Motor Paso

En nuestro trabajo relacionado al motor paso a paso, hemos decidido usar un motor unipolar por las siguientes ventajas: Menor costo en el circuito de control, y son más factibles y fáciles el manejo de dichos motores.

Veamos a continuación como usamos el motor:

Empezamos definiendo las patitas A,B,C, y D del motor de la siguiente manera:

Para identificar el cable común:
Con el multímetro en modo ohmetro comenzamos a medir resistencias por todos los cables y para mayor sorpresa solo se obtienen tres valores distintos y que se repiten varias veces
- 47 ohm
- 100 ohm
100 Ohm es el mayor valor por lo tanto corresponde a los extremos de las bobinas, es decir A-B o bien C-D.

47 Ohm es aproximadamente la mitad de 100, por tanto esa debe ser la resistencia entre el terminal común y ambos extremos de una bobina, por ejemplo entre A-Com1 o B-Com1, o bien en la otra bobina, C-Com2 o D-Com2.

Lo que queda pendiente es cuando no marca nada, y bueno es que en ese momento se midieron los cables de bobinas distintas.

Ahora suponte que unes los terminales Com1 y Com2, entonces nos quedamos con un motor de 5 cables.
Para identificar A, B, C y D:
Como unimos los cables comunes de cada bobina los cuatro cables restantes serán A, B, C y D, se conecta el terminal común al positivo de la fuente de alimentación, toma uno de los 4 cables que te quedaron, lo bautizas como A y lo mandas a GND, el motor quedará enclavado en una sola posición, ahora se sostiene otro de los tres que te quedaron, el motor dará un primer paso.

Aquí pueden ocurrir 3 cosas
-Que el motor gire a derecha, lo bautizas como B
-Que gire a izquierda, lo nombras D
-Si no pasa nada es C
Si este último cable era B entonces lo desconectamos y mantenemos A Conectado se buscas D, es decir que gire a izquierda y bueno, C es el que quedó libre.
Luego de conocer las patitas del motor procedemos a armar el circuito, y para esto es necesario contar con un ULN2003, que se encuentra en el mercado a un valor de 1.5 soles, este integrado nos servirá par manejar el motor paso, se trata de un array de transistores Dárlington capaz de manejar hasta 500mA en sus salida.

Veamos los esquemas a continuación:

Para controlar el motor paso decidimos hacerlo con un microcontrolador Pic16f84A, que es de fácil manejo y muy económico, con un oscilador de Cristal de 4 Mhz, Para el ejemplo usamos 4 entradas y 4 salidas, las 4 primeras (Port A) fueron para los switch de control, estos hacían girar el motor en ángulos de 360º, 180º, 90º y en sentido contrario, las otras cuatro salidas (Port B) fueron usadas para controlar el motor, Tal como se muestran en las imágenes a continuación.

El programa de control en lenguaje Assembler es el siguiente:

; Programa de Control para un motor paso

list p=16f84a
include
include

cblock 0xC
AUX1
AUX2
AUX3
AUX4
endc

org 0000h
goto inicio
org 5
goto inicio


;**********declaracion de variables*********
inicio
bsf STATUS,5
movlw b'11111111'
movwf TRISB
clrf TRISA
bcf STATUS,5
clrf PORTA
;***********programa principal************

principal
clrf PORTB
btfss PORTB,1
goto pasos_360
btfss PORTB,2
goto pasos_180
btfss PORTB,3
goto pasos_90
btfss PORTB,4
goto pasos_reversa
goto principal


;************Vuelta completa********
pasos_360
movlw .13
movwf AUX1
loop1
decfsz AUX1
goto loop2
clrf PORTA
goto principal
loop2
call pasos
goto loop1

;***********Media Vuelta************
pasos_180
movlw .7
movwf AUX2
loop3
decfsz AUX2
goto loop4
clrf PORTA
goto principal
loop4
call pasos
goto loop3


;********Cuarto de Vuelta***********
pasos_90
movlw .4
movwf AUX3
loop5
decfsz AUX3
goto loop6
clrf PORTA
goto principal
loop6
call pasos
goto loop5

