Autor Tema: Robot equilibrista  (Leído 211786 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado gary_servin

  • PIC12
  • **
  • Mensajes: 65
Re: Robot equilibrista
« Respuesta #360 en: 08 de Septiembre de 2010, 00:50:06 »
Hola a todos! Acá les muestro un avance de como va quedando la estructura para el robot equilibrista que estoy armando. Faltan los bujes para acoplar el eje del motor a las ruedas (espero para mañana tenerlos ya). Un saludo a todos y les dejo las fotos!

          


Desconectado edu_solano

  • PIC10
  • *
  • Mensajes: 1
Re: Robot equilibrista
« Respuesta #361 en: 10 de Septiembre de 2010, 12:37:03 »
Hola a todos, me llamo Edu y soy de un pueblecito de España. Estoy empezando con este proyecto también!

Este hilo es muy interesante, me he leydo todas las paginas del tirón

De momento ya tengo el acelerometro ya he probado la adquisicion de datos con el AD del micro y parece que funcioana todo bien..poco a poco..
Y vosotros como andais? Gera hace tiempo que no veo como va tu proyecto que tal lo llevas? y tu gary? veo que lo tienes muy avanzado por las fotos jeje
Y todos los demás? como llevais el proyecto? estais atascados en algun sitio? avanzando? contadme si no es mucha molestia como les va a cada uno y asi vemos quien sigue en el proyecto y nos ayudamos mutuamente.

No dejen de trabajar en este proyecto que se puede aprender mucho de él.

Un saludo amigos!

Desconectado rivale

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1707
Re: Robot equilibrista
« Respuesta #362 en: 22 de Octubre de 2010, 18:39:54 »
Hola a todos, yo estoy empezando con un robotito de este estilo, tengo unas dudas tecnicas, espero me puedan ayudar.

Quisiera saber cual es la diferencia entre un acelerometro y un giroscopio, porque se necesitan ambos?. tengo entendido que el giroscopio mide un angulo de giro, si este fuera el caso, el giro tambien se podria medir con un acelerometro, siendo mas especifico utilizando este:

http://www.freescale.com/webapp/sps/site/prod_summary.jsp?code=MMA8450Q&webpageId=1084288158625737424209&nodeId=01126911184209&fromPage=tax

en las hojas de aplicaciones viene que se pueden medir varias cosas dependiedno de la configuracion del acelerometro. entonces en lugar de uzar un giroscopio se podria usar uno de estos??
"Nada es imposible, no si puedes imaginarlo"

Desconectado gary_servin

  • PIC12
  • **
  • Mensajes: 65
Re: Robot equilibrista
« Respuesta #363 en: 22 de Octubre de 2010, 21:51:08 »
Hola a todos, yo estoy empezando con un robotito de este estilo, tengo unas dudas tecnicas, espero me puedan ayudar.

Quisiera saber cual es la diferencia entre un acelerometro y un giroscopio, porque se necesitan ambos?. tengo entendido que el giroscopio mide un angulo de giro, si este fuera el caso, el giro tambien se podria medir con un acelerometro, siendo mas especifico utilizando este:

http://www.freescale.com/webapp/sps/site/prod_summary.jsp?code=MMA8450Q&webpageId=1084288158625737424209&nodeId=01126911184209&fromPage=tax

en las hojas de aplicaciones viene que se pueden medir varias cosas dependiedno de la configuracion del acelerometro. entonces en lugar de uzar un giroscopio se podria usar uno de estos??

Hola rivale

El giroscopio mide la velocidad angular a la que esta sometido el mismo, el acelerometro mide la aceleración en cualquiera de los 3 (o 2 o 1, dependiendo del modelo) ejes y a través de unas transformaciones podemos obtener de estas mediciones, el angulo de inclinación.  Se utilizan los 2 debido a que el acelerometro solo es muy susceptible a "ruidos", debido al movimiento del robot, osea, al estar en movimiento el robot va a tener una componente de aceleración en alguno/s de los ejes, provocando errores en la medición del angulo, y además, el giroscopio no permite la medición absoluta del angulo debido a que no podemos conocer la posición inicial del sistema.

Espero que te haya podido ayudar!

Saludos!

Desconectado marito

  • PIC16
  • ***
  • Mensajes: 217
Re: Robot equilibrista
« Respuesta #364 en: 01 de Noviembre de 2010, 20:00:03 »
Hola a todos!!!
Leyendo en comentarios sobre el filtro Kalman encontre que han borrado dos líneas de código.
Estoy trabajando sobre un robot con un acelerometro de dos ejes y un giro de +-300º. En la primer etapa calculaba el ángulo sin aplicar el filtro y cuando puse a funcionar el filtro la señal mejoro un poco.
Le gente que elimino esas líneas no veia ninguna mejoría???
Saludos

Desconectado gera

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 2188
Re: Robot equilibrista
« Respuesta #365 en: 21 de Diciembre de 2010, 23:19:35 »
Buenasssss!!! Paso a mostrar mis avances jeje.


Al final termine usando el mbed en lugar de un pic, hice en una semana lo q me demoro 2 meses con un pic jeje. Las plaquitas de la base son los puente H q diseñe hace poco porque el l298 no se bancaba la corriente q consumen esos motores.
Bueno, mas adelante doy mas detalles.. todavia esta en fase de prueba la cosa jeje.
Saludos!!

"conozco dos cosas infinitas: el universo y la estupidez humana. Y no estoy muy seguro del primero." A.Einstein

Desconectado gary_servin

  • PIC12
  • **
  • Mensajes: 65
Re: Robot equilibrista
« Respuesta #366 en: 21 de Diciembre de 2010, 23:30:10 »
Excelente gera! Quedó muy bueno!  :-/ :-/ :-/

Desconectado bernardo62001

  • PIC10
  • *
  • Mensajes: 4
Robot equilibrista
« Respuesta #367 en: 31 de Diciembre de 2010, 00:06:57 »
  :-/
Pues échenle  un vistazo al que una amiga :g) y yo :shock: hicimos.


