velocidad constante en motores DC ante cambios bruscos de carga con PIC...

[Picuino]

El circuito anterior necesita un pequeño condensador a la entrada de RA0 y RA1 (las entradas analógicas)

Código que funcionó con el motor pequeño:
(es muuy simple, sin interrupciones ni PWM ni nada)

Código: C

1. /****************************************************************************
2.    DC MOTOR SPEED CONTROL
3.  
4.    C18 COMPILER
5.  ****************************************************************************/
6.  
7. #include <p18cxxx.h>
8. #include <stdio.h>
9. #include <delays.h>
10.  
11. #define  FOSC 20000000
12. #define  BAUD 57600
13.  
14.  
15. #define DCMOT_TRIS_AN0     TRISAbits.TRISA0
16. #define DCMOT_TRIS_AN1     TRISAbits.TRISA1
17.  
18. #define DCMOT_TRIS_BEMF    TRISAbits.TRISA2
19. #define DCMOT_BEMF         PORTAbits.RA2
20.  
21. #define DCMOT_TRIS_ENABLE  TRISAbits.TRISA3
22. #define DCMOT_ENABLE       PORTAbits.RA3
23.  
24. #define DCMOT_TRIS_IN1     TRISAbits.TRISA4
25. #define DCMOT_IN1          PORTAbits.RA4
26.  
27. #define DCMOT_TRIS_IN2     TRISAbits.TRISA5
28. #define DCMOT_IN2          PORTAbits.RA5
29.  
30.  
31. /****************************************************************************
32.     ADC FUNCTIONS
33.  ****************************************************************************/
34. /*
35.   Read Analog Input AN0 or AN1
36. */
37. unsigned short adc_read(unsigned char channel) {
38.    union {
39.       struct {
40.           unsigned char lob;
41.           unsigned char hib;
42.       };
43.       unsigned short word;
44.    } adc_val;
45.  
46.    // Configure ADC
47.    ADCON0 = 0b00000001 + (channel<<2);   // ADC on
48.    ADCON1 = 0b00001101;   // Analog inputs = AN0, AN1
49.    ADCON2 = 0b10010101;   // TAD
50.  
51.    // GO ADC conversion
52.    ADCON0bits.GO = 1;        // ADC Hold and Start conversion
53.    while (ADCON0bits.GO==1); // Conversion
54.  
55.    // Configure ADC
56.    ADCON0 = 0b00000000;   // ADC off
57.    ADCON1 = 0b00001111;   // All pins to digital inputs
58.  
59.    // Return ADC conversion
60.    adc_val.lob = ADRESL;
61.    adc_val.hib = ADRESH;
62.    return adc_val.word;
63. }
64.  
65.  
66. /****************************************************************************
67.       RS232 FUNCTIONS
68.  ****************************************************************************/
69. #pragma code
70.  
71. /*
72.   Initialize USART for RS232 comunications
73. */
74. void rs232_init(void) {
75.    BAUDCONbits.BRG16 = 0;             // BRG16: 16-Bit Baud Rate Register Enable bit
76.    SPBRGH = 0;
77.    SPBRG = (FOSC/(16*BAUD))-1;        // Real Baud = FOSC/(16*(SPBRG+1))
78.  
79.    TXSTA = (char)
80.            (0<<7)    // CSRC:  1 = Syncronous Master mode
81.          + (0<<6)    // TX9:   1 = Selects 9-bit transmission
82.          + (1<<5)    // TXEN:  1 = Transmit enabled
83.          + (0<<4)    // SYNC:  1 = Synchronous mode
84.          + (0<<3)    // SENDB: 1 = Asynchronous mode: Send Sync Break on next transmission (cleared by hardware upon completion)
85.          + (1<<2)    // BRGH:  1 = Asynchronous mode: High speed
86.          + (1<<1)    // TRMT:  1 = TSR empty
87.          + (0<<0);   // TX9D:  Ninth bit of Transmit Data
88.  
89.    RCSTA = (char)
90.            (1<<7)    // SPEN:  1 = Serial port enabled
91.          + (0<<6)    // RX9:   1 = Selects 9-bit reception
92.          + (0<<5)    // SREN:  1 = Enables single receive in Master Synchronous mode
93.          + (1<<4)    // CREN:  1 = Enables Continuous Receive
94.          + (0<<3)    // ADDEN: 1 = Enables address detection (RX9 = 1)
95.          + (0<<2)    // FERR:  1 = Framing error
96.          + (0<<1)    // OERR:  1 = Overrun error (can be cleared by clearing bit CREN)
97.          + (0<<0);   // RX9D:  Ninth bit of Received Data
98.  
99.    TRISCbits.TRISC6 = 0;      // Enable TX output
100.    PIE1bits.TXIE = 0;         // Disable RS232 interrupts
101. }
102.  
103.  
104. /****************************************************************************
105.     PWM OUTPUT
106.  ****************************************************************************/
107. void dcmot_pwm(int Vo) {
108.    char i;
109.    if (Vo<1)  Vo = 1;
110.    if (Vo>99) Vo = 99;
111.    DCMOT_ENABLE = 1;        // Switch on H-bridge
112.    for(i=0; i<50; i++) {
113.       DCMOT_IN1 = 1;
114.       Delay10TCYx(Vo);
115.       DCMOT_IN1 = 0;
116.       Delay10TCYx(100-Vo);
117.    }
118.    DCMOT_ENABLE = 0;        // Switch off H-bridge
119. }
120.  
121.  
122. /****************************************************************************
123.       MAIN PROGRAM
124.  ****************************************************************************/
125. void main(void) {
126.    int Vref, Vmot, Err, Integ, Vo;
127.  
128.    // Initialize
129.    rs232_init();
130.    CMCON = 0b00000111;
131.    ADCON1 = 0b00001111;
132.    
133.    DCMOT_BEMF = 0;
134.    DCMOT_IN1 = 0;
135.    DCMOT_IN2 = 0;
136.    DCMOT_ENABLE = 0;
137.  
138.    DCMOT_TRIS_BEMF = 0;
139.    DCMOT_TRIS_IN1 = 0;
140.    DCMOT_TRIS_IN2 = 0;
141.    DCMOT_TRIS_ENABLE = 0;
142.  
143.    DCMOT_TRIS_AN0 = 1;
144.    DCMOT_TRIS_AN1 = 1;
145.  
146.    fprintf(_H_USART, (const rom far char *)"\r\nSystem OK.\r\n");
147.  
148.    // DC MOTOR SPEED CONTROL
149.    Vo = 1;
150.    Integ = 0;
151.    while(1) {
152.        dcmot_pwm(Vo);
153.  
154.       //*********************************
155.       // BACK EMF SENSE
156.       //*********************************
157.  
158.       // printf control values while I_motor decrease to 0
159.       fprintf(_H_USART, (const rom far char *)"Vm=%d   Err=%d   Intg=%d   Vo=%d\r\n", Vmot, Err, Integ, Vo);
160.       Delay10TCYx(200);
161.  
162.       DCMOT_BEMF = 1;          // Ground motor terminal
163.       Delay10TCYx(100);
164.       Vmot = adc_read(0);
165.       DCMOT_BEMF = 0;
166.  
167.  
168.       //*********************************
169.       // PI Speed control
170.       //*********************************
171.       Vref = 100;
172.       Err = Vref - Vmot;        
173.       Integ += Err;
174.       if (Integ>20000) Integ = 20000;
175.       if (Integ<-20000) Integ = -20000;
176.  
177.       Vo = Err/8 + Integ/16;
178.    }
179. }

