Programas em Scilab

1. Programas em Scilab
// Programa: Máquina síncrona de polos lisos
// Autor: Jim Naturesa
// Valores iniciais
xs=10 // reatância síncrona
vt=380 // tensão terminal
ef=250 // tensão induzida
t=1 // variável de controle
delta(t)=-180 // angulo de potência - valor inicial
p(t)=3*((vt)*(ef)* sin((3.1416*delta(t))/180))/(xs);
// Variação do ângulo de potência
while delta<=180
delta(t+1)=delta(t)+1;
t=t+1; // aumento da variável
p(t)=3*((vt)*(ef)* sin((3.1416*delta(t))/180))/(xs);
end // fim do loop da variação do ângulo
// Gráfico Potência versus ângulo delta
plot(delta,p)
// Legenda do gráfico
xtitle( 'Gráfico da potência versus ângulo', 'Ângulo de potência', 'Potência trifásica')
**************************************************************************
// Programa: Máquina síncrona de polos lisos
// Variação do ângulo de potência e da corrente de campo
// Autor: Jim Naturesa
// Valores iniciais
xs=10 // reatância síncrona
vt=380 // tensão terminal
t=1 // primeira variável de controle
w=1 // segunda variável de controle
delta(t)=-180 // ângulo de potência - valor inicial
ef(w)=250 // tensão induzida - valor inicial
// Fórmula da potência
p(t)=3*((vt)*(ef(w))* sin((3.1416*delta(t))/180))/(xs);
//Variação da corrente de campo, logo, variação na tensão induzida
while ef(w)>=150 // loop da corrente de campo
// Variação do ângulo de potência
1

2. while delta(t)<180 //loop do ângulo delta
delta(t+1)=delta(t)+1;
t=t+1;
p(t)=3*((vt)*(ef(w))* sin((3.1416*delta(t))/180))/(xs);
end // fim do loop da variação do ângulo
// Gráfico Potência versus ângulo delta
//sgrid
plot(delta,p)
// Legenda do gráfico
xtitle( 'Gráfico da potência versus ângulo', 'Ângulo de potência', 'Potência trifásica')
// Diminui o valor de ef
ef(w+1)=ef(w)-(15.0);
w=w+1;
// A variável t deve retorna para o valor inicial
t=1;
// A variável delta também deve retornar para o valor inicial
delta(t)=-180;
// Valor da potência
p(t)=3*((vt)*(ef(w))* sin((3.1416*delta(t))/180))/(xs);
end // fim do loop de variação da corrente de campo
xgrid
// Observações:
// (1) Utilize o ponto e vírgula (;) depois das funções se vc quiser que a expressão
// não apareça na tela.
// (2) Retire o ponto e vírgula das expressões se vc está começando a programar.
// Assim vc pode acompanhar as variáveis.
***************************************************************************
// Programa: Máquina síncrona de polos lisos
// Variação do ângulo de potência
// Construção das curvas de potência ativa e reativa em função da variação do ângulo
// Autor: Jim Naturesa
// Valores iniciais
xs=10 // reatância síncrona
vt=380 // tensão terminal
ef=250 // tensão induzida
2

3. t=1 // variável de controle
delta(t)=1 // angulo de potência - valor inicial
p(t)=3*((vt)*(ef)* sin((3.1416*delta(t))/180))/(xs);// Potência ativa
q(t)=3*((vt)*(ef)*cos((3.1416*delta(t))/180))/(xs)-3*((vt^2)/(xs));// Potência reativa
// Variação do ângulo de potência
while t<35
delta(t+1)=delta(t)+2.75;
t=t+1; // aumento da variável
p(t)=3*((vt)*(ef)* sin((3.1416*delta(t))/180))/(xs);
q(t)=3*((vt)*(ef)*cos((3.1416*delta(t))/180))/(xs)-3*((vt^2)/(xs));
end // fim do loop da variação do ângulo
// Gráficos
// Duas curvas no mesmo gráfico
//plot(delta,p,delta,q)
// Outra forma de colocar duas curvas no mesmo gráfico
//clf()
//plot(delta,[p q])
clf()// Fecha todos os gráficos
subplot(211)
plot(delta,p);
xtitle("Potência ativa versus delta")
subplot(212)
plot(delta,q);
xtitle("Potência reativa versus delta")
*******************************************************************************
// Programa: Máquina síncrona de polos salientes
// Construção das curvas de potência ativa
// Autor: Jim Naturesa
// Valores iniciais
xd=4 // reatância de eixo direto
xq= 2 // reatância de eixo em quadratura
vt=127 // tensão terminal
ef=310 // tensão induzida
t=1 // variável de controle
delta(t)=-180 // angulo de potência - valor inicial
// A potência da máquina síncrona de pólos salientes é dada por duas parcelas:
p1(t)=3*((vt)*(ef)* sin((3.1416*delta(t))/180))/(xs); // Potência devido ao fluxo do campo
p2(t)=3*(((vt^2)*(xd-xq)*sin(2*((3.1416*delta(t))/180)))/(2*xd*xq)); // Potência devido a saliência
ptotal(t)=p1(t)+p2(t); // Potência total
// Variação do ângulo de potência
3

