INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA DO

MARANHÃO - CAMPUS MONTE CASTELO

ENGENHARIA ELÉTRICA INDUSTRIAL
IVYS KALIL SILVA ALMEIDA-20202EE0001

ATIVIDADE ASSINCRONA

São Luís, 27 de Setembro de 2021

IVYS KALIL SILVA ALMEIDA

ATIVIDADE ASSINCRONA

Trabalho da disciplina
de Tec. Programação,
do curso de engenharia
.
elétrica.

São Luís, 27 de Setembro de 2021

ANÁLISE E RESPOSTAS

PROGRAMA BASEADO NA SEGUINTE FÓRMULA:

QUESTÃO 1
clear;
clc;
close;

f=50; //Frequência do sinal

N=32; //Número de amostras

tsamp=linspace(0,(1/f),N+1); //Tempo no domínio do tempo discreto

ysamp=179.605*sin(2*%pi*f*tsamp + (%pi/18)); //Sinal no domínio do tempo discreto

function K=RMS_CLASSIC(AMOSTRA_SINAIS, N_DE_AMOSTRAS)

RMSaux = 0;
for n=1:1:N
RMSaux= RMSaux+(ysamp(n)*ysamp(n));//SOMATÓRIO DAS AMOSTRAS DAS TENSÕES
end

RMS = sqrt((1/N)*RMSaux);
disp(RMS);
K = RMS; //RETORNA O VALOR RMS

endfunction
M=RMS_CLASSIC(ysamp,N);

RESULTADO NO CONSOLE
QUESTÃO 2

PROGRAMA BASEADO NA SEGUINTE FÓRMULA:

OBS: APÓS FAZER O SOMATÓRIO O RESULTADO É UM VALOR NA FORMA RETANGULAR,

MAS PARA REPRESENTA-LO, TIVE QUE SEPARAR EM VETORES O ÂNGULO DO SOMATÓRIO
E O MÓDULO. ESSA SEPARAÇÃO É FEITA PELAS VARIAVEIS Iang, Vang...

CÓDIGO:
clear;
clc;

function [P, Q, S, fp, cons, Vang, Iang, Vmod, Imod]=CALCULA_AMOSTRAS(amostra_corrente,

amostra_tensao, temp_sump, N_AMOSTRAS)
v=0;
i=0;

for n = 1:1:N
v = v + (vsamp(n)*(cos(2*%pi*((n-1)/N))-%i*sin(2*%pi*((n-1)/N))));//SOMATÓRIO REFERENTE AS
AMOSTRAS DE TENSÃO
i = i + (isamp(n)*(cos(2*%pi*((n-1)/N))-%i*sin(2*%pi*((n-1)/N))));//SOMATÓRIO REFERENTE AS
AMOSTRAS DE CORRENTE
end

Vfasor1 = (sqrt(2)/N)*v;//DE ACORDO COM A FORMULA DEVE-SE FAZER ESTA OPERAÇÃO JUNTO
AO SOMATÓRIO v, no caso
Ifasor1 = (sqrt(2)/N)*i;

//FAZORES EM FORMA POLAR, REPRESENTADOS EM UM VETOR

Vfasor=[abs(Vfasor1) atan(imag(Vfasor1),real(Vfasor1))];
Ifasor=[abs(Ifasor1) atan(imag(Ifasor1),real(Ifasor1))];
//VAI SERVIR PARA SERAPAR OS ANGULOS E MÓDULOS DA TENSÃO E CORRENTE, ISSO
FACILITA A REPRESENTAÇÃO
Vang=Vfasor(2);
Iang=Ifasor(2);
Vmod=Vfasor(1);
Imod=Ifasor(1);

P = (real(Vfasor1)*real(Ifasor1))+(imag(Vfasor1)*imag(Ifasor1));//POTENCIA ATIVA DE ACORDO COM

A FORMULA
Q = (real(Vfasor1)*real(Ifasor1))-(imag(Vfasor1)*imag(Ifasor1));//POTENCIA REATIVA DE ACORDO
COM A FORMULA
S = sqrt(P^2 + Q^2);//POTENCIA APARENTE DE ACORDO COM A FORMULA
fp = P/S;
cons = P*8/1000;//CONSUMO
endfunction
f = 50;
N = 64;

tsamp = linspace(0,(1/f), N+1);

vsamp = 311.127*cos((2*f*%pi*tsamp) + (%pi/25));//AMOSTRAS TENSÃO
isamp = 14.142*cos((2*f*%pi*tsamp) - (%pi/20));//AMOSTRAS CORRENTE