Saludos.


Editado:
He añadido una linea muy importante:
      DCMOT_BEMF = 0;
Sin ella, el transistor Q1 se funde al comenzar el puente a dar tensión.

Saludos.

[Picuino]

No se ve el esquema, picuino

Gracias Nocturno, creo que google sites da problemas a veces mientras lo edito. (sólo lo veo yo)
Un saludo.

[Picuino]

Creo que ya se porqué se ha quemado el driver.
El problema está en el motor de mi taladro, que consume mucha corriente en la conmutación. Creo que tiene muy poca inductancia.

Para evitar este problema he cambiado el circuito de prueba añadiendo una inductancia de filtro.

También he añadido filtros a las entradas de tensión analógicas y una resistencia al transistor Q1 para que no se queme por error:



Saludos.

[LeugimZerO]

muy interesante picuino  sigo atento al hilo, termino un proyecto pendiente y hago pruebas... suerte a todos 

[Picuino]

He vuelto a medir la corriente por el motor de mi taladro y cuando lo paro con la mano, llega a picos de 8 amperios alimentando el puente a 16v.
No me extraña que el L6203 se quemara.
Para prevenirlo, el esquema final debería tener una limitación rápida por corriente excesiva. Creo que muchos micros tienen unido el comparador con el módulo PWM para apagar el PWM ante corrientes excesivas.

