\chapter{Códigos desenvolvidos para a simulação} \label{anexoA}

Neste anexo, encontram-se que os códigos utilizados para realizar todas as simulações numéricas. Todos os códigos estão na linguagem~C padrão.

\section{Arquivo Principal}

Nesta seção, apresenta-se a rotina principal desenvolvida.

\begin{verbatim}
#include <stdio.h>
#include <stdlib.h>

#include "TiposGerais.h"
#include "Inversor.h"
#include "Cargas.h"


int main()
{
    //variaveis de simulacao
    FILE *arq;
    float t, tmax, passo, hp, ts,svm_cont, svm_ang_eq, t1,t2,t0;
    int i, rel, cont,valor, rel_ts,j,k, cont2;

    //variaveis do circuito
    float fo, fs, Vdc, ma, Vp, R, L,h,val, idc,th;
    float vsin, vtriang1, vtriang2, vtriang, isin;
    int comand, comand1, comand2, svm_sec,rel_h, freq_type;
    SVM_modulation_parameters svm;
    chave_com Q;
    Voltage_sig V, V_ref;
    Current_sig I, I_ref;
    carga RL;
    cont2 = 0;
    k = 0;
    svm_sec = 1;
    svm_cont = 0.0;
    cont = 0;
    Q.q1a = 0;
    Q.q1b = 0;
    Q.q2a = 0;
    Q.q2b = 0;
    Q.q1c = 0;
    Q.q2c = 0;
    h = 0.005;
    V.vo = 0;
    I.io = 0;
    idc = 0.0;
    /*
     fo -> frequencia do sinal de saida
     fs -> frequencia de chaveamento
     Vdc -> tensão de barramento
     ma -> indice de modulação de amplitude
     Vp -> pico da portadora
     R,L -> resistência e indutância de carga
    */


    //inicializa variaveis de simulação
    t = 0;
    i = 0;

    arq = fopen("Saida.txt","w");
   // arq = fopen("Euler.txt","w");
    freq_type = LF;
    fs = 720.0*freq_type;
    fo = 60;
    passo = 0.00005/fs*freq_type;
    hp = 1.0/fs;
    ts = 1.0/fs;
    tmax = 0.1;
    rel = (int)(hp/passo);
    rel_ts = (int)(ts/passo);
    //inicializa variaveis de circuito
    th = 1.0/10000.0;
    rel_h = (int)(th/passo);
    Vdc = 400;
    ma = 0.8;
    Vp = 100;
    R = 1.2;
    L = 0.002;
    RL.R = R;
    RL.L = L;
    I.io = 0.00000;
    I.ia = 0.000;
    I.ib = 0.000;
    I.ic = 0.000;
    V_ref.vang = 0;

    svm.sec = 1;
    svm.ts = ts;
    svm.type_mod = SVM_AB;
 //   svm.type_mod = SVM_AB;
    svm.type_ref = TRIFASICO;
   // svm.type_ref = ESTACIONARIO;
    svm.t0 = ts/3.0;
    svm.t1 = ts/3.0;
    svm.t2 = ts/3.0;

  //  h = 5;

//entra na rotina do space vector a cada "rel" pontos
    for(t = 0; t<tmax; t= t+passo){
        i = i+1;
        if (i%rel == 0){
           k++;
        //modulacao space vector
        //geração do vetor de referência trifásico
            V_ref.va = ma*Vdc*sin(2*pi*fo*k*hp+pi/4);
            V_ref.vb = ma*Vdc*sin(2*pi*fo*k*hp-2*pi/3+pi/4);
            V_ref.vc = ma*Vdc*sin(2*pi*fo*k*hp+2*pi/3+pi/4);

            V_ref.vo = (maximo_V(V_ref)+minimo_V(V_ref))/2;

            V_ref.va = V_ref.va - V_ref.vo;
            V_ref.vb = V_ref.vb - V_ref.vo;
            V_ref.vc = V_ref.vc - V_ref.vo;
 
 //calcula modulação, tempos e define setor
            SVM_2N(&V_ref, &svm, Vdc);


         }
        contagem_tempos_SVMA(&svm, &Q, passo);
    /*    if(i%rel_h == 0){
         //histerese
            I_ref.ia = ma*Vp/R*cos(2*pi*fo*t);
            I_ref.ib = ma*Vp/R*cos(2*pi*fo*t-2*pi/3);
            I_ref.ic = ma*Vp/R*cos(2*pi*fo*t+2*pi/3);

            histerese(h, I, I_ref, &Q);
        }*/

        inversor_2N_trifasico(Vdc, Q, &V);
        circuito_RL_trifasico_equilibrado(V, RL, passo, &I);

        //exporta para arquivo de saída
        if(t>=tmax/2&&t<tmax/2+12/fs*freq_type){
            cont++;
            fprintf(arq, "%i %f %.1f %.1f %.1f %f
    %f %f %i %i % i\n",cont,t, V.va, V.vb, V.vc, 
  I.ia, I.ib, I.ic, Q.q1a, Q.q1b, Q.q1c);
          
        }

    }




    fclose(arq);
    printf("Hello world!\n");
    return 0;
}