A ver q les parece. ;-)

Desconectado Nocturno

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 17670
    • MicroPIC
Re: Robot equilibrista
« Respuesta #368 en: 31 de Diciembre de 2010, 04:02:11 »
Cuando está quieto se ve muy firme, casi no se mueven las ruedas.
Un saludo desde Sevilla, España.
Visita MicroPIC                                                                                        ɔ!doɹɔ!ɯ ɐʇ!s!ʌ

Desconectado bernardo62001

  • PIC10
  • *
  • Mensajes: 4
Re: Robot equilibrista
« Respuesta #369 en: 31 de Diciembre de 2010, 14:03:51 »
Si se mantiene bien estable vdd? :P , aunque como la camara es chafita no se alcanza  a ver como
oscila  un poquito, pero aun asi me falta seguir  optimizando el control para que esta as estable todabia
 :-/





Desconectado bernardo62001

  • PIC10
  • *
  • Mensajes: 4
Re: Robot equilibrista
« Respuesta #370 en: 01 de Enero de 2011, 23:33:39 »
Que tal aqui esta otro video del balancing robot que  diseñamos, este tiene mejor calidad y tiene audio.

http://www.youtube.com/user/Bernard062001?feature=mhum#p/a/u/0/Vt6jrgp1i6A :mrgreen:

Desconectado gera

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 2188
Re: Robot equilibrista
« Respuesta #371 en: 01 de Enero de 2011, 23:56:44 »
Felicitaciones bernardo!! Se ve genial!! Muy estable!!
Yo tuve un percance con el mio que me costo el mbed (el procesador) :( Asiq va a funcionar con un pic como lo habia planeado en un principio. Pero antes de seguir voy a rediseñar los circuitos con mas medidas de seguridad para evitar q ocurra de nuevo. Probablemente alimentar por separado los circuitos y los motores.
Saludos!!

"conozco dos cosas infinitas: el universo y la estupidez humana. Y no estoy muy seguro del primero." A.Einstein

Desconectado bernardo62001

  • PIC10
  • *
  • Mensajes: 4
Re: Robot equilibrista
« Respuesta #372 en: 02 de Enero de 2011, 14:26:59 »
Nosotros usamos el pic18f1320, y como puedes ver en el video alimentamos el pic con una pila de 9 [V] y el puente H está conectado a una fuente de voltaje de 12 Volts.   ;-), es decir los circuitos de control están aislados ópticamente de la parte de potencia, porque con el ruido que se genera en la alimentación debido a la conmutación, hace que el pic pierda la secuencia.
« Última modificación: 02 de Enero de 2011, 14:29:35 por bernardo62001 »

Desconectado AKENAFAB

  • Colaborador
  • DsPIC30
  • *****
  • Mensajes: 3177
    • Automation Media Lab