4. while delta<=180
delta(t+1)=delta(t)+1;
t=t+1; // aumento da variável
p1(t)=3*((vt)*(ef)* sin((3.1416*delta(t))/180))/(xs); // Potência devido ao fluxo do campo
p2(t)=3*(((vt^2)*(xd-xq)*sin(2*((3.1416*delta(t))/180)))/(2*xd*xq)); // Potência devido a saliência
ptotal(t)=p1(t)+p2(t); // Potência total
end // fim do loop da variação do ângulo
// Gráfico Potência versus ângulo delta
plot(delta,p1,delta,p2,delta,ptotal)
// Legenda do gráfico
xtitle('Gráfico da potência versus ângulo', 'Ângulo de potência', 'Potência trifásica')
xgrid // Coloca o grid no gráfico
********************************************************************************
// Programa: Máquina síncrona de polos salientes
// Construção das curvas de potência ativa e reativa
// Autor: Jim Naturesa
clear // Apaga os valores iniciais
// Valores iniciais
xd=4 // reatância de eixo direto
xq=2 // reatância de eixo em quadratura
vt=127 // tensão terminal
ef=310 // tensão induzida
t=1 // variável de controle
delta(t)=-180 // angulo de potência - valor inicial
// A potência ativa da máquina síncrona de pólos salientes é dada por duas parcelas:
p1(t)=3*((vt)*(ef)*sin((3.1416*delta(t))/180))/(xd); // Potência devido ao fluxo do campo
p2(t)=3*(((vt^2)*(xd-xq)*sin(2*((3.1416*delta(t))/180)))/(2*xd*xq)); // Potência devido a saliência
ptotal(t)=p1(t)+p2(t); // Potência total ativa
// A potência reativa também é dada por duas parcelas
q1(t)=3*((vt)*(ef)*cos((3.1416*delta(t))/180))/(xd); // Parcela um
q2(t)=3*((vt^2)*((sin((3.1416*delta(t))/180)^2/(xq)+(cos((3.1416*delta(t))/180))^2/(xd)))); //
Parcela dois
qtotal(t)=q1(t)-q2(t); // Potência total reativa
// Cálculo do fator de potência
angulo(t)=atan(qtotal(t)/ptotal(t));
fp(t)= cos(angulo(t));
// Variação do ângulo de potência
while delta<=180
4

5. delta(t+1)=delta(t)+1;
t=t+1; // aumento da variável
// A potência ativa da máquina síncrona é dada por duas parcelas:
p1(t)=3*((vt)*(ef)*sin((3.1416*delta(t))/180))/(xd);
p2(t)=3*(((vt^2)*(xd-xq)*sin(2*((3.1416*delta(t))/180)))/(2*xd*xq));
ptotal(t)=p1(t)+p2(t); // Potência total ativa
// A potência reativa também é dada por duas parcelas
q1(t)=3*((vt)*(ef)*cos((3.1416*delta(t))/180))/(xd);
q2(t)=3*((vt^2)*((sin((3.1416*delta(t))/180)^2/(xq)+(cos((3.1416*delta(t))/180))^2/(xd))));
qtotal(t)=q1(t)-q2(t); // Potência total reativa
// Cálculo do fator de potência
if ptotal|0
angulo(t)=atan(qtotal(t)/ptotal(t));
fp(t)= cos(angulo(t));
end
end // fim do loop da variação do ângulo
// Gráfico Potência versus ângulo delta
plot(delta,ptotal,delta,qtotal)
// Legenda do gráfico
xtitle('Gráfico da potência versus ângulo', 'Ângulo de potência', 'Potência trifásica')
xgrid // Coloca o grid no gráfico
5

6. delta(t+1)=delta(t)+1;
t=t+1; // aumento da variável
// A potência ativa da máquina síncrona é dada por duas parcelas:
p1(t)=3*((vt)*(ef)*sin((3.1416*delta(t))/180))/(xd);
p2(t)=3*(((vt^2)*(xd-xq)*sin(2*((3.1416*delta(t))/180)))/(2*xd*xq));
ptotal(t)=p1(t)+p2(t); // Potência total ativa
// A potência reativa também é dada por duas parcelas
q1(t)=3*((vt)*(ef)*cos((3.1416*delta(t))/180))/(xd);
q2(t)=3*((vt^2)*((sin((3.1416*delta(t))/180)^2/(xq)+(cos((3.1416*delta(t))/180))^2/(xd))));
qtotal(t)=q1(t)-q2(t); // Potência total reativa
// Cálculo do fator de potência
if ptotal|0
angulo(t)=atan(qtotal(t)/ptotal(t));
fp(t)= cos(angulo(t));
end
end // fim do loop da variação do ângulo
// Gráfico Potência versus ângulo delta
plot(delta,ptotal,delta,qtotal)
// Legenda do gráfico
xtitle('Gráfico da potência versus ângulo', 'Ângulo de potência', 'Potência trifásica')
xgrid // Coloca o grid no gráfico
5