\end{verbatim}

\section{Biblioteca de tipos e definições}

Nesta seção, apresenta-se a biblioteca que carrega os tipos de dados criados e definições gerais utilizadas em todo os códigos.

\begin{verbatim}
//constante pi
#define pi 3.14159

//estados lógicos
#define TRUE 1
#define FALSE 0

//operação do inversor
#define COMPLEMENTAR 1

//tipos de referência
#define TRIFASICO 0
#define ESTACIONARIO 1

//tipos de modulação
#define SVM_B   -1
#define SVM_A   1
#define SVM_AB  2

//tipo de angulo
#define sec_a 10
#define sec_b 20

//vetores
#define V0 0
#define V1 1
#define V2 2
#define V3 3
#define V4 4
#define V5 5
#define V6 6
#define V7 7

#define HF 10 //alta frequencia
#define LF 1 //baixa frequencia

//tipo de dado que contém informações da chave
// para inversores monofásicos, 
//trifásicos de dois e três níveis ou hexafásicos
typedef struct{
   int q1a, b1a;
   int q1b, b1b;
   int q2a, b2a;
   int q2b, b2b;
   int q1c, b1c;
   int q2c, b2c;
} chave_com, *pchave_com;

typedef struct{
   float va, vb, vc, vo;
   float valpha, vbeta, vmod, vang;

   /*
     va: tensão da fase a;
     vb: tensão da fase b;
     vc: tensão da fase c;
     vo: diferença de potencial aplicada à carga monofásico.
   */

}Voltage_sig, *pVoltage_sig;

typedef struct{
   float ia, ib, ic, io;

   /*
     ia: corrente da fase a;
     ib: corrente da fase b;
     ic: corrente da fase c;
     io: corrente aplicada à carga monofásico.
   */

}Current_sig, *pCurrent_sig;

//tipo de dado da carga
typedef struct{
    float R, L, tau;
} carga, *pcarga;

typedef struct{
    int sec, seg, type_mod, type_ref;
    float ang_eq, cont, t1, t2, t0, ts;
    //sec ->setor, seg -> segmento,
    // type_mod->tipo de referência,
    //type_ref->tipo de modulação
    //ang_eg->angulo equivalente para o primeiro setor
    //cont -> contador de tempo
    //t1 -> tempo do primeiro vetor
    //t2 -> tempo do segundo vetor 
    //t0 -> tempo do vetor nulo 
//os três anteriores são considerados 
//na metade do período de chaveamento
    //ts -> período de chaveamento

}SVM_modulation_parameters, *pSVM_modulation_parameters;


\end{verbatim}

\section{Simulação da Carga}

Nessa seção, apresenta-se o código C para simulação da carga e a sua respectiva biblioteca.

\subsection{Biblioteca com as funções da carga}

\begin{verbatim}
void cria_carga_monofasica(pcarga RL, float R, float L);

void circuito_RL_monofasico(Voltage_sig v, carga RL,
 float passo, pCurrent_sig i);

void circuito_RL_trifasico_equilibrado(Voltage_sig v, 
carga RL, float passo, pCurrent_sig i);

\end{verbatim}

\subsection{Arquivo em C com o código das funções da carga}