Re: Robot equilibrista
« Respuesta #373 en: 02 de Enero de 2011, 15:13:16 »
Buenasssss!!! Paso a mostrar mis avances jeje.


Al final termine usando el mbed en lugar de un pic, hice en una semana lo q me demoro 2 meses con un pic jeje. Las plaquitas de la base son los puente H q diseñe hace poco porque el l298 no se bancaba la corriente q consumen esos motores.
Bueno, mas adelante doy mas detalles.. todavia esta en fase de prueba la cosa jeje.
Saludos!!

Cual fue la diferencia de trabajar con el  mbed y pic para tu progreso en 2 semanas??? sin contar que ya habias ganado experiencia desarrollando tu aplicación 2 meses atras.

Que fue lo que te daño el embed?????

Desconectado gera

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 2188
Re: Robot equilibrista
« Respuesta #374 en: 02 de Enero de 2011, 19:04:08 »
La diferencia fue la potencia del mbed, la facilidad para programarlo, y las librerias q trae. Además que el circuito se simplifico bastante porque este trabaja a 3.3V, al igual que el modulo bluetooth, el acelerometro y el gyro.
Te muestro el codigo en C del pic, y en C++ del mbed, para q veas la diferencia en cuanto a lineas jeje.

Código del PIC
Código: C
  1. #define __PCH__ 1
  2. #include <18F452.h>
  3. #device adc=10
  4. #fuses HS,NOWDT,NOPROTECT,NOLVP
  5. #use delay(clock=20000000)
  6.  
  7. #use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)
  8.  
  9. #include <stdlib.h>
  10.  
  11. //puerto B
  12. #define DIRR PIN_B2
  13. #define DIRL PIN_B3
  14. #define ENCODERL PIN_B4
  15. #define ENCODERR PIN_B5
  16.  
  17. //puerto C
  18. #define PWMR PIN_C1
  19. #define PWML PIN_C2
  20.  
  21. //puerto D
  22. #define MOTORL1 PIN_D0
  23. #define MOTORL2 PIN_D1
  24. #define MOTORR1 PIN_D2
  25. #define MOTORR2 PIN_D3
  26. #define LED PIN_D7
  27.  
  28. //constantes sensores
  29. #define X_OFFSET     540.0
  30. #define Y_OFFSET     490.0
  31. #define GYRO_OFFSET  402.0
  32. #define MOD          247.0
  33.  
  34. //otras constantes
  35. #define FORWARD  0
  36. #define BACKWARD 1
  37. #define STOP     2
  38.  
  39. #define N_SAMPLES    64
  40. #define PRELOAD_TMR1 65043 //10 KHz prescaler=1
  41. #define PR2 107
  42. #define UT_MAX 800
  43.  
  44. //direcciones eeprom
  45. #define KP_DIR 0x00
  46. #define KI_DIR 0x08
  47. #define KD_DIR 0x10
  48. #define RT_DIR 0x18
  49.  
  50.  
  51. //variables globales----------------
  52. float Kp=0.0,Ki=0.0,Kd=0.0;
  53.  
  54. struct BytesPID
  55. {
  56.     float rT;  //Valor del Set Point
  57.     float eT;  //Valor del Error
  58.     float iT;  //Valor del termino Integral
  59.     float dT;  //Valor del termino Derivativo
  60.     float yT;  //Valor real
  61.     float uT;  //Valor de salida del controlador
  62.     float iT0; //Valor del termino integral en t0
  63.     float eT0; //Valor del termino del error en t0  
  64. }PID = {0,0,0,0,0,0,0,0};
  65.  
  66.  
  67. long int accel_x=0,gyro_rate=0;
  68.  
  69. //variables para el filtro
  70. float P[2][2] = {{ 1, 0 },{ 0, 1 }};
  71. float R_angle = 0.6;
  72. float Q_angle = 0.001;
  73. float Q_gyro = 0.003;
  74. float q_bias=0, angle=0, gyro=0, dt=0.0005,acc_angle=0;
  75.  
  76.  
  77. float pwm_R=0, pwm_L=0;
  78.  
  79. short flag_samples=0;
  80.  
  81. //funciones-------------------------
  82. void init();
  83. void get_samples();
  84. void calculate_angle();
  85. void refresh_pid();
  86. void set_motors();
  87. void state_update();
  88. void kalman_update(float angle_m);
  89.  
  90. void write_float_eeprom(long int n, float data);
  91. float read_float_eeprom(long int n);
  92.  
  93.  
  94. #int_timer1
  95. void timer1_isr()
  96. {
  97.    flag_samples=1;
  98.    set_timer1(PRELOAD_TMR1);
  99. }
  100.  
  101. #int_rda
  102. void serial_isr()
  103. {
  104.   char key[16];
  105.  
  106.   if(kbhit())
  107.   {
  108.     gets(key);
  109.    
  110.     switch(key[0])
  111.       {
  112.          case 'p':
  113.             Kp = atof((key+1));
  114.             printf("Kp = %f\r\n",Kp);
  115.             break;
  116.          case 'i':
  117.             Ki = atof((key+1));
  118.             printf("Ki = %f\r\n",Ki);
  119.             break;
  120.          case 'd':
  121.             Kd = atof((key+1));
  122.             printf("Kd = %f\r\n",Kd);
  123.             break;
  124.          case 'r':
  125.             PID.rT = atof((key+1));
  126.             printf("rT = %f\r\n",PID.rT);
  127.             break;
  128.          case 'a':
  129.             printf("angle = %f\r\n",angle);
  130.             break;
  131.          case 'g':
  132.             write_float_eeprom(KP_DIR, Kp);
  133.             write_float_eeprom(KI_DIR, Ki);
  134.             write_float_eeprom(KD_DIR, Kd);
  135.             write_float_eeprom(RT_DIR, PID.rT);
  136.             printf("datos guardados\r\n");
  137.             break;
  138.          case 'l':
  139.             printf("rT=%f\nkp=%f\nki=%f\nkd=%f\n\r\n",read_float_eeprom(RT_DIR),read_float_eeprom(KP_DIR),read_float_eeprom(KI_DIR),read_float_eeprom(KD_DIR));
  140.             break;
  141.          case 'h':
  142.             printf("p<valor>: define la constante kp\ni<valor>: define la constante ki\nd<valor>: define la constante kd\nr<valor>: define el setpoint rT\na: devuelve el anguloactual\ng: guarda las constantes en la eeprom\nl: muestra los valores guardados en la eeprom\n\r\n");
  143.             break;
  144.          default:
  145.             printf("error: comando desconocido\r\n");
  146.             break;
  147.       }
  148.   }
  149. }
  150.  
  151.  
  152. void main()
  153. {  
  154.    delay_ms(100);
  155.    init();
  156.    
  157.    while(TRUE)
  158.    {
  159.       if(flag_samples)
  160.       {
  161.          get_samples();
  162.          calculate_angle();
  163.          if(angle < 0.7 && angle > -0.7)
  164.          {
  165.             refresh_pid();
  166.             pwm_R = -PID.uT;
  167.             pwm_L = -PID.uT;
  168.          }
  169.          else
  170.          {
  171.             pwm_R = 0;
  172.             pwm_L = 0;
  173.          }
  174.          
  175.          set_motors();
  176.          flag_samples = 0;
  177.       }
  178.       output_toggle(LED);
  179.       delay_ms(500);
  180.      
  181.    }
  182. }
  183.  
  184.  
  185.  
  186. void init()
  187. {
  188.    //E/S digitales
  189.    set_tris_a(0b111111);   //RA5,RA4,ref3V3,gyro,accelY,accelX
  190.    set_tris_b(0b11111100); //RB7,RB6,encoderR,encoderL,dirL,dirR,RB1,RB0
  191.    set_tris_c(0b10000000); //rx,tx,RC5,RC4,RC3,pwm1,pwm2,RC0
  192.    set_tris_d(0b00000000); //led,RD6,RD5,RD4,motorR2,motorR1,motorL2,motorL1
  193.    
  194.    //PWM
  195.    setup_timer_2(T2_DIV_BY_4, PR2, 1);
  196.    setup_ccp1(CCP_PWM);   // Configure CCP1 as a PWM
  197.    setup_ccp2(CCP_PWM);   // Configure CCP2 as a PWM
  198.    
  199.    //Timer1
  200.    setup_timer_1 ( T1_INTERNAL | T1_DIV_BY_1 );
  201.    
  202.    //entradas analogicas
  203.    setup_adc_ports(AN0_AN1_AN2_AN4_VSS_VREF);
  204.    setup_adc(ADC_CLOCK_INTERNAL);
  205.    
  206.    //interrupciones
  207.    enable_interrupts(INT_RDA);
  208.    enable_interrupts(INT_TIMER1);
  209.    disable_interrupts(GLOBAL);
  210.    
  211.    set_timer1(PRELOAD_TMR1);
  212.    
  213.    Kp = read_float_eeprom(KP_DIR);
  214.    Ki = read_float_eeprom(KI_DIR);
  215.    Kd = read_float_eeprom(KD_DIR);
  216.    PID.rT = read_float_eeprom(RT_DIR);
  217.    
  218.    enable_interrupts(GLOBAL);
  219. }
  220.  
  221.  
  222. void get_samples()
  223. {
  224.    int i;
  225.    accel_x=0;
  226.    gyro_rate=0;
  227.    
  228.    for(i=0;i<N_SAMPLES;i++)
  229.    {
  230.       set_adc_channel(0);
  231.       delay_us(20);
  232.       accel_x += read_adc();
  233.      
  234.       set_adc_channel(2);
  235.       delay_us(20);
  236.       gyro_rate += read_adc();
  237.    }
  238.    
  239.    accel_x /= N_SAMPLES;
  240.    gyro_rate /= N_SAMPLES;
  241. }
  242.  
  243.  
  244. void calculate_angle()
  245. {
  246.    acc_angle = ((float)accel_x - X_OFFSET) / mod;
  247.    gyro = -((float)gyro_rate - GYRO_OFFSET);
  248.  
  249.    state_update();
  250.    kalman_update(acc_angle);
  251.    
  252.    //printf("%f,%f,%f,\n",acc_angle,gyro,angle);
  253. }
  254.  
  255.  
  256. void refresh_pid()
  257. {
  258.     PID.yT = angle;
  259.     PID.eT = PID.rT - PID.yT; //Calculo del error
  260.    
  261.     PID.iT = PID.eT + PID.iT0; //Calculo de la integral
  262.     PID.dT = PID.eT - PID.eT0; //Calculo de la derivada
  263.    
  264.     PID.uT = Kp * PID.eT + Ki * PID.iT + Kd * PID.dT; //Calculo de la señal de control
  265.    
  266.     //Evitamos que uT se sature
  267.     if(PID.uT > UT_MAX)
  268.         PID.uT = UT_MAX;
  269.     if(PID.uT < -UT_MAX)
  270.         PID.uT = -UT_MAX;
  271.    
  272.     PID.iT0 = PID.iT; //Actualizamos la integral
  273.     PID.eT0 = PID.eT; //Actualizamos el error
  274. }
  275.  
  276.  
  277.  
  278.  
  279. void set_motors()
  280. {
  281.    int dutyR=0, dutyL=0;
  282.    
  283.    if(pwm_R >= 0)
  284.    {
  285.       dutyR = (int)pwm_R;
  286.       output_high(MOTORR2);
  287.       output_low(MOTORR1);
  288.    }
  289.    else
  290.    {
  291.       dutyR = (int)(-pwm_R);
  292.       output_high(MOTORR1);
  293.       output_low(MOTORR2);
  294.    }
  295.  
  296.    if(pwm_L >= 0)
  297.    {
  298.       dutyL = (int)pwm_L;
  299.       output_high(MOTORL2);
  300.       output_low(MOTORL1);
  301.    }
  302.    else
  303.    {
  304.       dutyL = (int)(-pwm_L);
  305.       output_high(MOTORL1);
  306.       output_low(MOTORL2);
  307.    }
  308.    
  309.    set_pwm1_duty(dutyR);
  310.    set_pwm2_duty(dutyL);
  311. }
  312.  
  313.  
  314.  
  315. void state_update()   //Prediccion
  316. {
  317.   float Pdot[4];
  318.  
  319.   Pdot[0] =  - P[0][1] - P[1][0];
  320.   Pdot[1] = -P[1][1];
  321.   //Pdot[2] = -P[1][1];
  322.   //Pdot[3] = Q_gyro;
  323.  
  324.   gyro -= q_bias;
  325.   angle += gyro * dt ;
  326.  
  327.   P[0][0] += (Pdot[0] * dt) + (P[1][1]*dt*dt) + Q_angle;
  328.   P[0][1] += Pdot[1] * dt;
  329.   P[1][0] += Pdot[1] * dt;
  330.   P[1][1] += Q_gyro;
  331. }
  332.  
  333. void kalman_update( float angle_m )
  334. {
  335.   float K_0=0;
  336.   float K_1=0;
  337.  
  338.   K_0 = P[0][0] / (R_angle + P[0][0]);
  339.   K_1 = P[1][0] / (R_angle + P[0][0]);
  340.  
  341.   P[0][0] -= K_0 * P[0][0];
  342.   P[0][1] -= K_0 * P[0][1];
  343.   P[1][0] -= K_1 * P[0][0];
  344.   P[1][1] -= K_1 * P[0][1];
  345.  
  346.   angle += K_0 * (angle_m - angle);
  347.   q_bias += K_1 * (angle_m - angle);
  348. }
  349.  
  350.  
  351.  
  352. void write_float_eeprom(long int n, float data)
  353. {
  354.    int i;
  355.    for (i = 0; i < 4; i++)
  356.      write_eeprom(i + n, *(((int8*)&data + i))) ;
  357. }
  358.  
  359. float read_float_eeprom(long int n)
  360. {
  361.    int i;
  362.    float data;
  363.    for (i = 0; i < 4; i++)
  364.      *((int8*)&data + i) = read_eeprom(i + n);
  365.    return(data);
  366. }
  367.  