Por ahora lo estoy probando con un 18F2550, pero el micro final debería ser un 16F88 ¿Que opinais?

Saludos.

[Picuino]

muy interesante picuino  sigo atento al hilo, termino un proyecto pendiente y hago pruebas... suerte a todos 

Gracias LeugimZerO, cualquier aporte será bienvenido.

Veo que has publicado sobre drivers para motores PAP.

Una de las aplicaciones de este proyecto puede ser sustituir un motor PAP. En el peor de los casos un motor regulado por Back-emf puede tener un error del 5% en su velocidad.
Este error de velocidad se puede corregir con facilidad con un encoder.

La ventaja de utilizar motores DC en vez de PAP es que estás seguro de no perder pulsos y el par motor es mucho mayor.
La mayoría de las impresoras se mueven con motores DC y encoders muy baratos construídos con una lámina transparente con rayas impresas y un fotodetector:



Un saludo.

[Picuino]

Otro circuito más para hacer pruebas (y van 3):

Ya funcionan los circuitos anteriores con motores pequeños. Además he comprado otro L6203 (a ver si este me dura más )

Con este tercer circuito voy a probar:
   Conmutación con el módulo PWM del micro a frecuencias más altas (25Khz)
   Tensión de alimentación mayor (30v)
   Limitación de corriente de pico para proteger al integrado.
   Regulación PID más fina (por ahora el motor se acelera al aumentar la carga mecánica en el eje y la velocidad de giro oscila mucho)



   
Faltaría por desarrollar:
   Control del motor en los dos sentidos.
   Sensado de Back-emf en los dos sentidos.
   Sensado de corriente media por el motor.
   Regulación de par motor.

Saludos.

[amyver]

Buenisimo PICUINO... sera posible escribir el codigo del micro en "C"
saludos...

[Picuino]

El código en el que me baso está unos mensajes más arriba y ya funciona (sin módulo PWM)

Sólo hay que mejorarle.

Saludos.

[Picuino]

Ahora creo que hace falta tratar el tema de los motores DC con más detalle.

He creado un nuevo hilo donde explico el funcionamiento de los motores de corriente continua (dentro del foro técnico) y he desplazado todo el contenido que tenía en este mensaje:

GUIA: Motores de corriente continua


Saludos

[amyver]

El código en el que me baso está unos mensajes más arriba y ya funciona (sin módulo PWM)

Sólo hay que mejorarle.

Saludos.

En realidad me referia al lenguaje de programacion del CCS....

[Picuino]

No tengo instalado CSS ni lo conozco, pero no creo que sea difícil.
De hecho casi no he utilizado librerias para que sea más portable.

De todas formas el programa aun no está terminado.

Saludos.

[Picuino]

Cómo funciona un motor DC de imanes permanentes:
=======================================

1.7 Ejemplos prácticos:

Motor de 33000 rpm 30 voltios y 4 amperios:

   w = 33000 rpm = 3456 rad/s
   Pe = I · V = 4 · 30 = 120w
   Pm = Pe · n = 120 · 0.85 = 102 w     (El rendimiento n vale aproximadamente 0.85 para un motor típico de 100w)
   N = Pm / w = 102 / 3456 = 0.0295 Nm = 29.5 mNm = 301 grf·cm     (par máximo)
   Km = I / N = 4 / 0.0295 = 136 rad/s·v


Pequeño motor de 6v y 1A
    Rm = 2 ohm     (medido con polímetro)

    V = 3v   I = 0.06 A   w = 790 rpm
    Km = w / (V - Rm · I) = 790 / (3 - 2 · 0.06) = 274 rad/s·v
    N = I / Km = 1 / 274 = 0.0036 Nm = 3.6 mNm = 36.7 grf·cm    (par máximo)
    Máxima velocidad w = Eg · Km = 6 · 274 = 1644 rad/s = 15700 rpm

Saludos.

[Picuino]

Las pruebas que voy realizando dan buenos resultados.
He modificado el código para que tenga menos librerías del compilador.

Código: C