\begin{verbatim}
#include "TiposGerais.h"



void cria_carga_monofasica(pcarga RL, float R, float L){
    RL->R = R;
    RL->L = L;
    RL->tau = L/R;
}

void circuito_RL_monofasico(Voltage_sig v, carga RL,
 float passo, pCurrent_sig i){

    i->io = passo/RL.L*(-i->io*RL.R+v.vo)+i->io;

}

void circuito_RL_trifasico_equilibrado(Voltage_sig v,
 carga RL, float passo, pCurrent_sig i){

    float ias, ibs, ics, vas, vbs, vcs, L, R;
    L = RL.L;
    R = RL.R;

    ias = i->ia;
    ibs = i->ib;
    ics = i->ic;

    vas = v.va;
    vbs = v.vb;
    vcs = v.vc;

    i->ia = passo/L*(-ias*R+2*(vas-vbs)/3+(vbs-vcs)/3)+ias;
    i->ib = passo/L*(-ibs*R-(vas-vbs)/3+(vbs-vcs)/3)+ibs;
    i->ic = -i->ia-i->ib;

}
\end{verbatim}

\section{Simulação do inversor e da modulação}

Nessa seção, apresenta-se o código C para simulação do inversor e da modulação por vetores espaciais e a sua respectiva biblioteca.

\subsection[Biblioteca do inversor e da modulação]{Biblioteca com as funções do inversor e da modulação disponibilizadas para o arquivo principal}

\begin{verbatim}




extern float triangular(float ang);
extern int comparador(float a, float b);
extern int porta_inversora(int a);
extern float maximo_V(Voltage_sig v);
extern float minimo_V(Voltage_sig v);


extern void inversor_2N_monofasico(float Vdc, chave_com Q, 
pVoltage_sig v);

extern void inversor_2N_trifasico(float Vdc, chave_com Q,
 pVoltage_sig v);

extern void inversor_NPC_monofasico(float Vdc, chave_com Q, 
pVoltage_sig v);

extern void inversor_NPC_trifasico(float Vdc, chave_com Q, 
pVoltage_sig v);

extern void inversor_2N_trifasico_Krause(float Vdc, chave_com Q,
 pVoltage_sig v, Current_sig i, float*idc, int config);

extern void histerese(float h, Current_sig I, Current_sig I_ref,
 pchave_com Q);

extern void SVM_2N(pVoltage_sig V_ref, 
pSVM_modulation_parameters svm, float Vdc);

extern void contagem_tempos_SVMA(pSVM_modulation_parameters svm, 
pchave_com Q, float passo);


\end{verbatim}

\subsection[Códigos do inversor e da modulação]{Código com as funções do inversor, da modulação e funções internas}
 \tiny
\begin{verbatim}
#include "TiposGerais.h"



float triangular(float ang);
int comparador(float a, float b);


void inversor_2N_monofasico(float Vdc, chave_com Q, pVoltage_sig v);
void inversor_2N_trifasico(float Vdc, chave_com Q, pVoltage_sig v);
void inversor_NPC_monofasico(float Vdc, chave_com Q, pVoltage_sig v);
void inversor_NPC_trifasico(float Vdc, chave_com Q, pVoltage_sig v);
void bracoKrause(float Vdc, int q, int b, float *v, float i, float *idc);
void inversor_2N_trifasico_Krause(float Vdc, chave_com Q, pVoltage_sig v, Current_sig i, float*idc, int config);

void calcula_tempos_svm(pVoltage_sig V_ref, pSVM_modulation_parameters svm, float Vdc);
void calcula_tempos_svm2(pVoltage_sig V_ref, pSVM_modulation_parameters svm, float Vdc);
void clark_3F(pVoltage_sig V_ref);
void planar_para_retangular(pVoltage_sig V_ref);
void verifica_referencia(pVoltage_sig V_ref, pSVM_modulation_parameters svm);
void define_setor_2N(pVoltage_sig V_ref, pSVM_modulation_parameters svm);
void SVM_2N(pVoltage_sig V_ref, pSVM_modulation_parameters svm, float Vdc);