Código del mbed
Código: C
  1. #include "mbed.h"
  2. #include <math.h>
  3. #include <motordriver.h>
  4. #include "PID.h"
  5.  
  6. //constantes de linealidad
  7. #define GYRO_OFFSET 0.376
  8. #define X_OFFSET 0.55
  9. #define Y_OFFSET 0.51
  10. #define GYRO_GAIN 0.3
  11. #define X_GAIN 4.0
  12. #define Y_GAIN 4.0
  13.  
  14. #define Ts  0.01 //periodo de muestreo en s
  15.  
  16.  
  17. Serial cdc(USBTX,USBRX);
  18. AnalogIn acc_x(p15);
  19. AnalogIn acc_y(p16);
  20. AnalogIn gyro_rate(p17);
  21. //DigitalOut led(LED1);
  22.  
  23. Motor leftMotor(p25, p30, p29, 0); // pwm, fwd, rev, can brake
  24. Motor rightMotor(p26, p28, p27, 0); // pwm, fwd, rev, can brake
  25. PID controller(7, 0, 0, Ts); //Kc, Ti, Td, RATE
  26.  
  27.  
  28. int main()
  29. {
  30.     float x=0, y=0, gyro=0;
  31.     float angle=0, acc_angle=0;
  32.     float speed=0;
  33.    
  34.     controller.setInputLimits(-3.1, 3.1); //-pi , pi
  35.     controller.setOutputLimits(-1.0, 1.0);
  36.     controller.setBias(0.0);
  37.     controller.setMode(AUTO_MODE);
  38.     controller.setSetPoint(0);
  39.  
  40.     rightMotor.speed(0);
  41.     leftMotor.speed(0);
  42.    
  43.     while(1)
  44.     {
  45.             x = (acc_x - X_OFFSET) * X_GAIN;
  46.             y = (acc_y - Y_OFFSET) * Y_GAIN;
  47.             gyro = (gyro_rate - GYRO_OFFSET) * GYRO_GAIN;
  48.            
  49.             acc_angle = atan2(y,x);
  50.             angle = (0.9)*(angle + gyro) + (0.1)*(acc_angle);
  51.             //cdc.printf("%f,%f,%f,\n",acc_angle,gyro,angle); //graficamos
  52.            
  53.             controller.setProcessValue(angle);
  54.             speed = controller.compute();
  55.             rightMotor.speed(speed);
  56.             leftMotor.speed(speed);
  57.             //cdc.printf("%f    %f\n",angle,speed); //graficamos
  58.            
  59.             wait(Ts);
  60.     }
  61. }

El mbed se me quemo porq el PID estaba sobredimensionado, entonces las ruedas hicieron un cambio brusco de direccion y eso genero una tension inversa muy fuerte :( A pesar que los puentes H cuentan con unos transistores TIPs que tienen unos diodos de proteccion incluidos. Ademas ya tenia problemas graves de ruido en la alimentacion culpa de los motores. Por eso decidi poner alimentaciones distintas para la electronica y para los motores.
No te puedo contar la angustia cuando vi quemarse el mbed, por poco me largo a llorar... pero bueno, shit happens.
Saludos!!

"conozco dos cosas infinitas: el universo y la estupidez humana. Y no estoy muy seguro del primero." A.Einstein


 

anything