1. /****************************************************************************
2.    DC MOTOR SPEED CONTROL
3.    PICUINO APPLICATION BOARD
4.    https://sites.google.com/site/picuino
5.  ****************************************************************************/
6.  
7. #include <p18cxxx.h>
8. #include <stdio.h>
9.  
10. #define  FOSC 20000000
11. #define  BAUD 57600
12.  
13.  
14. #define DCMOT_TRIS_AN0     TRISAbits.TRISA0
15. #define DCMOT_TRIS_AN1     TRISAbits.TRISA1
16.  
17. #define DCMOT_TRIS_ENABLE  TRISCbits.TRISC1
18. #define DCMOT_ENABLE       LATCbits.LATC1
19.  
20. #define DCMOT_TRIS_IN1     TRISAbits.TRISA4
21. #define DCMOT_IN1          LATAbits.LATA4
22.  
23. #define DCMOT_TRIS_IN2     TRISAbits.TRISA5
24. #define DCMOT_IN2          LATAbits.LATA5
25.  
26.  
27.  
28. /****************************************************************************
29.       DELAY FUNCTIONS
30.  ****************************************************************************/
31. void Delay_10us(unsigned int t) {
32.     unsigned char i;
33.     do {
34.       i = 11;
35.       while(--i);
36.    } while(--t);
37. }
38.  
39.  
40. /****************************************************************************
41.     ADC FUNCTIONS
42.  ****************************************************************************/
43. /*
44.   Read Analog Input AN0 or AN1
45. */
46. unsigned short adc_read(unsigned char channel) {
47.    union {
48.       struct {
49.           unsigned char lob;
50.           unsigned char hib;
51.       };
52.       unsigned short word;
53.    } adc_val;
54.  
55.    // Configure ADC
56.    ADCON0 = 0b00000001 + (channel<<2);   // ADC on
57.    ADCON1 = 0b00001101;   // Analog inputs = AN0, AN1
58.    ADCON2 = 0b10010101;   // TAD
59.  
60.    // Make an ADC conversion
61.    Delay_10us(1);
62.    ADCON0bits.GO = 1;        // ADC Hold and Start conversion
63.    while (ADCON0bits.GO==1); // Conversion
64.  
65.    // Configure ADC
66.    ADCON0 = 0b00000000;   // ADC off
67.    ADCON1 = 0b00001111;   // All pins to digital inputs
68.  
69.    // Return ADC conversion
70.    adc_val.lob = ADRESL;
71.    adc_val.hib = ADRESH;
72.    return adc_val.word;
73. }
74.  
75.  
76. /****************************************************************************
77.       PWM FUNCTIONS
78.  ****************************************************************************/
79. /*
80.   Initialize and configure PWM module
81.   D = Duty cycle in range 0 .. 200
82. */
83. void pwm1_init(unsigned char D) {
84.    CCP1CON = 0b00001100;
85.    T2CON = 0b00000100;    // Timer2 on, prescaler = 1
86.    PR2 = 200;             // PWM Period = [(PR2) + 1] &#8226; TCY &#8226;(TMR2 Prescale Value)]
87.    CCPR1L = D;
88.    TRISCbits.TRISC2 = 0;
89. }
90.  
91.  
92.  
93. /****************************************************************************
94.       RS232 FUNCTIONS
95.  ****************************************************************************/
96.  
97. /*
98.   Initialize USART for RS232 comunications
99. */
100. void rs232_init(void) {
101.    BAUDCONbits.BRG16 = 0;             // BRG16: 16-Bit Baud Rate Register Enable bit
102.    SPBRGH = 0;
103.    SPBRG = (FOSC/(16*BAUD))-1;        // Real Baud = FOSC/(16*(SPBRG+1))
104.  
105.    TXSTA = (char)
106.            (0<<7)    // CSRC:  1 = Syncronous Master mode
107.          + (0<<6)    // TX9:   1 = Selects 9-bit transmission
108.          + (1<<5)    // TXEN:  1 = Transmit enabled
109.          + (0<<4)    // SYNC:  1 = Synchronous mode
110.          + (0<<3)    // SENDB: 1 = Asynchronous mode: Send Sync Break on next transmission (cleared by hardware upon completion)
111.          + (1<<2)    // BRGH:  1 = Asynchronous mode: High speed
112.          + (1<<1)    // TRMT:  1 = TSR empty
113.          + (0<<0);   // TX9D:  Ninth bit of Transmit Data
114.  
115.    RCSTA = (char)
116.            (1<<7)    // SPEN:  1 = Serial port enabled
117.          + (0<<6)    // RX9:   1 = Selects 9-bit reception
118.          + (0<<5)    // SREN:  1 = Enables single receive in Master Synchronous mode
119.          + (1<<4)    // CREN:  1 = Enables Continuous Receive
120.          + (0<<3)    // ADDEN: 1 = Enables address detection (RX9 = 1)
121.          + (0<<2)    // FERR:  1 = Framing error
122.          + (0<<1)    // OERR:  1 = Overrun error (can be cleared by clearing bit CREN)
123.          + (0<<0);   // RX9D:  Ninth bit of Received Data
124.  
125.    TRISCbits.TRISC6 = 0;      // Enable TX output
126.    PIE1bits.TXIE = 0;         // Disable RS232 interrupts
127. }
128.  
129.  
130. /****************************************************************************
131.       MAIN PROGRAM
132.  ****************************************************************************/
133. void main(void) {
134.    int Vref, Vmot, Err, Integ, Vo;
135.    int _Vref, _Vmot, _Err, _Integ, _Vo;
136.    char st1;
137.  
138.    //*********************************
139.    // Initialize
140.    //*********************************
141.    rs232_init();
142.    CMCON = 0b00000111;
143.    ADCON1 = 0b00001111;
144.    
145.    DCMOT_IN1 = 0;
146.    DCMOT_IN2 = 0;
147.    DCMOT_ENABLE = 0;
148.  
149.    DCMOT_TRIS_IN1 = 0;
150.    DCMOT_TRIS_IN2 = 0;
151.    DCMOT_TRIS_ENABLE = 0;
152.  
153.    DCMOT_TRIS_AN0 = 1;
154.    DCMOT_TRIS_AN1 = 1;
155.  
156.    fprintf(_H_USART, (const rom far char *)"\r\nSystem OK.\r\n");
157.  
158.    //*********************************
159.    // DC MOTOR SPEED CONTROL
160.    //*********************************
161.    Integ = 0;
162.    st1 = 0;
163.    while(1) {
164.  
165.       //*********************************
166.       // PID Speed control
167.       //*********************************
168.       Vref = 50;
169.       Err = Vref - Vmot;        
170.       Integ += Err;
171.       if (Integ>30000) Integ = 30000;
172.       if (Integ<-30000) Integ = -30000;
173.  
174.       Vo = Vref/5 + Err/5 + Integ/16;
175.  
176.       //*********************************
177.       // Debug PID values
178.       //*********************************
179.       switch (st1++) {  
180.          case 1: _Vref = Vref;
181.                  _Vmot = Vmot;
182.                  _Err = Err;
183.                  _Integ = Integ;
184.                  _Vo = Vo;
185.                  break;
186.          case 2: fprintf(_H_USART, "Vm=%3d   ", _Vmot);
187.                  break;
188.          case 3: fprintf(_H_USART, "Err=%3d   ", _Err);
189.                  break;
190.          case 4: fprintf(_H_USART, "Intg=%5d   ", _Integ);
191.                  break;
192.          case 5: fprintf(_H_USART, "Vo=%-3d", _Vo);
193.                  break;
194.          case 6: fprintf(_H_USART, "\r\n");
195.                  st1 = 0;
196.                  break;
197.       }
198.    
199.  
200.       //*********************************
201.       // PWM driver output
202.       //*********************************
203.       if (Vo>100) pwm1_init(100);
204.       else if (Vo<0) pwm1_init(0);
205.       else pwm1_init(Vo);
206.       Delay_10us(800);
207.  
208.  
209.       //*********************************
210.       // BACK EMF SENSE
211.       //*********************************
212.       DCMOT_ENABLE = 0;
213.       Delay_10us(80);
214.       Vmot = adc_read(0);
215.       DCMOT_ENABLE = 1;
216.    }
217. }

Si alguien lo quiere probar puede escribir sus resultados y aportar su opinión, que será bien recibida.
Saludos.

[amyver]

Para tomar las lecturas de la Back-emf con inversion de giro, progongo usar el integrado 4053, que es un muliplexor/demultiplexor analogico..

tube problemas al subir la imagen del circuito ...pero en fin el  integrado 4053 es muy simple de ser utilizado...

bueno el circuito habla por si mismo, cualquier aporte o comentario bien venido...

Saludos