int matriz_vetores_2N_SVMA(int i, int j, int mod, float ang);
void atualiza_vetores_2N(int vec, pchave_com Q, pSVM_modulation_parameters svm);
void tabela_vetores_2N(pSVM_modulation_parameters svm, pchave_com Q);
void contagem_tempos_SVMA(pSVM_modulation_parameters svm, pchave_com Q, float passo);
void determina_segmento(pSVM_modulation_parameters svm);

float triangular(float ang){

     while(ang > 2*pi){
        ang = ang-2*pi;
     }
     while(ang < 0){
        ang = ang+2*pi;
     }

     if (ang<pi){
         return 2/pi*(ang)-1;
     }
     else{
         return -2/pi*(ang-pi)+1;
     }

}

int comparador(float a, float b){
     if(a>b)
        return TRUE;
     else
        return FALSE;

}

int porta_inversora(int a){
     if(a == TRUE)
        return FALSE;
     if(a == FALSE)
        return TRUE;

}

void inversor_2N_monofasico(float Vdc, chave_com Q, pVoltage_sig v){
/*
void inversor_2N_monofasico(float Vdc, chave_com Q, pVoltage_sig v)

Modelo simplificado de inversor NPC monofásico.
Considerações para uso:
- Carga balanceada e equilibrada;
- Chaves e diodos ideais.

Vdc - > tensão do barramento DC
Q -> vetor de comando das chaves superiores, na ordem [q1a, q1b, q2a, q2b]
v_out -> tensões nos pontos de saída, para alimentação do motor vo = v.vo

Conferir: Advanced Power Electronics Converters:PWM Converters Processing AC Voltages
*/

   v->vo = (Q.q1a-Q.q1b)*Vdc;

}

void inversor_2N_trifasico(float Vdc, chave_com Q, pVoltage_sig v){
/*
void inversor_2N_monofasico(float Vdc, chave_com Q, pVoltage_sig v)

Modelo simplificado de inversor NPC monofásico.
Considerações para uso:
- Carga balanceada e equilibrada;
- Chaves e diodos ideais.

Vdc - > tensão do barramento DC
Q -> vetor de comando das chaves superiores, na ordem [q1a, q1b, q2a, q2b]
v_out -> tensões nos pontos de saída, para alimentação do motor vo = v.vo

Conferir: Advanced Power Electronics Converters:PWM Converters Processing AC Voltages
*/
     v->va =  Vdc*(2.0/3.0*(Q.q1a)-1.0/3.0*(Q.q1b+Q.q1c));
     v->vb =  Vdc*(2.0/3.0*(Q.q1b)-1.0/3.0*(Q.q1a+Q.q1c));
     v->vc =  Vdc*(2.0/3.0*(Q.q1c)-1.0/3.0*(Q.q1a+Q.q1b));

}
void bracoKrause(float Vdc, int q, int b, float *v, float i, float *idc){
        float vsw = 0, vd = 0;

        if(q == 1 && b == 0){
            if(i>0)
               *v = Vdc-vsw;
            if(i<0)
               *v = Vdc+vd;
            if(i == 0)
               *v = Vdc;
            *idc = i;
        }
        if(q == 0 && b == 1){
            if(i>0)
               *v = -vd;
            if(i<0)
               *v = vsw;
            if(i == 0)
               *v = 0;
            *idc = 0;
        }
        if(q == 0 && b == 0){
            *idc = 0;
            if(i>0)
               *v = -vd;
            if(i<0){
               *v = Vdc+vd;
               *idc = i;
            }
            if(i == 0)
               *v = 0;
        }
}