;**************Reversa***************
pasos_reversa
movlw .13
movwf AUX4
loop7
decfsz AUX4
goto loop8
clrf PORTA
goto principal
loop8
call pasos
goto loop7

;***********Rutina de pasos***********
pasos
movlw b'00001000'
movwf PORTA
delay_ms .50
movlw b'00001001'
movwf PORTA
delay_ms .50
movlw b'00000001'
movwf PORTA
delay_ms .50
movlw b'00000011'
movwf PORTA
delay_ms .50
movlw b'00000010'
movwf PORTA
delay_ms .50
movlw b'00000110'
movwf PORTA
delay_ms .50
movlw b'00000100'
movwf PORTA
delay_ms .50
movlw b'00001100'
movwf PORTA
delay_ms .50
return

include
END

Este programa podria ser el inicio de un control mucho más completo, hoy en día existen muchas aplicaciones las cuales podríamos destacar y controlarlos del mismo modo que nuestra aplicación.

• Taxímetros
• Brazo y Robots completos.
• Patrón mecánico de velocidad angular.
• Máquinas de escribir electrónicas.
• Posicionamiento de válvulas en controles industriales.
• Posicionamiento de piezas en general.

EJEMPLO DE UN SISTEMA BIOLÓGICO SIMPLE

Los componentes básicos del sistema son

Entrada: dirección hacia la que se quiere caminar Salida: dirección que realmente se sigue al caminar.

Controlador o regulador: el cerebro.

Planta o proceso: piernas y pies que sirven para caminar.

Comparador: el cerebro que compara la dirección deseada con la dirección real, dando una señal de error, con la que se va corrigiendo las posibles desviaciones de la dirección deseada, actuando sobre el sistema nervioso central y éste a su vez sobre piernas y pies.

Los ojos en esta ocasión servirían de realimentación ya que son los que captan la dirección real y continuamente indican al cerebro la dirección en que se camina.

Calentador

Controladores

Un controlador PI, se caracteriza por la función de transferencia:

Este controlador introduce un cero y un polo en el sistema. De esta forma se está aumentando el orden de la función de transferencia en lazo abierto, por lo que provoca que el sistema sea menos estable o incluso pueda llegar a la inestabilidad. Un controlador PI actúa como un compensador de retardo de fase, incrementando la ganancia a bajas frecuencias y mejorando la precisión del estado estacionario.

Por consiguiente se debe tener cuidado en la elección de los parámetros Kp y Ti, para asegurar una respuesta transitoria adecuada.

Un controlador PD, se caracteriza por la función de transferencia:

Este controlador introduce un cero en el sistema. Se comporta como un compensador de adelanto afectando a la región de altas frecuencias, mejora la estabilidad del sistema y la respuesta transitoria.

Se han elaborado diversos métodos de sintonización de controladores. El controlador para el que se suelen referenciar los mismos es el PID.

DISEÑO DE UN COMPENSADOR DE ADELANTO

Diseño de un Compensador de Adelanto Ogata K, Ingeniería de Control Moderna

Considere el sistema de la figura 9-6. La función de transferencia en lazo abierto es
Se quiere diseñar un compensador para el sistema de modo que la constante de error estático de velocidad Kv sea de 20 seg-1, el margen de fase sea al menos de 50” y el margen de ganancia sea al menos de 10 dB.

%---------------------------------------
%Diseño de un Compensador de Adelanto
%Ogata K, Ingeniería de Control Moderna
%Tercera Edición
%Ejemplo 9.1, pag. 615
%_--------------------------------------

close all, clear all, clc

%Planta
num=4; den=[1 2 0]; planta=tf(num,den);

%Requerimientos de Diseño
kv=20; MFD=50; MG=50;

%Se halla k del Compensador
kva=polyval(num,0)/polyval(deconv(den,[1 0]),0);
k=kv/kva;

%Se continúa el diseño sobre plantaux=k*planta
numaux=k*num; denaux=den; plantaux=tf(numaux,denaux);

%Se halla los vectores de Ganancia (gandB) y Fase (fase)
w=logspace(-1,2,500); [gan,fase]=bode(numaux,denaux,w); gandB=20*log10(gan);