[P,Q,S,fp,cons,Vang,Iang,Vmod,Imod]=CALCULA_AMOSTRAS(isamp,vsamp,tsamp,N);//A FUNÇÃO
RETORNA AS GANDEZAS PEDIDAS
//Imod representa o modulo; Iang representa o angulo da corrente. Esses valores foram separados para
facilitar na hora de exibir
printf(" VALOR DA Corrente RMS--> MODULO:%g ANGULO:%g \n VALOR DA TENSÃO RMS-->
MODULO:%g ANGULO:%g \n ",Imod,Iang,Vmod,Vang);
printf("P=%g W \n Q=%g VA \n S=%g VAr \n fp=%g \n consumo=%g KWh",P,Q,S,fp,cons);

RESULTADO NO CONSOLE

QUESTÃO 3:

CODIGO:
clear;
clc;

f=60; //Frequência fundamental do sinal

N=32; //Número de amostras por período

tsamp=linspace(0,(1/f),N+1); //Tempo no domínio do tempo discreto

//Sinais no domínio do tempo discreto de corrente e tensão

ysamp= 10 + 311.127*cosd(120*%pi*tsamp + 35) + 28.284*cosd(240*%pi*tsamp + 5) +
16.97*cosd(840*%pi*tsamp);
isamp= 3 + 25.456*cos(120*%pi*tsamp + %pi/6) + 8.485*cos(240*%pi*tsamp - %pi/12) +
5.657*cos(840*%pi*tsamp - %pi/18);

function [P, Q, S, Irms, Vrms]=TRUE_RMS(ysamp, isamp, N)

Irms1=0;Vrms1=0;
P=0;Q=0;
x=zeros((N/2),1);
y=zeros((N/2),1);

for k=1:1:(N/2) //calcula as harmonicas

for n=1:1:N
x(k) = x(k) + ysamp(n)*(cos(2*%pi*(k-1)*(n-1)/N) - %i*sin(2*%pi*(k-1)*(n-1)/N));//tensão
y(k) = y(k) + isamp(n)*(cos(2*%pi*(k-1)*(n-1)/N) - %i*sin(2*%pi*(k-1)*(n-1)/N)); // corrente
end
xfasor(k)=(sqrt(2)/N)*x(k);//para ter o valor TENSAO DE CADA HARMONICA
yfasor(k)=(sqrt(2)/N)*y(k);//para ter o valor CORRENTE RMS DE CADA HARMONICA
xfasor(1)=xfasor(1)/sqrt(2);
yfasor(1)=xfasor(1)/sqrt(2);

P= P + abs(xfasor(k))*abs(yfasor(k))*cos(atan(imag(xfasor(k)),real(xfasor(k)))-
atan(imag(yfasor(k)),real(yfasor(k))));//POTENCIA SEGUNDO A FORMULA
Q= Q + abs(xfasor(k))*abs(yfasor(k))*sin(atan(imag(xfasor(k)),real(xfasor(k)))-
atan(imag(yfasor(k)),real(yfasor(k))));//POTENCIA SEGUNDO A FORMULA
 Irms1= Irms1+(abs(xfasor(k)))^2;
Vrms1= Vrms1+(abs(yfasor(k)))^2;
end

Irms=sqrt(Irms1);
Vrms=sqrt(Vrms1);
S=Irms*Vrms;

endfunction
[P,Q,S,Irms,Vrms]=TRUE_RMS(ysamp,isamp,N);
printf("P=%g\nQ=%g\nS=%g\nIrms=%g\nVrmas=%g",P,Q,S,Irms,Vrms);

CONSOLE:
QUESTÃO 4

PARA CALCULAR AS COMPONENTES SIMÉTRICAS ME BASEEI NAS SEGUINTES FÓRMULAS:

PORTANTO, RECEBO DO USUÁRIO VC VA E VB

AS DEMAIS COMPONENTES:

PARA CALCULAR OS FASORES ORIGINAIS ME BASEEI

SEGUE, PORTANTO O CÓDIGO:
clear;
clc;

a=[1 120]; // OPERADOR a = 1 /120°

a2=[1 240];// OPERADOR a² = 1 /240°

//////// CONVERTE PARA RETANGULAR /////////////////

function x=conver(vetor)//SERÁ RECEBIDO UM VETOR COM O MÓDULO E O ANGULO, COM O
FORMATO: [MÓD ANG]
r = cosd(vetor(2))*(vetor(1));
im= sind(vetor(2))*vetor(1);
x = r + %i*im;
endfunction

function ccd=FASOR_ORIGINAL()//function que calcula os fasores originais com base nas componentes
simétricas

//RECOMENDAÇÕES PARA O USUÁRIO

printf("********* Cálculo dos Fasores originais (desequilibrados) com base nas componentes simétricas
************ \n\n ORIENTAÇÕES:\n\n 1- DEVE-SE DIGITAR APENAS OS VALORES DAS
COMPONENTES SIMÉTRICAS Va0, Va1, Va2; \n\n 2- DEVE-SE DIGITAR CADA UMA DAS
COMPONENTES Va0 Va1 e Va2, DE FORMA SEPARADA E DE ACORDO COM A ORDEM QUE O
PROGRAMA INDICAR;\n\n 3- ATENÇÃO! OS VALORES DAS COMPONENTES SIMÉTRICAS
DEVEM SER DIGITADOS EM FORMATO DE VETOR, COM COLCHETES E OS VALORES
SEPARADOS, EX: [1 2];\n\n 4- O PRIMEIRO ELEMENTO DESSE VETOR É O MÓDULO E O
SEGUNDO É ÂNGULO EM GRAUS.\n\n");

printf(" Por favor, digite no seguite formato:[mod ang]. Com o colchete, e sendo mod o módulo e ang o
angulo.\n\n");
//RECEBENDO OS VALORES DAS COMPONENTES SIMÉTRICAS DO USUÁRIO
Va0=input('Va0 =');
Va1=input('Va1=');
Va2=input('Va2=');

//AUXILIARES QUE MULTIPLICARÃO OS OPERADORES (a² e a),EM POLAR,COM Va2 e Va1.

/*O INTUÍTUO É FAZER OS PRODUTOS DOS OPERADORES(a² e a) com as componentes simétricas,
DE FORMA SEPARADA, E DEPOIS SEGUIR NORMALMENTE A FÓRMULA 24,25 E 26
da Atividade Assíncrona - Etapa 3.*/
aux1VB = [a2(1)*Va1(1) a2(2)+Va1(2)];
aux2VB = [a(1)*Va2(1) a(2)+Va2(2)];
aux1VC = [a(1)*Va1(1) a(2)+Va1(2)];
aux2VC = [a2(1)*Va2(1) a2(2)+Va2(2)];

//PARA SOMAR TUDO FOI NECESSÁRIO CONVERTER AS COMPONENTES SIMÉTRICAS PARA A

FORMA RETANGULAR
//SEGUINDO A FÓRMULA 24,25,26 DA Atividade Assíncrona - Etapa 3.
Va0 = conver(Va0);
//FÓMULAS 24,25,26
Va=Va0+conver(Va1)+conver(Va2);
Vb=conver(aux1VB)+conver(aux2VB)+Va0;
Vc=conver(aux1VC)+conver(aux2VC)+Va0;

Va=[abs(Va) (180/%pi)*(atan(imag(Va),real(Va)))];//MOSTRAR OS FASORES ORIGINAIS EM

FORMATO DE VETOR: [MÓD ANG]
Vb=[abs(Vb) (180/%pi)*(atan(imag(Vb),real(Vb)))];
Vc=[abs(Vc) (180/%pi)*(atan(imag(Vc),real(Vc)))];
printf(" MODULO ANGULO \n");
printf(" Va0 %g %g\n",Va(1),Va(2));
printf(" Va1 %g %g\n",Vb(1),Vb(2));
printf(" Va2 %g %g\n",Vc(1),Vc(2));

ccd = [Va ; Vb ; Vc];//RETORNA OS FASORES ORIGINAIS

endfunction

function v=COMPO_SIMETRICA()//FUNÇÃO QUE CALCULA AS COMPONENTES SIMÉTRICAS

//RECOMENDAÇÕES PARA O USUÁRIO
printf("********* Cálculo das componentes simétricas com base nos Fasores originais (desequilibrados)
************ \n\n ORIENTAÇÕES:\n\n 1- DEVE-SE DIGITAR APENAS OS VALORES DOS
FASORES ORIGINAIS Va, Vb, Vc; \n\n 2- DEVE-SE DIGITAR CADA UM DOS FASORES
ORIGINAIS Va Vb e Vc, DE FORMA SEPARADA E DE ACORDO COM A ORDEM QUE O
PROGRAMA INDICAR;\n\n 3- ATENÇÃO! OS VALORES DOS FASORES ORIGINAIS DEVEM
SER DIGITADOS EM FORMATO DE VETOR, COM COLCHETES E OS VALORES SEPARADOS,
EX: [1 2];\n\n 4- O PRIMEIRO ELEMENTO DESSE VETOR É O MÓDULO E O SEGUNDO É
ÂNGULO EM GRAUS.\n\n");

printf(" Por favor, digite no seguite formato:[mod ang]. Com o colchete, e sendo mod o módulo e ang o
angulo.\n\n");
//RECEBENDO OS VALORES DAS COMPONENTES SIMÉTRICAS DO USUÁRIO
Va=input('Va =');
Vb=input('Vb=');
Vc=input('Vc=');

//AUXILIARES QUE MULTIPLICARÃO OS OPERADORES(a² e a),EM POLAR,COM Vb e Vc.

/*O INTUÍTUO É FAZER OS PRODUTOS DOS OPERADORES(a² e a) com os fasores originais,

DE FORMA SEPARADA, E DEPOIS SEGUIR NORMALMENTE A FÓRMULA 32,33 E 34
da Atividade Assíncrona - Etapa 3.*/
aux1VA1 = [a(1)*Vb(1) a(2)+Vb(2)];
aux2VA1 = [a2(1)*Vc(1) a2(2)+Vc(2)];
aux1VA2 = [a(1)*Vc(1) a(2)+Vc(2)];
aux2VA2 = [a2(1)*Vb(1) a2(2)+Vb(2)];
//FÓRMULAS 32,33,34
//SOMAS FEITAS EM FORMA RETANGULAR, POR ISSO AS CONVERSÕES
Va1= (1/3)*(conver(Va)+conver(aux1VA1)+conver(aux2VA1));
Va0= (1/3)*(conver(Va)+conver(Vb)+conver(Vc));
Va2= (1/3)*(conver(Va)+conver(aux1VA2)+conver(aux2VA2));

//coversão para polar DE Va0

//seguindo o ítem (c) e numeração 21,22,23 da Atividade Assíncrona - Etapa 3
Va0=[abs(Va0) (180/%pi)*(atan(imag(Va0),real(Va0)))];//coverte logo, pois terá que igualar com Vb0 e
Vc0
Vb0=Va0;
Vc0=Va0;

Vb1=[abs(Va1) -120];//seguindo o ítem (a) e numeração 16 da Atividade Assíncrona - Etapa 3

Vb2=[abs(Va2) -240];//seguindo o ítem (b) e numeração 19 da Atividade Assíncrona - Etapa 3

Vc1=[abs(Va1) -240];//seguindo o ítem (a) e numeração 17 da Atividade Assíncrona - Etapa 3

Vc2=[abs(Va2) -120];//seguindo o ítem (b) e numeração 20 da Atividade Assíncrona - Etapa 3

//MOSTRANDO EM FORMA POLAR

 Va1=[abs(Va1) (180/%pi)*(atan(imag(Va1),real(Va1)))];

Va2=[abs(Va2) (180/%pi)*(atan(imag(Va2),real(Va2)))];
printf(" MODULO ANGULO \n");
printf(" Va0 %g %g\n",Va0(1),Va0(2));
printf(" Va1 %g %g\n",Va1(1),Va1(2));
printf(" Va2 %g %g\n",Va2(1),Va2(2));
printf(" Vb0 %g %g\n",Vb0(1),Vb0(2));
printf(" Vb1 %g %g\n",Vb1(1),Vb1(2));
printf(" Vb2 %g %g\n",Vb2(1),Vb2(2));
printf(" Vc0 %g %g\n",Vc0(1),Vc0(2));
printf(" Vc1 %g %g\n",Vc1(1),Vc1(2));
printf(" Vc2 %g %g",Vc2(1),Vc2(2));

v=[Va0 ;Va1; Va2; Vb0; Vb1; Vb2; Vc0; Vc1; Vc2];//RETORNAR AS COMPONENTES SIMÉTRICAS

endfunction
// M E N U
printf("**********************MENU*******************\n\n OPÇÃO 1- CALCULAR AS
COMPONENTES SIMÉTRICAS\n\n OPÇÃO 2-OS FASORES ORIGINAIS\n\n");

auxMENU= input(' DIGITE UMA OPÇÃO=');

switch auxMENU
case 1
MY=COMPO_SIMETRICA();
case 2
MY=FASOR_ORIGINAL();
otherwise
disp('DIGITE A OPÇÃO 1 OU A OPÇÃO 2');
end

CONSOLE:

1. MENU
 2. OPÇÃO 2

OBS: PERCEBA A FORMA COMO O USÚARIO ADICIONA VALORES, SÃO VETORES COM O
PRIMEIRO ELEMENTO SENDO O MÓDULO E O SUGUNDO O ÂNGULO. O MESMO FORMATO
DE ATRIBUIÇÃO DE VALOR SERVE PARA OPÇÃO 1.