void inversor_2N_trifasico_Krause(float Vdc, chave_com Q, pVoltage_sig v, Current_sig i, float*idc, int config){

     float vag, vbg, vcg, iadc, ibdc, icdc;
     vag = 0.000; vbg = 0.000; vcg = 0.000;
     iadc = 0.100; ibdc = 0.000; icdc = 0.000;

     if(config == COMPLEMENTAR){
        Q.b1a = porta_inversora(Q.q1a);
        Q.b1b = porta_inversora(Q.q1b);
        Q.b1c = porta_inversora(Q.q1c);
     }


    bracoKrause(Vdc, Q.q1a, Q.b1a, &vag, i.ia, &iadc);
    bracoKrause(Vdc, Q.q1b, Q.b1b, &vbg, i.ib, &ibdc);
    bracoKrause(Vdc, Q.q1c, Q.b1c, &vcg, i.ic, &icdc);

    *idc = iadc+ibdc+icdc;

    v->va = 2.0/3.0*vag-1.0/3.0*vbg-1.0/3.0*vcg;
    v->vb = 2.0/3.0*vbg-1.0/3.0*vag-1.0/3.0*vcg;
    v->vc = 2.0/3.0*vcg-1.0/3.0*vbg-1.0/3.0*vag;
}

void inversor_NPC_monofasico(float Vdc, chave_com Q, pVoltage_sig v){
/*
void inversor_NPC_monofasico(float Vdc, chave_com Q, pVoltage_sig v)

Modelo simplificado de inversor NPC monofásico.
Considerações para uso:
- Carga balanceada e equilibrada;
- Chaves e diodos ideais.

Vdc - > tensão do barramento DC
Q -> vetor de comando das chaves superiores, na ordem [q1a, q1b, q2a, q2b]
v_out -> tensões nos pontos de saída, para alimentação do motor vo = v.vo

Conferir: Advanced Power Electronics Converters:PWM Converters Processing AC Voltages
*/

    v->vo = (Q.q1a+Q.q2a-Q.q1b-Q.q2b)*Vdc;

}

void inversor_NPC_trifasico(float Vdc, chave_com Q, pVoltage_sig v){
/*
void inversor_NPC_trifasico(float Vdc, chave_com Q, pVoltage_sig v)

Modelo simplificado de inversor NPC trifásico.
Considerações para uso:
- Carga balanceada e equilibrada;
- Chaves e diodos ideais.


Vdc - > tensão do barramento DC
Q -> vetor de comando das chaves superiores, na ordem [1a, 1b, 2a, 2b, 3a, 3b]
v_out -> tensões nos pontos de saída, para alimentação do motor va = v_out, vb = v_out, vc =

Conferir: Advanced Power Electronics Converters:PWM Converters Processing AC Voltages
*/

     v->va =  Vdc*(2/3*(Q.q1a+Q.q2a)-1/3*(Q.q1b+Q.q2b+Q.q1c+Q.q2c));
     v->vb =  Vdc*(2/3*(Q.q1b+Q.q2b)-1/3*(Q.q1a+Q.q2a+Q.q1c+Q.q2c));
     v->vc =  Vdc*(2/3*(Q.q1c+Q.q2c)-1/3*(Q.q1a+Q.q2a+Q.q1b+Q.q2b));
}

void histerese(float h, Current_sig I, Current_sig I_ref, pchave_com Q){

  //  isin = ma*Vp/R*cos(2*pi*fo*t);
      float ia_ref, ib_ref, ic_ref;
      ia_ref = I_ref.ia;
      ib_ref = I_ref.ib;
      ic_ref = I_ref.ic;


            if(I.ia > ia_ref+h){
                Q->q1a = FALSE;
                Q->b1a = TRUE;
            }

            if(I.ia < ia_ref-h){
                Q->q1a = TRUE;
                Q->b1a = FALSE;
            }

            if(I.ib > ib_ref+h){
                Q->q1b = FALSE;
                Q->b1b = TRUE;
            }

            if(I.ib < ib_ref-h){
                Q->q1b = TRUE;
                Q->b1b = FALSE;
            }


            if(I.ic > ic_ref+h){
                Q->q1c = FALSE;
                Q->b1c = TRUE;
            }

            if(I.ic < ic_ref-h){
                Q->q1c = TRUE;
                Q->b1c = FALSE;
            }

}
void SVM_2N(pVoltage_sig V_ref, pSVM_modulation_parameters svm, float Vdc){
    verifica_referencia(V_ref,svm);//rotinas para detectar o modulo e o angulo do vetor de referencias
    define_setor_2N(V_ref, svm);//permite criar 6 (60º) ou 12(30º) setores dependendo do tipo de modulação escolhida
    calcula_tempos_svm(V_ref, svm, Vdc);//define tempos conforme fórmula dos slides do Batschauer, valem para o primeiro quadrante
 }
