Documentos de Académico
Documentos de Profesional
Documentos de Cultura
ESTUDIANTE CUI
GRUPO SUBGRUPO
10/01/2024 23/01/2024
Se tiene un circuito serie RLC Alimentado por una fuente v(t) entrada y vc(t) tensión en el
capacitor de salida.
𝒊(𝒕)
𝑡
𝑑𝑖(𝑡) 1
𝑣(𝑡) = 𝑅𝑖(𝑡) + 𝐿 + ∫ 𝑖(𝑡)𝑑𝑡
𝑑𝑡 𝐶(𝑡) 0
𝑑𝑞(𝑡) 𝑑 2 𝑞(𝑡) 1
𝑣(𝑡) = 𝑅 +𝐿 + 𝑞(𝑡)
𝑑𝑡 𝑑𝑡 2 𝐶
𝒒(𝒕) = 𝑪 ∗ 𝑽𝑪(𝒕)
𝑑𝑉𝐶(𝑡) 𝑑2 𝑉𝐶(𝑡)
𝑣(𝑡) = 𝑅𝐶 + 𝐿𝐶 + 𝑉𝐶(𝑡)
𝑑𝑡 𝑑𝑡 2
1
𝑉(𝑠) = 𝑅𝐼(𝑠) + 𝐿𝑠𝐼(𝑠) + 𝐼(𝑠)
𝐶𝑠
Programa de Estudios de
FACULTAD DE INGENIERÍA DE PRODUCCIÓN Y SERVICIOS
Ingeniería Eléctrica
LABORATORIO DE CONTROL 1
1
𝑉(𝑠) = 𝐼(𝑠) (𝑅 + 𝐿𝑠 + )
𝐶𝑠
𝐼(𝑠) 1
=
𝑉(𝑠) 𝑅 + 𝐿𝑠 + 1
𝐶𝑠
1
𝑉𝑐(𝑠) = 𝐼(𝑠) ∗
𝐶𝑠
1
𝑉𝑐(𝑠) 𝐿𝐶
𝑠𝑢𝑠𝑡𝑖𝑡𝑢𝑦𝑒𝑛𝑑𝑜 𝐼(𝑠): =
𝑉(𝑠) 𝑅 1
𝑠 2 + 𝐿 𝑠 + 𝐿𝐶
𝑑𝑖(𝑡)
𝑣(𝑡) = 𝑅𝑖(𝑡) + 𝐿 + 𝑣𝑐(𝑡)
𝑑𝑡
𝑑𝑖(𝑡)
𝐿 = −𝑅𝑖(𝑡) − 𝑣𝑐(𝑡) + 𝑣(𝑡)
𝑑𝑡
𝑑𝑣𝑐(𝑡)
𝑖(𝑡) = 𝐶
𝑑𝑡
𝑑𝑣𝑐(𝑡) 𝑖(𝑡)
= + 0𝑣𝑐(𝑡) + 0𝑣(𝑡) … … … (𝐼𝐼)
𝑑𝑡 𝐶
𝑑𝑖(𝑡) 𝑅 1
− − 1
[ 𝑑𝑡 ] = [ 𝐿 𝐿] [ 𝑖(𝑡) ] + [ ] 𝑣(𝑡)
𝑑𝑣𝑐(𝑡) 1 𝑣𝑐(𝑡) 𝐿
0 0
𝑑𝑡 𝐶
Programa de Estudios de
FACULTAD DE INGENIERÍA DE PRODUCCIÓN Y SERVICIOS
Ingeniería Eléctrica
LABORATORIO DE CONTROL 1
𝑦1 = 𝑣𝑐(𝑡)
𝑖(𝑡)
[𝑦1] = [0 1] [ ] + [0]𝑣(𝑡)
𝑣𝑐(𝑡)
2.1.4. Obtener analíticamente vc(t) para una entrada escalón unitario para valores de
R L y C asumidos por el estudiante.. (nótese que la entrada paso es la integral
de una entrada impulso)
1
𝑉𝑐(𝑠) 𝐿𝐶 1
= =
𝑉(𝑠) 𝑅 1 2
𝑠 2 + 𝐿 𝑠 + 𝐿𝐶 𝐿𝐶𝑠 + 𝑅𝐶𝑠 + 1
1
𝑉(𝑠) = 𝑋(𝑠) =
𝑠
𝑉𝑐(𝑠) 1 1
= =
𝑉(𝑠) 𝐿𝐶𝑠 2 + 𝑅𝐶𝑠 + 1 𝑠 2 + 2𝑠 + 1
1
𝑉𝑐(𝑠) ∗ 𝑠 =
𝑠 2 + 2𝑠 + 1
1 1
𝑉𝑐(𝑠) = ∗
𝑠 2 + 2𝑠 + 1 𝑠
1 𝑠+2
= − 2
𝑠 𝑠 + 2𝑠 + 1
1 1 1
= − −
𝑠 𝑠 + 1 (𝑠 + 1)2
Aplicando Laplace
1 1 1
𝑉𝑐(𝑠) = − −
𝑠 𝑠 + 1 (𝑠 + 1)2
2.1.5. Con la ayuda del Excel presente los gráficos para una entrada escalón
unitario en lazo abierto.
Vc t
0 0
0,264241118 1
0,59399415 2
0,800851727 3
0,908421806 4
0,959572318 5
0,982648735 6
0,992704944 7
0,996980836 8
0,998765902 9
0,999500601 10
0,99979958 11
0,999920125 12
0,999968355 13
0,999987527 14
0,999995106 15
0,999998087 16
0,999999255 17
0,999999711 18
0,999999888 19
0,999999957 20
0,999999983 21
0,999999994 22
0,999999998 23
VC EN FUNCION DE T
1,2
1
VC TENSION EN EL CONDENSADOR
0,8
0,6
0,4
0,2
0
0 5 10 15 20 25
TIEMPO
Programa de Estudios de
FACULTAD DE INGENIERÍA DE PRODUCCIÓN Y SERVICIOS
Ingeniería Eléctrica
LABORATORIO DE CONTROL 1
𝑉𝑐(𝑠) 1
= 2
𝑉(𝑠) 𝑠 + 2𝑠 + 1
2.2.2. Obtener la respuesta en lazo abierto y cerrado para las entradas: impulso, paso,
rampa, senoidal.
clc
num=[1];
den=[1 2 1];
sys=tf(num,den);
impulse(tf(num,den))
step(sys)
Programa de Estudios de
FACULTAD DE INGENIERÍA DE PRODUCCIÓN Y SERVICIOS
Ingeniería Eléctrica
LABORATORIO DE CONTROL 1
Programa de Estudios de
FACULTAD DE INGENIERÍA DE PRODUCCIÓN Y SERVICIOS
Ingeniería Eléctrica
LABORATORIO DE CONTROL 1
clear all;
num=[1];
den=[1 2 1];
num1=[1];
den1=[1 0 0];
sys=tf(num,den);
sys1=tf(num1,den1);
sys3=series(sys,sys1);
plot(1),impulse(sys3),grid on,title('Respuesta a entrada de
rampa');
clear all;
num=[1];
den=[1 2 1];
num1=[1];
den1=[1 0 1];
sys=tf(num,den);
sys1=tf(num1,den1);
sys3=series(sys,sys1);
plot(1),impulse(sys3),grid on,title('Respuesta a entrada
senoidal');
Programa de Estudios de
FACULTAD DE INGENIERÍA DE PRODUCCIÓN Y SERVICIOS
Ingeniería Eléctrica
LABORATORIO DE CONTROL 1
𝒊(𝒕)
1
𝑉(𝑠) = 𝑅1𝐼(𝑠) + 𝐼(𝑠)
𝐶𝑠
1
𝑉𝑐(𝑠) = 𝐼(𝑠) ∗
𝐶𝑠
Programa de Estudios de
FACULTAD DE INGENIERÍA DE PRODUCCIÓN Y SERVICIOS
Ingeniería Eléctrica
LABORATORIO DE CONTROL 1
1
𝑉(𝑠) = 𝐼(𝑠) (𝑅1 + )
𝐶𝑠
𝐼(𝑠) 1
=
𝑉(𝑠) (𝑅1 + 1 )
𝐶𝑠
𝐼(𝑠) 1
=
𝑉(𝑠) (𝑅1 + 1 )
𝐶𝑠
1
𝑉𝑐(𝑠) 𝐶𝑠 1
= =
𝑉(𝑠) 1
(𝑅1 + 𝐶𝑠) 𝑅1𝐶𝑠 + 1
𝑉𝑐(𝑠) 1
=
𝑉(𝑠) 𝑅1𝐶𝑠 + 1
2.3. Informe
2.3.1. Empleando lazos y estructura de control de flujo, elabore un programa que
permita obtener sobre un mismo grafico la respuesta escalón en lazo abierto
para cinco valores diferentes del parámetro a del sistema dado por la siguiente
función de transferencia:
a
G( s) =
s+4
clear all
for a=1:5;
num=[a];
den=[1 4];
sys=tf(num,den);
step(sys);
grid on
hold on
end
Programa de Estudios de
FACULTAD DE INGENIERÍA DE PRODUCCIÓN Y SERVICIOS
Ingeniería Eléctrica
LABORATORIO DE CONTROL 1
2.5.3 Presentar resultados obtenidos del uso del programa mason.m del
anexo a este laboratorio.
end
Num=sprintf('%s)+',Num); % Close the bracket around paths list of sums
end
Num=Num(1:length(Num)-1); % Remove the extra plus sign on the end.NOTE using
/b screws up the symbolic math later
% Determine Denominator
Den='1'; % Denominator always start with a zero
for order=1:length(L)-1 % Add order subtract the sum of each orders loops
% if order is odd order append a minus, otherwise a plus,
if (rem(order,2)==1)
Den=sprintf('%s-',Den);
else
Den=sprintf('%s+',Den);
end
%Add or subtract all the loops
% KLUDGE: all the loops not touching the path with nodes 999999999 are added
% That definetly should be all of them!
Den=[Den,PrintSumsNotTouching(L,order,[9999999 999999])]; %Sums of all the
loops of order order
end
fprintf('\nThe variables returned are strings describing\n')
fprintf('the numerator and Denominator of the transfer equation.\n')
fprintf('If you have the symbolic toolbox, use
Denominator=sym(Denominator)\n');
fprintf('and Numerator=sym(Numerator) to make these symbolic equations.\n')
fprintf('You can now use simple(Numerator/Denominator) to boil the whole\n')
fprintf('thing down. You could also use simple(Numerator) to simplify the\n')
fprintf('Numerator on it'' own.\n\n')
% ****** Convert to Symbolic and do substitutions *******
for coeff_num=length(Coeff_Names):-1:1; %Cycle through Coefficient array,
substituting each one
orig=sprintf('c%d',Net(coeff_num,1)); % for each line generate c[Coeff
Number] to replace
Den=strrep(Den,orig,Coeff_Names{coeff_num}); % Replace all the c#s with the
strings from net file
Num=strrep(Num,orig,Coeff_Names{coeff_num});
end % This loop had to count down so there was no risk of C12 being replace
by C1
%****************************************************************************
*********************
function Touching=AreTouchingLoops(Nodes1,Nodes2)
%****************************************************************************
*********************
% This function takes two arrays describing two sets of nodes visited(each
padded with zeros).
% Return 1 if they are they are touching loops.
% Determine length of loop arrays with zeros removed
Loop1Length=sum(Nodes1>0);
Loop2Length=sum(Nodes2>0);
for first=1:Loop1Length
for second=1:Loop2Length
if (Nodes1(first)==Nodes2(second))
Touching=1;
return;
end
end
end
Touching=0;
%****************************************************************************
*********************
Programa de Estudios de
FACULTAD DE INGENIERÍA DE PRODUCCIÓN Y SERVICIOS
Ingeniería Eléctrica
LABORATORIO DE CONTROL 1
function StrMult=CoeffToString(Coefficients)
%****************************************************************************
*********************
% StrMult=CoeffToString(Coefficients)
% Coefficients is an array with coefficients c1,c2..cN
N=length(Coefficients); % Get length of string
StrMult=sprintf('c%d',Coefficients(1)); % Start with first coefficient
for n=2:N % Append each coefficent in list with * before it
StrMult=[StrMult, sprintf('*c'),sprintf('%d',Coefficients(n))];
end
%****************************************************************************
*********************
function [PathUp,NodesUp]=findpaths(StartNode,StopNode,Path,Nodes,Net)
%****************************************************************************
*********************
%[PathUp,NodesUp]=findpaths(StartNode,StopNode,Path,Nodes,Net)
%
%Iterative function to find path between StartNode and StopNode. Net is the
array with the network
%list in it. Path is the single path to date for a given route through the
tree. PathUp is a
%list of all paths terminated below that node that are sucesfull.
%Nodes is the list of nodes tvaersed so far on the way down
% Determine number of coefficients in net
temp=size(Net);
NumberCoeff=temp(1,1);
PathUp=[];
NodesUp=[];
% Terminate branch and return nothing if the Nodes to date contains
repetitions.
for index=1:NumberCoeff
if not(isempty(Nodes)) % Only compare if the the Path has data in it
if (sum(Nodes==index)>1)
PathUp=[];
% fprintf('Repeated Node : ');
% fprintf('%d ',Nodes);
% fprintf('\n');
return
end
end
end
% Terminate branch and return path if start and stop nodes are the same
if ((StartNode==StopNode) & (length(Path>1)))
PathUp=Path;
NodesUp=Nodes;
%fprintf('Sucessfull Path : ');
%fprintf('%d ',Path);
%fprintf('\n');
return
end
% Check for all branches leaving StartNode, and call another iteration for
them
for index=1:NumberCoeff
if (StartNode==Net(index,2))
NodesUp=[NodesUp;[FoundNodes,zeros(1,NumberCoeff+1-length(FoundPath))]];
end
end
end
%****************************************************************************
*********************
function Same=IsSameLoop(Loop1,Loop2)
%****************************************************************************
*********************
% This function takes two arrays describing two loops(Can be padded with
zeros if desired).
% Return 1 if they are they describe the same circular loop.
% Determine length of loop arrays with zeros removed
Loop1Length=sum(Loop1>0); % Count all the non zero terms
Loop2Length=sum(Loop2>0);
%Return 0 if different length since the loops can't be the same!
if (Loop1Length~=Loop2Length)
Same=0;
return
end
%They are the same length so see if the contain the same nodes, but in any
order.
% sort the nodes and subtract the two vectors. The resulting vector
componments will all be zero, only if the lists contains the same values.
if (sum(abs(sort(Loop1)-sort(Loop2)))==0)
Same=1; % Loops are the same
else
Same=0; % Loops are different
end
%****************************************************************************
*********************
function Str=PrintSumsNotTouching(L,order,Pnodes)
%****************************************************************************
*********************
% Str=PrintSumsNotTouching(L,path)
% L is the array of structs containing all the first and higher order loops.
% Pnodes is the array of nodes that decibing a path
%
% The function returns a string with the sum off all the loops of order order
% that do not touch the path. The sum is contained within a set of brackets
No_NonTouching=1; % Flag set so indacate no nontouching loops found
Str=('('); % Open the first bracket
for n=1:L{order}.NumberLoops % Look at each loop of thet order
if not(AreTouchingLoops(Pnodes,L{order}.Node{n})) %The loop doesn't touch the
path
Str=sprintf('%s%s+',Str,CoeffToString(L{order}.Coeff{n}));% So add its
coefficients
No_NonTouching=0; % Set flag to indacet a nontouching loop was found
end
end
Programa de Estudios de
FACULTAD DE INGENIERÍA DE PRODUCCIÓN Y SERVICIOS
Ingeniería Eléctrica
LABORATORIO DE CONTROL 1
2.5. Bibliografía
The Math Works Inc, Manuales MATLAB.