Para a etapa de resultados experimentais foram usados: o kit de desenvolvimento em FPGA, um conversor DA R-2R de 8 bits, 3 filtros passa-baixas RC e um osciloscópio, assim como mostrado na Figura 35.
A parte real do vetor de referência foi amostrado utilizando-se o conversor DA. Os resultados do experimento, presentes na Figura 36, mostram o correto funcionamento do algoritmo, visto que o sinal amostrado é senoidal, com frequência em torno de 60 Hz, e amplitude constante.
Figura 35 - Montagem feita para obtenção dos resultados experimentais.
Fonte: Próprio autor.
A variável que indica o sextante atual também foi amostrada pelo conversor DA, como pode ser visto na Figura 37. A forma de onda observada está em consonância com o correto funcionamento do código, visto ser idêntico às formas de ondas desta variável antes vistas e possuir a mesma frequência da Figura 36.
Para verificar como o código sendo executado dentro do FPGA calcula as sequencias de chaveamento, foram obtidas imagens do período de comutação com a referência senoidal inerte para cada um dos sextantes. Tais dados, como vistos na Figura 38 - Sequências de chaveamento para cada sextante., mostram o correto funcionamento da modulação contínua simétrica. É possível notar que a sequência de vetores ativos segue corretamente as indicações da Tabela 1.
Para a frequência de chaveamento foi escolhido o valor de 83kHz. deve-se observar que qualquer valor suficientemente longe da frequência da referência senoidal poderá ser usado sem perda de generalidade.
Figura 37 - Definição do sextante atual observado.
Entre cada um dos 3 pinos da saída do algoritmo e o GND do FPGA foi incluso um filtro passa-baixas. Cada filtro é constituído de 2 resistores de 470 Ω em série e um capacitor de 1uF. Com tais valores, a frequência de corte do filtro usado é:
𝑓𝑐 = 1 𝑅. 𝐶 =
1
940.10−6 = 1063 𝐻𝑧 ( 28 )
Tal valor se encontra mais de uma década acima da frequência que se deseja manter intacta (60 Hz) e mais de uma década abaixo das frequências das harmônicas indesejadas, sendo assim, capaz de oferecer em sua saída os sinais senoidais trifásicos desejados, como pode ser visto na Figura 39.
Figura 38 - Sequências de chaveamento para cada sextante.
Nesta figura é possível notar a correta defasagem angular entre as três fases do sistema, além da igualdade de suas amplitudes e a periodicidade do sinal. É percebível também a presença da componente de terceira harmônica, intrínseca ao método da modulação vetorial.
Tal componente está presente apenas nos sinais de tensão de fase, visto que, para tensões de linha, essas componentes irão se cancelar, gerando uma forma de onda perfeitamente senoidal na saída, assim como visto na Figura 40. Foi usada a função de subtração do osciloscópio para simular a tensão de linha resultante no conversor.
Figura 39 - Sinais de tensão após o filtro RC.
Figura 40 - Anulação da terceira harmônica. Fonte: Próprio autor.
6 CONCLUSÃO
Para o presente trabalho foi realiza uma vasta revisão bibliográfica sobre FPGAs e modulações PWM, e com os conhecimentos adquiridos a implementação de uma técnica de modulação vetorial para inversores de frequência, trifásicos com 2 níveis, foi discutida e realizada em FPGA, sem o uso de memória externa. Foram evidenciadas as características da implementação em nível de hardware, como a falta da representação numérica em ponto flutuante, que pôde ser superada pelo uso da notação em ponto Q, e a ausência de funções matemáticas complexas, sendo necessário o uso de métodos numéricos adequados para avaliar tais funções não contidas na linguagem.
A implementação criada foi simulada em dois softwares diferentes e medições experimentais foram realizadas, todas em consonância com o correto funcionamento do conversor, como foi evidenciado no capítulo 5, no qual percebe-se que a criação programática da referência senoidal, a definição do sextante atual e o cálculo do tempo de cada vetor ocorrem corretamente.
Por fim, fica evidenciada a viabilidade da implementação de algoritmos de modulação para conversores de potência usando FPGAs.
7 REFERÊNCIAS
.
ARAR, S. Fixed-Point Representation: The Q Format and Addition Examples - Technical
Articles. Disponível em: <https://www.allaboutcircuits.com/technical-articles/fixed-point-
representation-the-q-format-and-addition-examples/>. Acesso em: 24 out. 2019.
DAGOBERTO ADRIANO RIZZOTTO JUSTO - UFRGS et al. Cálculo Numérico. [s.l: s.n.].
DÁRIO, V. et al. Análise Comparativa das Técnicas SPWM e SVM Aplicadas a um Inversor de Tensão Trifásico Comparative Analysis between SPWM and SVM Techniques applied to a Three-Phase Voltage. 2000.
GOMES, L. Introdução ao VHDL. p. 1–19, 2002.
HOLMES, D. G.; LIPO, T. A. Pulse Width Modulation for Power Converters. [s.l: s.n.].
ISLAM, M. A. et al. Field oriented space vector pulse width modulation control of permanent magnet brushless DC motor. 5th IEEE Region 10 Humanitarian Technology Conference
2017, R10-HTC 2017, v. 2018-Janua, n. 1, p. 322–327, 2018.
NEACSU, D. O.; IASI, G. A. T. U. OF. SPACE VECTOR MODULATION – An Introduction == Tutorial at IECON2001 ==. v. 00, n. 2, p. 1583–1592, 2001.
TZOU, Y. Y.; HSU, H. J.; KUO, T. S. FPGA-based SVPWM control IC for 3-phase PWM inverters. IECON Proceedings (Industrial Electronics Conference), v. 1, p. 138–143, 1996.
ANEXO A
Código em VHDL para modulação vetorial library ieee;
use ieee.std_logic_1164.all; entity Modulacao is modulacao
port (
saidaA : out std_logic; saidaB : out std_logic; saidaC : out std_logic; clkin : in std_logic;
VAx : out integer range -1023 to 1023:= 0; -- Iint10 VAy : out integer range -1023 to 1023:= 0; -- Iint10 VBx : out integer range -1023 to 1023:= 0; -- Iint10 VBy : out integer range -1023 to 1023:= 0; -- Iint10 VCx : out integer range -1023 to 1023:= 0; -- Iint10 VCy : out integer range -1023 to 1023:= 0 -- Iint10 );
end Modulacao;
architecture teste of Modulacao is
-- Variáveis para os divisores de frequeêcia --
signal ClockSenoide : std_logic := '0'; -- freq senoide = fre oscilador / ( 23610*2* divFreqSen) signal divFreqSen : integer range 0 to 65535 := 12000; -- Uint16
signal ClockModulacao : std_logic := '0';-- freq modulação = fre oscilador / ( 300*2* divFreqMod) signal divFreqMod : integer range 0 to 65535 := 10; -- Uint16
-- Variáveis para a referencia senoidal--
signal posicaoX : integer range -65535 to 65535:= 0; -- Iint16 signal posicaoY : integer range -65535 to 65535:= 0; -- Iint16 signal posicaoX2 : integer range -65535 to 65535:= 0; -- Iint16 signal posicaoY2 : integer range -65535 to 65535:= 0; -- Iint16 signal velocidadeX : integer range -65535 to 65535:= 0; -- Iint16 signal velocidadeY : integer range -65535 to 65535:= 0; -- Iint16 signal raioAoQuadrado: integer range 0 to 1048575 := 0; -- Uint20 constant raioBase : integer range 0 to 1023 := 220;-- Uint10 signal raiz : integer range 0 to 65535 := 16; -- Uint16 signal raizPassada : integer range 0 to 65535 := 16; -- Uint16
signal delta : integer := 16; -- Uint16 -- Variáveis para a modulação vetorial simétrica-- signal iteracao : integer range 0 to 15 := 0; signal vcc : integer := 300 * 32 ;
signal divisorFreq : integer := 300; -- TS signal contfreq : integer := 0;
signal estado1 : integer := 0; signal tempoestado1 : integer := 0; signal estado2 : integer := 0; signal tempoestado2 : integer := 0; signal estado3 : integer := 0; signal tempoestado3 : integer := 0; signal estado4 : integer := 3; signal tempoestado4 : integer := 0; signal estado5 : integer := 0; signal tempoestado5 : integer := 0; signal estado6 : integer := 0; signal tempoestado6 : integer := 0; signal estado7 : integer := 0; signal tempoestado7 : integer := 0; signal estado8 : integer := 0; signal tempoestado8 : integer := 0; signal estadoatual : integer := 0 ;
signal sextanteAtual : integer range 1 to 6 := 1; signal contagem : integer := 0;
-- Variáveis extras--
constant q : integer range 0 to 255 := 32; -- Uint8 begin
-- Para a fase B, só é necessário realizar a rotação em 120 graus ccw, pelo uso da matriz de rotação VBx <= -( posicaoX + ((posicaoY * 1774)/ 1024) )/ (2*q);
VBy <= ( ((posicaox * 1774)/ 1024) - posicaoy )/ (2*q); -- Idem para fase C, porém com angulo de 240 graus VCx <= ( ((posicaoY * 1774)/ 1024) - posicaoX )/ (2*q); VCy <= -( ((posicaox * 1774)/ 1024) + posicaoy )/ (2*q);
---
--- Processo que calcula o sinal de clock para o proceso da seinóide --- ---
clock2Senoide : process (clkin)
variable cont : integer range 0 to 1048575 := 0; -- Uint20 begin
if(clkin'event and clkin='1') then cont := cont +1;
if cont >= divFreqSen then
ClockSenoide <=not (ClockSenoide); cont :=0;
end if; end if;
end process;
---
--- Processo que calcula o sinal de clock para o proceso de modulação --- ---
clock2Modulacao : process (clkin)
variable contMod : integer range 0 to 65535:= 0; -- Iint16 begin
if(clkin'event and clkin='1') then
if contMod >= divFreqMod then
clockModulacao <=not (clockModulacao); contMod :=0;
end if; end if;
end process;
--- ---
--- Processo que gera a referência senoidal para a modulação --- --- ---
process (ClockSenoide)
variable iteracao : integer range 0 to 15:= 0; -- Uint4 begin
if(ClockSenoide'event and ClockSenoide='1') then
case iteracao is when 0 => posicaoX <= raioBase * q ; posicaoY <= 0; iteracao := iteracao + 1; when 1 =>
velocidadeX <= - posicaoY / 512;
velocidadeY <= posicaoX / 512 ;
iteracao := iteracao + 1;
when 2 =>
posicaoX <= posicaoX + velocidadeX; posicaoY <= posicaoY + velocidadeY; iteracao := iteracao + 1;
when 3 =>
raioAoQuadrado <= (((posicaoX ) * (posicaoX ) + (posicaoy ) * (posicaoy ))) / ( q *q); -- *q duas veses
iteracao := iteracao + 1; when 4 =>
if raizPassada /= 0 then
raiz <= raizPassada - (
raizPassada * raizPassada - raioAoQuadrado )/(2 * raizPassada );
iteracao := iteracao + 1; when 5 => if raiz /= 0 then posicaoX2 <= (posicaoX * raioBase) / raiz ; posicaoy2 <= (posicaoy * raioBase) / raiz ; end if; iteracao := iteracao + 1; when 6 =>
if raiz > 150 and raiz < 250 and raiz = raizPassada then -- ageitar isso aki
posicaoX <= posicaoX2 ; posicaoy <= posicaoy2 ; raizPassada <= 1; raiz <= 1;
end if ;
iteracao := iteracao + 1; when 7 => raizPassada <= raiz; VAx <= posicaoX / q ; VAy <= posicaoY / q; iteracao := 1;
When others => null ;
end case;
end if;
end process;
--- ---
--- Processo que gera calcula os tempos de cada palavra e executa a modulação --- --- ---
process (clockModulacao) begin
if contfreq > divisorFreq then contfreq <= 0; else contfreq <= contfreq + 1; end if; estado1 <= 0; estado4 <= 7; estado5 <= 7; estado8 <= 0;
if ( posicaoX > 0 and posicaoY > 0 and posicaoY * q < 55 * posicaoX ) then sextanteatual <= 1;
estado2 <= 4; estado3 <= 6; estado6 <= estado3; estado7 <= estado2;
tempoestado3 <= posicaoY * divisorfreq / ( 2 *vcc * 866 / 1000);
tempoestado6 <= posicaoY * divisorfreq / ( 2 *vcc * 866 / 1000);
tempoestado2 <= ((posicaoX * divisorfreq / vcc) - tempoestado3) / 2 ;
tempoestado7 <= ((posicaoX * divisorfreq / vcc) - tempoestado3) / 2 ;
elsif ( posicaoX > 0 and posicaoY > 0 and posicaoY * q > 55 * posicaoX ) then sextanteatual <= 2; estado2 <= 2; estado3 <= 6; estado6 <= estado3; estado7 <= estado2; tempoestado2 <= ((divisorfreq / 2 )* ( (posicaoY * 1000 - posicaoX * 1732 ) ) / ( vcc * 1732 )) ; tempoestado6 <= tempoestado3 ;
tempoestado3 <= ( posicaoX * 2 * divisorfreq / (vcc ) + 2 * tempoestado2 ) / 2;
tempoestado7 <= tempoestado2;
elsif ( posicaoX < 0 and posicaoY > 0 and posicaoY *q > -55 * posicaoX ) then
sextanteatual <= 2; --estado1 <= 0; estado2 <= 2; estado3 <= 6; --estado4 <= 7; --estado5 <= 7; estado6 <= 6; estado7 <= 2; --estado8 <= 0; tempoestado2 <= ((divisorfreq / 2 )* ( (posicaoY * 1000 - posicaoX * 1732 ) ) / ( vcc * 1732 )) ; tempoestado7 <= tempoestado2; tempoestado3 <= (posicaoX * 2 * divisorfreq/(vcc ) + 2 * tempoestado2) / 2; tempoestado6 <= tempoestado3 ;
elsif ( posicaoX < 0 and posicaoY > 0 and posicaoY *q < - 55 * posicaoX ) then sextanteatual <=3; estado2 <= 2; estado3 <= 3; estado6 <= estado3; estado7 <= estado2;
tempoestado2 <= (posicaoY * divisorfreq * 1000 / ( vcc * (866 )))/ 2 ; tempoestado6 <= tempoestado3; tempoestado3 <= (( - posicaoX * divisorfreq / vcc) - tempoestado2) / 2; tempoestado7 <= tempoestado2;
ELSif posicaoX < 0 AND posicaoY < 0 AND posicaoY * q > 55 * posicaoX THEn sextanteatual <= 4; estado2 <= 1; estado3 <= 3; estado6 <= estado3; estado7 <= estado2;
tempoestado2 <= (-posicaoY * divisorfreq * 1000 / ( vcc * (866 ) )) / 2;
tempoestado7 <= tempoestado2;
tempoestado3 <= (( - posicaoX * divisorfreq / vcc) - tempoestado2) / 2;
elsif posicaoX < 0 and posicaoY < 0 and posicaoY * q < (55 ) * posicaoX then sextanteatual <= 5; estado2 <= 1; estado3 <= 5; estado6 <= estado3; estado7 <= estado2; --//// no sextante 5 é invertido do 2 tempoestado3 <= ((divisorfreq / 2 )* ( ( posicaoX * 1732 - posicaoY * 1000 ) ) / ( vcc * 1732 )) ; -- tempoestado3 <= (divisorfreq*( - posicaoY + (1732/ 1000)* posicaoX )/ ( vcc * (1732/1000) ))/2; tempoestado6 <= tempoestado3 ; tempoestado2 <= (- posicaoX * 2 * divisorfreq / (vcc ) + 2 * tempoestado3 )/ 2; tempoestado7 <= tempoestado2;
elsif posicaoX > 0 and posicaoY < 0 and posicaoY *q < - (55) * posicaoX then
sextanteatual <=5;
estado3 <= 5; estado6 <= estado3; estado7 <= estado2; tempoestado3 <= ((divisorfreq / 2 )* ( ( posicaoX * 1732 - posicaoY * 1000 ) ) / ( vcc * 1732 )) ; -- tempoestado3
<= (divisorfreq*( - posicaoY + (1732 / 1000)* posicaoX )/ ( vcc * (1732/1000) ))/2;
--/// o dois da equaçao 3 linha erh porque eu ja dividi o tempo em dois pra modulacao simetrica
tempoestado6 <= tempoestado3 ;
tempoestado2 <= (- posicaoX * 2 * divisorfreq/(vcc ) + 2 * tempoestado3) / 2;
tempoestado7 <= tempoestado2;
elsif ( posicaoX > 0 and posicaoY < 0 and posicaoY * q > -55 * posicaoX ) then
estado2 <= 4; estado3 <= 5; estado6 <= estado3; estado7 <= estado2;
tempoestado3 <= (- posicaoY * divisorfreq * 1000 / ( vcc * (866) ))/2; tempoestado6 <= tempoestado3;
tempoestado2 <= ((posicaoX * divisorfreq / vcc) - tempoestado3)/2; tempoestado7 <= tempoestado2;
end if;
tempoestado1 <= (divisorfreq - 2*tempoestado2 - 2*tempoestado3) / 4;
tempoestado4 <= tempoestado1; tempoestado5 <= tempoestado1; tempoestado8 <= tempoestado1;
if (contfreq < tempoestado1 )then estadoatual <= estado1;
elsif ( contfreq < tempoestado1 + tempoestado2 )then estadoatual <= estado2;
elsif ( contfreq < tempoestado1 + tempoestado2+ tempoestado3 )then estadoatual <= estado3;
elsif ( contfreq < tempoestado1 + tempoestado2+ tempoestado3+ tempoestado4 )then estadoatual <= estado4;
elsif ( contfreq < tempoestado1 + tempoestado2+ tempoestado3+ tempoestado4+ tempoestado5 )then estadoatual <= estado5;
elsif ( contfreq < tempoestado1 + tempoestado2+ tempoestado3+ tempoestado4+ tempoestado5+ tempoestado6 )then
estadoatual <= estado6;
elsif ( contfreq < tempoestado1 + tempoestado2+ tempoestado3+ tempoestado4+ tempoestado5+ tempoestado6 + tempoestado7 )then
estadoatual <= estado7;
elsif ( contfreq < tempoestado1 + tempoestado2+ tempoestado3+ tempoestado4+ tempoestado5+ tempoestado6 + tempoestado7 + tempoestado8 )then
estadoatual <= estado8; end if ; if (estadoatual = 0 )then saidaA <= '0'; saidaB <= '0'; saidaC <= '0';
elsif ( estadoatual = 1 ) then saidaA <= '0';
saidaB <= '0'; saidaC <= '1';
elsif ( estadoatual = 2 ) then saidaA <= '0';
saidaC <= '0';
elsif ( estadoatual = 3 ) then saidaA <= '0';
saidaB <= '1'; saidaC <= '1';
elsif ( estadoatual = 4 ) then saidaA <= '1';
saidaB <= '0'; saidaC <= '0';
elsif ( estadoatual = 5 ) then saidaA <= '1';
saidaB <= '0'; saidaC <= '1';
elsif ( estadoatual = 6 ) then saidaA <= '1'; saidaB <= '1'; saidaC <= '0'; else saidaA <= '1'; saidaB <= '1'; saidaC <= '1'; end if; end if; end process;
end teste;
Código auxiliar escrito em C#
/////////////////////// GERA SENOIDE VARIABLES ///////////////////
#include <Stdlib.h> #include <String.h> #include <math.h> int g_nInputNodes=0; int g_nOutputNodes=0; int g_nStepCount=0; static int contagem; static float entradapassada; static float posicaoX; static float posicaoY; static float velocidadeX; static float velocidadeY; float raioatual;
float raio = 150;
float passoporcentagem = 1 ; float passo = 1 ;
static int jafoi = 0;
//////////////////// GERA SENOIDE UPDATE /////////////////// #include <Stdlib.h>
#include <String.h> #include <math.h> g_nStepCount++;
if ( in[0] > entradapassada ){
raioatual = sqrt( posicaoX * posicaoX + posicaoY*posicaoY ); passo = passoporcentagem * raioatual / 100 ;
velocidadeX = - posicaoY; velocidadeY = posicaoX;
velocidadeX = velocidadeX *passo / raioatual; velocidadeY = velocidadeY *passo / raioatual; posicaoX = posicaoX + velocidadeX;
posicaoY = posicaoY + velocidadeY; posicaoX = posicaoX * raio / raioatual; posicaoY = posicaoY * raio / raioatual; contagem = contagem + 1; } entradapassada =in[0]; out[0] = posicaoX; out[1] = posicaoY; out[2] = raioatual; out [3] = contagem;
// In case of error, uncomment next two lines. Set *pnError to 1 and copy Error message to szErrorMsg //*pnError=1;
//strcpy(szErrorMsg, "Place Error description here.");
///////////////////////////////////////////// MODULACAO VARIAVEIS ///////////////////////// #include <Stdlib.h> #include <String.h> #include <math.h> int g_nInputNodes=0; int g_nOutputNodes=0; int g_nStepCount=0; float vcc = 200; float divisorfreq = 100 ; static float contfreq;
///////////////////////////////////////////////////////// static int estado1 = 0;
static int estado2 = 0; // vetor ativo; static float tempoestado2;
static int estado3 = 3; static float tempoestado3; static int estado4 = 3; static float tempoestado4;
static int estado5= 0; // vetor ativo static float tempoestado5;
static int estado6 = 0; static float tempoestado6; static int estado7 = 0; static float tempoestado7; static int estado8 = 0; static float tempoestado8; static int estadoatual = 0; static int sextanteatual = 1; static int contagem; static float entradapassada;
////////////////////////////// MODULAÇAO UPDATE /////////////////////////// #include <Stdlib.h> #include <String.h> #include <math.h> g_nStepCount++; if ( in[0] > entradapassada ){
//// FAZ CONTFREQ VARIAR DE 0 ATE O MAXIMO /// if ( contfreq > divisorfreq ){
contfreq = 0 ; }else {
contfreq = contfreq + 1; }
///////////////////////// CALCULA O SEXTANTE ATUAL //////////////////////////////////// estado1 = 0;
estado4 = 7; estado5 = 7; estado8 = 0;
if ( in[1] > 0 && in[2]>0 && in[2]< 1.732 * in[1] ){ sextanteatual = 1;
estado2 = 4; estado3 = 6; estado6 = estado3; estado7 = estado2;
tempoestado3 = in[2]* contfreq / ( vcc * 0.866 ); tempoestado3 = tempoestado3 / 2;
tempoestado6 = tempoestado3;
tempoestado2 = (in[1]*contfreq/ vcc) - tempoestado3; tempoestado2 = tempoestado2 / 2;
tempoestado7 = tempoestado2; }
if ( in[1] > 0 && in[2]>0 && in[2]> 1.732 * in[1] ){ sextanteatual =2;
estado2 = 6; estado3 = 2;
estado6 = estado3; estado7 = estado2;
tempoestado3 = contfreq*( in[2] - 1.732*in[1] )/ ( vcc*1.732 ); tempoestado3 = tempoestado3 / 2
tempoestado6 = tempoestado3 ;
tempoestado2 = in[1]*2*contfreq/(vcc ) + 2 * tempoestado3; tempoestado2 = tempoestado2 / 2;
tempoestado7 = tempoestado2; }
if ( in[1] < 0 && in[2]>0 && in[2]> 1.732 * - in[1] ){ sextanteatual =2;
estado2 = 6; estado3 = 2; estado6 = estado3; estado7 = estado2;
tempoestado3 = contfreq*( in[2] - 1.732*in[1] )/ ( vcc*1.732 ); tempoestado3 = tempoestado3 / 2;
tempoestado6 = tempoestado3 ;
tempoestado2 = in[1]*2*contfreq/(vcc ) + 2 * tempoestado3; tempoestado2 = tempoestado2 / 2;
tempoestado7 = tempoestado2; }
if ( in[1] < 0 && in[2]>0 && in[2]< 1.732 * - in[1] ){ sextanteatual =3;
estado3 = 3; estado6 = estado3; estado7 = estado2; tempoestado2 = in[2]*contfreq / ( vcc * 0.866 ); tempoestado2 = tempoestado2 / 2; tempoestado7 = tempoestado2;
tempoestado3 = (-in[1]*contfreq/ vcc) - tempoestado2; tempoestado3 = tempoestado3 / 2;
tempoestado6 = tempoestado3; }
if ( in[1] < 0 && in[2]<0 && in[2]> 1.732 * in[1] ){ sextanteatual =4; estado2 = 3; estado3 = 1; estado6 = estado3; estado7 = estado2; tempoestado3 = -in[2]*contfreq / ( vcc * 0.866 ); tempoestado3 = tempoestado3 / 2; tempoestado6 = tempoestado3;
tempoestado2 = (-in[1]*contfreq/ vcc) - tempoestado3; tempoestado2 = tempoestado2 / 2;
tempoestado7 = tempoestado2;
}
if ( in[1] < 0 && in[2]<0 && in[2]< 1.732 * in[1] ){ sextanteatual =5;
estado3 = 5; estado6 = estado3; estado7 = estado2;
tempoestado3 = contfreq*( - in[2] + 1.732* in[1] )/ ( vcc*1.732 ); tempoestado3 = tempoestado3 / 2;
tempoestado6 = tempoestado3 ;
tempoestado2 = - in[1]*2*contfreq/(vcc ) + 2 * tempoestado3; tempoestado2 = tempoestado2 / 2;
tempoestado7 = tempoestado2; }
if ( in[1] > 0 && in[2]<0 && in[2]< -1.732 * in[1] ){ sextanteatual =5;
estado2 = 1; estado3 = 5; estado6 = estado3; estado7 = estado2;
tempoestado3 = contfreq*( - in[2] + 1.732* in[1] )/ ( vcc*1.732 ); tempoestado3 = tempoestado3 / 2;
tempoestado6 = tempoestado3 ;
tempoestado2 = - in[1]*2*contfreq/(vcc ) + 2 * tempoestado3; tempoestado2 = tempoestado2 / 2;
tempoestado7 = tempoestado2; }
if ( in[1] > 0 && in[2]<0 && in[2]> -1.732 * in[1] ){ sextanteatual =6;
estado3 = 4; estado6 = estado3; estado7 = estado2; tempoestado2 =- in[2]*contfreq / ( vcc * 0.866 ); tempoestado2 = tempoestado2 / 2; tempoestado7 = tempoestado2;
tempoestado3 = (in[1]*contfreq/ vcc) - tempoestado2; tempoestado3 = tempoestado3 / 2;
tempoestado6 = tempoestado3; }
tempoestado1 = (contfreq - 2*tempoestado2 - 2*tempoestado3) / 4; tempoestado4 = tempoestado1;
tempoestado5 = tempoestado1; tempoestado8 = tempoestado1;
///////////////// COM BASE EM CONTFREQ DETERMINA QUAL O ESTADO ATUAL ///////// if (contfreq < tempoestado1 ){
estadoatual = estado1;
}else if ( contfreq < tempoestado1 + tempoestado2 ){ estadoatual = estado2
}else if ( contfreq < tempoestado1 + tempoestado2+ tempoestado3 ){ estadoatual = estado3;
}else if ( contfreq < tempoestado1 + tempoestado2+ tempoestado3+ tempoestado4 ){ estadoatual = estado4;
}else if ( contfreq < tempoestado1 + tempoestado2+ tempoestado3+ tempoestado4+ tempoestado5 ){ estadoatual = estado5;
}else if ( contfreq < tempoestado1 + tempoestado2+ tempoestado3+ tempoestado4+ tempoestado5+ tempoestado6 ){ estadoatual = estado6;
}else if ( contfreq < tempoestado1 + tempoestado2+ tempoestado3+ tempoestado4+ tempoestado5+ tempoestado6 + tempoestado7 ){
estadoatual = estado7; }
else if ( contfreq < tempoestado1 + tempoestado2+ tempoestado3+ tempoestado4+ tempoestado5+ tempoestado6 + tempoestado7 + tempoestado8 ){
estadoatual = estado8; }
//////// DECIDE AS SAIDAS DE ACORDO COM ESTADO ATUAL ////// if (estadoatual == 0 ){ out[2] = 0; out[0] = 0; out[1] = 0; }else if ( estadoatual == 1 ) { out[2] = 0; out[0] = 0; out[1] = 1; }else if ( estadoatual == 2 ) { out[2] = 0; out[0] = 1; out[1] = 0; }else if ( estadoatual == 3 ) { out[2] = 0; out[0] = 1; out[1] = 1; }else if ( estadoatual == 4 ) { out[2] = 1;
out[0] = 0; out[1] = 0; }else if ( estadoatual == 5 ) { out[2] = 1; out[0] = 0; out[1] = 1; }else if ( estadoatual == 6 ) { out[2] = 1; out[0] = 1; out[1] = 0; } else { out[2] = 1; out[0] = 1; out[1] = 1; } contagem = contagem + 1; } entradapassada =in[0];