void calcula_tempos_svm(pVoltage_sig V_ref, pSVM_modulation_parameters svm, float Vdc){
    float m, ang;
    int mod, i;
    m = V_ref->vmod/Vdc;
    i = svm->sec;
    mod = svm->type_mod;
    ang = svm->ang_eq;
//    if(mod == SVM_AB){
//        if(svm->ang_eq < pi/6 && svm->sec%2 == 1)
//            mod = SVM_A;
//        if(svm->ang_eq > pi/6 && svm->sec%2 == 0)
//            mod = SVM_A;
//        if(svm->ang_eq < pi/6 && svm->sec%2 == 0)
//            mod = SVM_B;
//        if(svm->ang_eq > pi/6 && svm->sec%2 == 1)
//            mod = SVM_B;
//    }
   if(mod == SVM_AB){
        if(svm->sec%2==1&&ang<pi/6){
          mod = SVM_A;
     //     printf("ang_eq = %f, sec = %i\n",ang*180/pi,svm->sec);
        }
        if(svm->sec%2==1&&ang>pi/6){
          mod = SVM_B;
     //     printf("ang_eq = %f, sec = %i\n",ang*180/pi,svm->sec);
        }
        if(svm->sec%2==0&&ang<pi/6){
          mod = SVM_B;
     //     printf("ang_eq = %f, sec = %i\n",ang*180/pi,svm->sec);
        }
        if(svm->sec%2==0&&ang>pi/6){
          mod = SVM_A;
     //     printf("ang_eq = %f, sec = %i\n",ang*180/pi,svm->sec);
        }
 //       if(ang<pi/6) mod = SVM_A;
 //       else  mod = SVM_B;
 //        if(i%2==1) mod = SVM_A;
 //        else  mod = SVM_B;
   //       mod = SVM_A;
    }



      if(mod == SVM_A){
 //       if (svm->sec%2==1){
          svm->t1 = m*svm->ts/2*(cos(svm->ang_eq)-sin(svm->ang_eq)/(sqrt(3)));
          svm->t2 = m*svm->ts*sin(svm->ang_eq)/(sqrt(3));
 //       }
 //       else{
 //         svm->t2 = m*svm->ts/2*(cos(svm->ang_eq)-sin(svm->ang_eq)/(sqrt(3)));
 //         svm->t1 = m*svm->ts*sin(svm->ang_eq)/(sqrt(3));
 //       }
      }
      if(mod == SVM_B){
    //    if (svm->sec%2==0){
    //      svm->t1 = m*svm->ts/2*(cos(svm->ang_eq)-sin(svm->ang_eq)/(sqrt(3)));
    //      svm->t2 = m*svm->ts*sin(svm->ang_eq)/(sqrt(3));
    //    }
    //    else{
          svm->t2 = m*svm->ts/2*(cos(svm->ang_eq)-sin(svm->ang_eq)/(sqrt(3)));
          svm->t1 = m*svm->ts*sin(svm->ang_eq)/(sqrt(3));
     //   }
      }

    svm->t0 = svm->ts/2-svm->t1-svm->t2;
   //  printf("ang = %f\n", svm->ang_eq);
   // printf("ts = %f, t0 = %f, t1 = %f, t2 = %f\n",svm->ts, svm->t0,svm->t1,svm->t2);

}

void clark_3F(pVoltage_sig V_ref){

         V_ref->valpha = 2.0/3.0*(V_ref->va-0.5*V_ref->vb-0.5*V_ref->vc);
         V_ref->vbeta = 2.0/3.0*(sqrt(3.0)/2*V_ref->vb-sqrt(3.0)/2*V_ref->vc);

}
void planar_para_polar(pVoltage_sig V_ref){
        V_ref->vmod = sqrt(V_ref->valpha*V_ref->valpha+V_ref->vbeta*V_ref->vbeta);
        V_ref->vang = atan2(V_ref->vbeta,V_ref->valpha);

          //deixa o angulo entre 0 e 2*pi
         if(V_ref->vang<0)
            V_ref->vang = V_ref->vang+2*pi;

}