%Se halla el margen de fase: MF
VectIndices=find(gandB<0);>

Indice=VectIndices(1);

MF=180-(-fase(Indice));

%Se halla la fase a compensar: Fadic Fadic=MFD-MF+5;

%alfa alfa=(1-sin(Fadic*pi/180))/(1+sin(Fadic*pi/180));

%ganancia del compensador r=20*log10(sqrt(1/alfa));

%Se halla la nueva frecuencia de creuce de ganancia: wm VectIndice2=find(gandB<-r); Indice2=VectIndice2(1);

wm=w(Indice2)

%T T=1/sqrt(alfa)/wm;

%Parámetros del Compensador

Zc=1/T; Pc=1/alfa/T; Kc=k/alfa; Comp=tf(Kc*[1 Zc],[1 Pc])

%Planta Compensada PlantaCompensada=series(planta,Comp)

%Respuesta en el Tiempo

figure(1), step(feedback(planta,1)), hold on, grid on step(feedback(PlantaCompensada,1))

%Respuesta en Frecuencia

figure(2),bode(planta), hold on, grid on bode(PlantaCompensada)

SISTEMAS BIOLÓGICOS

Función el lazo abierto

function ojo(td,k,te)
num=[(k/2)*td^2 -k*td k];
den=[conv([te 1],conv([te 1],[te 1]))];
sys=tf(num,den)
step(sys)

Función en lazo cerrado

function ojo2(b,a,t5,t4,t3,t2,t1,s,t)
disp('t=1 step otherwise impulse')
if t==1
if s==1
num=[b];
den=conv([(1/2)*t5^2 t5 1],[t3 1]);
sys=tf(num,den)
num1=[a 0];
den1=[conv([(1/2)*t4^2 t4 1],conv([t1 1],[t2 1]))];
sys1=tf(num1,den1)
sys2=sys+sys1
step(sys2)
else
num=[b];
den=conv([(1/2)*t5^2 t5 1],[t3 1]);
sys=tf(num,den)
% num1=[(a/2)*t5^2 -a*t5 a 0];
% den1=[conv([t1 1][t2 1])];
% sys1=tf(num1,den1);
% sys2=sys+sys1
step(sys)
end
else
if s==1
num=[b 0];
den=conv([(1/2)*t5^2 t5 1],[t3 1]);
sys=tf(num,den)
num1=[a 0 0];
den1=[conv([(1/2)*t4^2 t4 1],conv([t1 1],[t2 1]))];
sys1=tf(num1,den1)
sys2=sys+sys1
step(sys2)
else
num=[b 0];
den=conv([(1/2)*t5^2 t5 1],[t3 1]);
sys=tf(num,den)
% num1=[(a/2)*t5^2 -a*t5 a 0];
% den1=[conv([t1 1][t2 1])];
% sys1=tf(num1,den1);
% sys2=sys+sys1
step(sys)
end
end

Para entrada step y = 0

>> ojo2(0.24,1.2,0.6,0.3,1,0.46,0.4,0,1)
t=1 step otherwise impulse

Transfer function:
0.24
-------------------------------
0.18 s^3 + 0.78 s^2 + 1.6 s + 1

Para entrada step y = 1

>> ojo2(0.24,1.2,0.6,0.3,1,0.46,0.4,1,1)
t=1 step otherwise impulse

Transfer function:
0.24
-------------------------------
0.18 s^3 + 0.78 s^2 + 1.6 s + 1


Transfer function:
1.2 s
-------------------------------------------------
0.00828 s^4 + 0.0939 s^3 + 0.487 s^2 + 1.16 s + 1


Transfer function:
0.218 s^4 + 0.9585 s^3 + 2.037 s^2 + 1.478 s + 0.24
----------------------------------------------------------------------------------------
0.00149 s^7 + 0.02336 s^6 + 0.1742 s^5 + 0.7472 s^4 + 1.958 s^3 + 3.123 s^2 + 2.76 s + 1

Para entrada impulse y = 0

>> ojo2(0.24,1.2,0.6,0.3,1,0.46,0.4,0,0)
t=1 step otherwise impulse

