El programa trae los valores de las potencias activas y cosenos phi de cada una de las cargas que se ve en la figura inferior.
Agrupación de cargas en paralelo que en el programa se compensa el coseno phi a 0.9 |
En la figura que sigue se puede apreciar como quedo compensada al potencia reactiva para obtener un coseno phi de 0.9.
Potencias del sistema, antes y luego de la compensación del coseno phi. |
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Nelson G. Lombardo.
% Año: 2010
% Licensed under GPL v2 or higher.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Se presetan varias cargas en paralelo, inductivas. Se calcula el capacitor
% de compensación a conectar en paralelo para mejorar el coseno de phi.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Borramos la memoria.
clear;
% Esta función devuelve un vector con los ángulos en radianes,
% a partir de un vector que contiene el coseno de phi de cada carga.
function [phi]=cal_phi(cos_phi,tam)
for c=1:tam
phi(c)=acos(cos_phi(c));
endfor
endfunction
% Esta función devuelve un vector con la potencia reactiva presente
% en cada carga, a partir del vector que almacena la potencia activa de cada
% carga y el ángulo phi de cada una.
function [potencia_reactiva_cargas]=cal_pot_react(potencia_activa_cargas,phi,tam)
for c=1:tam
potencia_reactiva_cargas(c)=...
(potencia_activa_cargas(c)/cos(phi(c)))*sin(phi(c));
endfor
endfunction
% Esta función devuelve un vector que contiene las potencias reactivas de cada
% carga en base a la pontecia activa presente en las cargas, y el ángulo phi de
% cada una.
function [potencia_aparente_cargas]=cal_pot_apa(potencia_activa_cargas,phi,tam)
for c=1:tam
potencia_aparente_cargas(c)=...
potencia_activa_cargas(c)/cos(phi(c));
endfor
endfunction
% Esta función devuelve un vector con el módulo de cada una de las impedancias,
% trabajando sobre las potencias aparentes y la tensión de trabajo a la que estan
% sometidas las cargas.
function [modulo_impedancia_cargas]=cal_impedancia(potencia_aparente_cargas,...
tension_trabajo, tam)
for c=1:tam
modulo_impedancia_cargas(c)=...
(tension_trabajo^2)/potencia_aparente_cargas(c);
endfor
endfunction
% Esta función devuelve la potencia aparente, reactiva y activa del sistema, basandose en
% los vectores de la potencia activa y reactiva de cada una de las cargas del sistema.
function [potencia_aparente potencia_reactiva potencia_activa]=cal_sumatoria_potencias(...
potencia_reactiva_cargas, potencia_activa_cargas)
potencia_reactiva=sum(potencia_reactiva_cargas);
potencia_activa=sum(potencia_activa_cargas);
potencia_aparente=sqrt(potencia_activa^2+potencia_reactiva^2);
endfunction
% Esta funcion returna un vector que almacena la impedancia compleja de cada una
% de las cargas, trabajando sobre el vector que contiene el módulo de las impedancias y
% el vector del ángulo phi.
function [impedancia_compleja_cargas]=cal_imp_comp(modulo_impedancia_cargas,phi,tam)
for c=1:tam
impedancia_compleja_cargas(c)=...
modulo_impedancia_cargas(c)*cos(phi(c))+...
j*modulo_impedancia_cargas(c)*sin(phi(c));
endfor
endfunction
% Esta función retorna el paralelo de las impedancias de las cargas.
function [impedancia_compleja]=cal_paralelo_imp(impedancia_compleja_cargas,tam)
tmp=0;
for c=1:tam
tmp=(1/impedancia_compleja_cargas(c))+tmp;
endfor
impedancia_compleja=1/tmp;
endfunction
% Esta función devuelve el valor del capacitor que se requiere conectar en paralelo para
% obtener el coseno de phi buscado.
function [capacitor]=cal_cap_comp(impedancia_compleja, coseno, frec)
alfa=tan(acos(coseno));
m=(real(impedancia_compleja)^2)+(imag(impedancia_compleja)^2);
capacitor=(imag(impedancia_compleja)-(alfa*real(impedancia_compleja)))/(m*2*pi*frec);
endfunction
% La siguiente función toma la tensión de trabajo, el vector de las impedancias complejas
% de las cargas y retorna un vector con las corrientes que circulan por cada carga.
function [corrientes_complejas_cargas]=cal_corrientes(tension,impedancia_compleja_cargas,tam)
for c=1:tam
corrientes_complejas_cargas(c)=tension/impedancia_compleja_cargas(c);
endfor
endfunction
% La próxima función toma la tensión de trabajo y el vector de impedacias complejas en las
% cargas y nos retorna la potencia activa de cada carga en forma de vector.
function [potencia_activa_cargas]=cal_pot_act(tension, impedancia_compleja_cargas, tam)
for c=1:tam
coseno=cos(atan(imag(impedancia_compleja_cargas(c))...
/real(impedancia_compleja_cargas(c))));
potencia_activa_cargas(c)=(tension^2/abs(impedancia_compleja_cargas(c)))*coseno;
endfor
endfunction
% El procedimiento que sigue, permite graficar la potencia activa, reactiva y aparente del sistema.
% Divide la gráfica en dos, para poder lograr comparar el sistema antes y despúes de la
% compensacion. Requiere de la potencia reactiva del sistema como así de la activa, 1 o 2 según
% se quiera graficar a la derecha o izquierda respectivamente, la potencia que va a establecer
% el límite de la gráfica (conviene que sea como mínimo el valor de la potencia aparente del
% sistema antes de la compensacion asi las escalas coinciden), la frecuencia de trabajo del
% sistema y la leyenda que se quiera utilizar en la gráfica.
function plot_vector_pot(reactiva, activa, m, pot, freq, leg)
% Se establecen las condiciones básicas
w = 2 * pi * freq; % Velocidad angular = [rad/s]
t = [0:1/5000:1/50]; % Tiempo para 50 Hz
subplot(1, 2, m); % Una sola fila de gráficos, dos columnas.
hold on; % Se retienen las gráficas a medida que se realizan.
title(leg); % Título de las mismas.
ylabel("Potencia Reactiva");
xlabel("Potencia Activa");
% Graficamos un círculo que encierra la potencia total
% puesta en juego:
pwrs = sqrt(reactiva^2+activa^2);
circle = pwrs * (cos(w*t)+j*sin(w*t));
plot(circle,'k');
circle = activa * (cos(w*t)+j*sin(w*t));
plot(circle,'b');
circle = reactiva * (cos(w*t)+j*sin(w*t));
plot(circle,'r');
% Gráficamos el vector representativo de la potencias
% total puesta en juego:
plot([0 activa],[0 reactiva],'k','LineWidth',4);
plot([0 activa],[0 0],'b','LineWidth',2);
plot([0 0],[0 reactiva],'r','LineWidth',2);
axis([-pot pot -pot pot]);
hold off;
grid on;
endfunction
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Programa principal
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
clf; % Borramos todas las gráficas.
% El siguiente vector contiene cada una de las potencias activas de las cargas
% siempre en orden. La unidad debe ser en Watts.
potencia_activa_cargas=[746 559.5 373 500];
% El siguiente vector contiene cada coseno phi de las cargas, respetando el orden
% posicional impuesto en el vector anterior.
cos_phi=[0.65 0.75 0.7 0.6];
% Tensión de trabajo eficaz del sistema.
Vrms=220;
% Frecuencia de trabajo del sistema en Hz
frec=50;
% Coseno de phi al cual se quiere compensar el sistema.
coseno=0.9;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Todos los cálculos requeridos por el gabinete con el sistema sin compensar:
% Pequeña leyenda para poder observar y discrimar mejor los datos calculados
% desde el terminal y gráficos.
leg="Instalacion sin compensacion:";
printf("--- %s\n",leg);
% La variable tam almacena la cantidad de cargas de las cuales se esta hablando.
tam = length(cos_phi);
% Cálculamos el angulo phi de cada carga:
[phi]=cal_phi(cos_phi, tam);
% Calculamos la potencia reactiva de cada carga:
[potencia_reactiva_cargas]=cal_pot_react(potencia_activa_cargas, phi, tam);
% Calculamos la potencia aparente de cada carga:
[potencia_aparente_cargas]=cal_pot_apa(potencia_activa_cargas, phi, tam);
% Calculamos el modulo de la impedancia de cada carga:
[modulo_impedancia_cargas]=cal_impedancia(potencia_aparente_cargas,Vrms, tam);
% Requerimos de la potencia aparente, reactiva y activa del sistema sin compensar:
[potencia_aparente potencia_reactiva potencia_activa]=cal_sumatoria_potencias(...
potencia_reactiva_cargas, potencia_activa_cargas, tam);
printf("Potencia aparente del sistema: %f[VA]\n",potencia_aparente);
printf("Potencia activa del sistema: %f[W]\n",potencia_activa);
printf("Potencia reactiva del sistema: %f[VAR]\n",potencia_reactiva);
[impedancia_compleja_cargas]=cal_imp_comp(modulo_impedancia_cargas, phi, tam);
[impedancia_compleja]=cal_paralelo_imp(impedancia_compleja_cargas, tam);
printf("Modulo de la impedancia sin compensar: %f[ohm]\n",...
abs(impedancia_compleja));
printf("Angulo de la impedancia sin compensar: %f\n",...
atan(imag(impedancia_compleja)/real(impedancia_compleja))*180/pi);
% A fines de matener una escala adecuada y poder hacer una comparación gráfica
% correcta, el paramétro pot (límite vertical y horizontal en las gráficas), será el de
% la potencia aparente del sistema sin compensar más un 10%.
pot = potencia_aparente + 0.1*potencia_aparente;
% Graficamos las potencias del sistema del lado derecho (1):
plot_vector_pot(potencia_reactiva, potencia_activa, 1, pot, frec, leg);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Todos los cálculos requeridos por el gabinete con el sistema compensado.
leg="Instalacion con compensacion:";
printf("---%s\n",leg);
% Calculo del capacitor de compensacion:
[capacitor]=cal_cap_comp(impedancia_compleja,coseno,frec);
printf("Capacitor que compensa la instalacion: %f[F]\n", capacitor);
% Calculod e la impedancia del capactior:
Zc=-j/(2*pi*frec*capacitor);
% Se agrega esta impedancia y el angulo a los vectores conrrespondientes:
impedancia_compleja_cargas(tam+1)=Zc;
phi(tam+1)=-pi/2;
% Se calcula la impedancia compleja del sistema:
[impedancia_compleja]=cal_paralelo_imp(impedancia_compleja_cargas, tam+1);
printf("Modulo de la impedancia compensada: %f[ohm]\n",...
abs(impedancia_compleja));
printf("Angulo de la impedancia compensada: %f\n",...
atan(imag(impedancia_compleja)/real(impedancia_compleja))*180/pi);
% Se calcula las corrientes por las cargas y asi se obtiene la especificacion del capacitor
[corrientes_complejas_cargas]=cal_corrientes(Vrms, impedancia_compleja_cargas, tam+1);
printf("Espcificacion de corriente reactiva del capacitor: %f[A]\n", ...
imag(corrientes_complejas_cargas(tam+1)));
% Se calcula la corriente total del sistema:
corriente_compleja=sum(corrientes_complejas_cargas);
printf("Corriente eficaz que ingresa al sistema: %f[A]\n", abs(corriente_compleja));
% Presenta las corrientes en cada una de las cargas:
for c=1:tam
printf("Corriente eficaz por la carga %i: %f[A]\n"...
, c, abs(corrientes_complejas_cargas(c)));
endfor
% Cálculo de las potencias con compensación presentes en las cargas:
[potencia_activa_cargas]=cal_pot_act(Vrms, impedancia_compleja_cargas, tam+1);
[potencia_reactiva_cargas]=cal_pot_react(potencia_activa_cargas, phi, tam+1);
[potencia_aparente_cargas]=cal_pot_apa(potencia_activa_cargas, phi, tam+1);
% Se calcula la nueva potencia aparente, reactiva y activa del sistema compensado:
[potencia_aparente potencia_reactiva potencia_activa]=...
cal_sumatoria_potencias( potencia_reactiva_cargas, potencia_activa_cargas);
printf("Potencia aparente del sistema: %f[VA]\n",potencia_aparente);
printf("Potencia activa del sistema: %f[W]\n",potencia_activa);
printf("Potencia reactiva del sistema: %f[VAR]\n",potencia_reactiva);
% Se grafica del lado izquierdo (2) el sistema compensado:
plot_vector_pot(potencia_reactiva, potencia_activa, 2, pot, frec,leg);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Fin del programa
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
No hay comentarios.:
Publicar un comentario