void verifica_referencia(pVoltage_sig V_ref, pSVM_modulation_parameters svm){
     if(svm->type_ref == TRIFASICO){//no caso da referencia ser dada em coordenadas trifásicas
         clark_3F(V_ref);//faz a transformada de clark
         planar_para_polar(V_ref);//calcula o módulo e a fase do vetor
     }
     if(svm->type_ref == ESTACIONARIO){//no caso da referência ser dada em coordenadas estacionárias
         planar_para_polar(V_ref);//calcula o módulo e a fase do vetor
     }
}

void define_setor_2N(pVoltage_sig V_ref, pSVM_modulation_parameters svm){

     int j, t;
     t = 0;

     for(j = 1;j<=6;j++){
            //verifica em que setor o angulo se encontra

 //       if(svm->type_mod == SVM_A){
            if(V_ref->vang >= (j-1.0)*pi/3.0 && V_ref->vang < j*pi/3.0){
               svm->sec = j; //define o setor
               if(j%2 == 1)
                  svm->ang_eq = V_ref->vang-(j-1.0)*pi/3.0; //define o angulo equivalente do primeiro quadrante
                                                  //nesse caso, mesmo para setores de 30º, o valor é pi/3 mesmo na conta
               if(j%2 == 0){
                  svm->ang_eq = -V_ref->vang+j*pi/3.0;
               }

               break; //sai do "for" após encontrar o setor
            }
   //     }
//        else{
//            if(j%2 == 1)
//               t++;
//
//            if(V_ref->vang >= (j-1)*pi/6 && V_ref->vang < j*pi/6){
//               svm->sec = j; //define o setor
//               svm->ang_eq = V_ref->vang-(t-1)*pi/3; //define o angulo equivalente do primeiro quadrante
//                                                  //nesse caso, mesmo para setores de 30º, o valor é pi/3 mesmo na conta
//               break; //sai do "for" após encontrar o setor
//            }
//
//        }

    }
    //printf("sec = %i, ang = %f, ang_eq = %f\n",svm->sec,V_ref->vang*180.0/pi,svm->ang_eq*180.0/pi);
   /*  for(j = 1;j<=6;j++){
            //verifica em que setor o angulo se encontra
        if(V_ref->vang >= (j-1)*pi/3 && V_ref->vang < j*pi/3){
            svm->sec = j; //define o setor
            svm->ang_eq = V_ref->vang-(j-1)*pi/3; //define o angulo equivalente do primeiro quadrante
                                                  //nesse caso, mesmo para setores de 30º, o valor é pi/3 mesmo na conta
            break; //sai do "for" após encontrar o setor
        }
    }*/


}