Transfer function:
0.24 s
-------------------------------
0.18 s^3 + 0.78 s^2 + 1.6 s + 1

Para entrada step y = 1

>> ojo2(0.24,1.2,0.6,0.3,1,0.46,0.4,1,0)
t=1 step otherwise impulse

Transfer function:
0.24 s
-------------------------------
0.18 s^3 + 0.78 s^2 + 1.6 s + 1


Transfer function:
1.2 s^2
-------------------------------------------------
0.00828 s^4 + 0.0939 s^3 + 0.487 s^2 + 1.16 s + 1


Transfer function:
0.218 s^5 + 0.9585 s^4 + 2.037 s^3 + 1.478 s^2 + 0.24 s
----------------------------------------------------------------------------------------
0.00149 s^7 + 0.02336 s^6 + 0.1742 s^5 + 0.7472 s^4 + 1.958 s^3 + 3.123 s^2 + 2.76 s + 1

Control Proporcional

Nos piden implementar un control proporcional para el sistema que aparece en la figura 1 con la condición de que el sistema resultante tenga un sobreimpulso del 20%, luego de ello variar los valores de K para poder observar la variación

Primero en el workspace implementamos el sistema de la siguiente manera;

>> num=[1];

>> den=[conv([1 1],conv([1 2],[1 3]))];

>> sys=tf(num,den)

Transfer function:

1

----------------------

s^3 + 6 s^2 + 11 s + 6

>> t=feedback(sys,1)

Transfer function:

1

----------------------

s^3 + 6 s^2 + 11 s + 7

después de haber echo eso aplicamos una señal escalón para obtener su respuesta

>> step(t)

Respuesta al Step

Como podemos observar el sistema sin el control proporcional no presenta sobreimpulso y su velocidad de establecimiento es muy lenta. Después de realizar esto tenemos que hacer el diseño del controlador, pero como sólo contamos con un sólo dato hacemos uso de una herramienta del Matlab llamada Rltool en la cual con únicamente conocer el factor de amortiguamiento, el sobreimpulso, etc. podemos diseñar un controlador proporcional. Para ello hacemos o siguiente en el workspace:

>> rltool

Figura 1

Una vez obtenida la gráfica de Rltool (gráfica del lugar geométrico e las raíces) como se observa en la figura 2 procedemos al diseño, que en este caso depende del sobreimpulso, para ello en los requerimientos de diseño seleccionamos la opción por porcentaje de sobreimpulso y digitamos el valor que deseamos, en este caso 20%

Figura 2

Después de esto nos aparece en la gráfica del Rltool unas líneas negras que cortan la gráfica, lo que nos quieren decir estas líneas es que en esos puntos se cumple la condición que le hemos impuesto al sistema. Entonces para poder obtener un sobreimpulso del 20% sólo tenemos que arrastrar los polos al punto de intersección entre las líneas negras y la gráfica del Rltool, como se puede observar en la figura 3

Figura 3

Después de haber arrastrado los polos al punto de intersección de las gráficas procedemos a obtener la respuesta ante una entrada escalón, la cual se ve en la figura 4 y comprobamos que el porcentaje de sobreimpulso es cercano al valor que deseamos.

Figura 4

Después de ello nos fijamos que valor de K nos posibilita tener esa gráfica, con ello implementamos el circuito. Ponemos un potenciómetro en el lugar donde va el valor de K para que con ello nos permita variar los valores de k y así poder obtener graficas diferentes.

En la práctica que se realizó en el laboratorio tuvimos ciertos inconvenientes debido a que el sistema respondía a frecuencias bajas; esto lo hallamos de la respuesta en frecuencia del sistema es decir del diagrama de Bode (figura5), por ello utilizamos un switch y un trigger smith lo que podemos observar en la figura 6

Figura 5

Figura 6

Las respuestas halladas para el sistema a una respuesta escalón son las siguientes:

Para K = 9.9KΩ

Para K = 7.75KΩ

Para K = 4.59KΩ

Para K = 1.53KΩ

Para K = 2.8Ω

Circuito Implementado