int matriz_vetores_2N_SVMA(int i, int j, int mod, float ang){//i:svm->sec, j:svm->seg (conferir slide 30 aula 2)
       //     printf("sec = i = %i, seg = j = %i\n",i,j);
       if(mod == SVM_AB){
        if(i%2==1&&ang<pi/6){
          mod = SVM_A;
     //     printf("i = %i, ang = %f\n",i,ang*180/pi);
        }
        if(i%2==1&&ang>pi/6){
          mod = SVM_B;
     //     printf("i = %i, ang = %f\n",i,ang*180/pi);
        }
        if(i%2==0&&ang<pi/6){
          mod = SVM_B;
     //     printf("i = %i, ang = %f\n",i,ang*180/pi);
        }
        if(i%2==0&&ang>pi/6){
          mod = SVM_A;
     //     printf("i = %i, ang = %f\n",i,ang*180/pi);
        }
//         if(ang<pi/6) mod = SVM_A;
//         else  mod = SVM_B;
 //        if(i%2==1) mod = SVM_A;
 //        else  mod = SVM_B;

       }


       if(mod == SVM_A){
           if(j == 1 || j == 7) return V0;
           if(j == 4) return V7;
           if(j == 3 || j == 5){
                if(i<=2) return V2;
                if(i<=4) return V4;
                return V6;
            }
            if(j == 2 || j == 6){

                if(i == 5 || i == 4)  return V5;
                if(i == 1 || i == 6)  return V1;
                if(i == 2 || i == 3)  return V3;

            }
       }
       if(mod == SVM_B){
           if(j == 1 || j == 7) return V7;
           if(j == 4) return V0;
           if(j == 2 || j == 6){
                if(i<=2) return V2;
                if(i<=4) return V4;
                return V6;
            }
            if(j == 3 || j == 5){

                if(i == 5 || i == 4)  return V5;
                if(i == 1 || i == 6)  return V1;
                return V3;

            }
       }
}
void atualiza_vetores_2N(int vec, pchave_com Q,pSVM_modulation_parameters svm){
    int val, ang, sec;
    val = svm->type_mod;
    sec = svm->sec;

    if(svm->ang_eq<pi/6) ang = sec_a;
    else  ang = sec_b;

     switch(vec){
            case V0:
               Q->q1a = FALSE; Q->q1b = FALSE; Q->q1c = FALSE;
            break;
            case V1:
               Q->q1a = TRUE; Q->q1b = FALSE; Q->q1c = FALSE;
            break;
            case V2:
               Q->q1a = TRUE; Q->q1b = TRUE; Q->q1c = FALSE;
            break;
            case V3:
               Q->q1a = FALSE; Q->q1b = TRUE; Q->q1c = FALSE;
            break;
            case V4:
               Q->q1a = FALSE; Q->q1b = TRUE; Q->q1c = TRUE;
            break;
            case V5:
               Q->q1a = FALSE; Q->q1b = FALSE; Q->q1c = TRUE;
            break;
            case V6:
               Q->q1a = TRUE; Q->q1b = FALSE; Q->q1c = TRUE;
            break;
            case V7:
               Q->q1a = TRUE; Q->q1b = TRUE; Q->q1c = TRUE;
            break;
       }

}

void tabela_vetores_2N(pSVM_modulation_parameters svm, pchave_com Q){
        int vec;
        vec = matriz_vetores_2N_SVMA(svm->sec, svm->seg, svm->type_mod, svm->ang_eq);
        atualiza_vetores_2N(vec, Q, svm);
}
void determina_segmento(pSVM_modulation_parameters svm){
    float limite[8];
    int i;
    limite[0] = 0.0;
    limite[1] = limite[0]+svm->t0/2;
    limite[2] = limite[1]+svm->t1;
    limite[3] = limite[2]+svm->t2;
    limite[4] = limite[3]+svm->t0;
    limite[5] = limite[4]+svm->t2;
    limite[6] = limite[5]+svm->t1;
    limite[7] = limite[6]+svm->t0/2;


        if(svm->cont >= limite[0] && svm->cont < limite[1])
            svm->seg = 1;
        if(svm->cont >= limite[1] && svm->cont < limite[2])
            svm->seg = 2;
        if(svm->cont >= limite[2] && svm->cont < limite[3])
            svm->seg = 3;
        if(svm->cont >= limite[3] && svm->cont < limite[4])
            svm->seg = 4;
        if(svm->cont >= limite[4] && svm->cont < limite[5])
            svm->seg = 5;
        if(svm->cont >= limite[5] && svm->cont < limite[6])
            svm->seg = 6;
        if(svm->cont >= limite[6] && svm->cont < limite[7])
            svm->seg = 7;
}
void contagem_tempos_SVMA(pSVM_modulation_parameters svm, pchave_com Q, float passo){
         svm->cont = svm->cont+passo; //atualiza contagem de tempo

         if(svm->cont>=svm->ts) //reinicia a contagem de tempo caso passe do período de chaveamento
            svm->cont = 0.0;

         determina_segmento(svm); //define segmentos
         tabela_vetores_2N(svm, Q); //determina vetor espacial atual

}

float maximo_V(Voltage_sig v){
     float maxi;

     if(v.va > v.vb)
        maxi = v.va;
     else
        maxi = v.vb;

     if(v.vc>maxi)
        maxi = v.vc;

     return maxi;

}

float minimo_V(Voltage_sig v){
     float maxi;

     if(v.va < v.vb)
        maxi = v.va;
     else
        maxi = v.vb;

     if(v.vc<maxi)
        maxi = v.vc;

     return maxi;

}

\end{verbatim}