Informe de laboratorio N 5

Laboratorio 5 Microcontrolador (MCU): Control remoto brazo mecnico (Diciembre 2012)

Germn F. Crdenas y Christopher A. Flores, Ingeniera Civil Biomdica, DIE Profesor: Miguel E. Figueroa Ayudantes: Enrique I. Germany; Nicole A. Labra

Resumen Se implementar en el laboratorio el control de un brazo mecnico, mediante un exoesqueleto, va comunicacin inalmbrica. Potencimetros conectados en el exoesqueleto entregarn voltaje proporcional a la angulatura de la articulacin, que ser convertida digitalmente para su envo en grados a travs del mdulo XBEE a otro microcontrolador, cuyos motores servos sern modulados para cumplir con el movimiento angular solicitado. Palabras claves Atmega64, XBEE, PWM

- Desarrollar un sistema para medir y controlar el ngulo de diversas articulaciones de un brazo robtico.

III. COMPONENTES Y EQUIPOS - Microcontrolador Atmel ATmega 64 - Cable alimentacin microcontrolador - Protoboard - 1 Cable JTAG -2 Mdulos XBEE -1 Exoesqueleto (6 potencimetros) -1 Brazo robtico (6 motores servo) - 1 Source power - Cables -Alicates -Multmero -Ordenador -Software AVR Studio -Software AVR Programmer

I. INTRODUCCIN

n microcontrolador es un dispositivo programable. Posee una Unidad Central de Procesamiento (CPU), memoria y perifricos de entrada/salida. El MCU a utililizar en el laboratorio es el Atmel ATmega 64, que posee las siguientes caractersticas: Reloj de hasta 16 [MHz], 64 [Kb] de flash de programa, 2 [Kb] de EEPROM de datos, 4 [Kb] de RAM, registros generales (32) y especializados, entre otros, pudiendo ser programado en lenguaje C, assembly (bajo nivel) o Basic. Una interrupcin es un llamado a procedimiento que afecta el actual estado de trabajo del MCU para ejecutar una nueva funcin. En el laboratorio se utilizarn interrupciones peridicas por timmer, para todos los tiempos y para la generacin de ondas PWM. A continuacin se muestran los resultados obtenidos en el laboratorio.

IV. METODOLOGA -Simular programa en C en Proteus y Matlab -Conectar el cableado del exoesqueleto y el del brazo robtico segn corresponda: 6 cables de datos (ngulos y control de servos) y 2 de alimentacin (VCC y GND). -Cargar en MCU el programa -Encender el MCU y verificar funcionamiento

V. DESARROLLO A.1 Solucin propuesta

II. OBJETIVOS -Programar un MCU Atmel ATmega64 en lenguaje C -Familiarizarse con la comunicacin inalmbrica entre dos MCU

Se tiene un sistema exoesqueleto para el control de 6 movimientos: Abduccin horizontal del hombro, abduccin lateral del hombro, flexin y extensin del codo, pronacin y supinacin del antebrazo, giro de mueca y apertura (cierre) de una pinza. Este sistema posee 6 potencimetros que darn lugar a diferentes voltajes segn el ngulo en que se

Informe de laboratorio N 5 encuentre la articulacin, que ser controlada por uno de los integrantes del grupo de trabajo. Dichos voltajes sern digitalizados y convertidos a un valor angular, para ser enviados va comunicacin serial inalmbrica por un mdulo XBEE a un microcontrolador de un brazo robtico. Este segundo sistema modificar el ngulo de la articulacin por medio de 6 motores servo, mediante modulacin PWM. A continuacin se muestra la relacin del ancho de pulso con el movimiento a realizar por el servo, as como el intervalo digital (hexadecimal) de dichos ngulos: TABLA1: ANCHOS DEL PULSO Posicin Brazo Articulacin ngulo Movimiento derecho [ms] giro Abduccin 90 Frontal 2.2 horizontal Lateral 1.36 hombro Abduccin 90 Horizontal 1.52 lateral Vertical 0.960 hombro Codo 90 Extensin 0.600 Flexin 1.52 Pronacin/ 180 Pronacin 2.48 supinacin Supinacin 0.602 Mueca 120 60 palmar 0.880 60 dorsal 2.080 Pinza -Cerrado 0.920 Abierto 1.241
Unidades de medida utilziadas: ms = milisegundo

El mdulo XBEE permite la comunicacin inalmbrica entre dispositivos MCU, con distancias que van desde los 100 [m] hasta los 1.6 [km] para el caso de XBEE pro, con un bajo consumo energtico.

Brazo izquierdo [ms] 1.280 2.160 1.52 0.961 0.600 1.52 0.600 2.48 0.880 2.080 0.920 1.241
Fig.1 Mdulo XBEE

A continuacin se muestra un diagrama de funcionamiento general del sistema a implementar:

Exoesqueleto

Brazo robtico

Potencimetros

Motores servos

TABLA 2: VOLTAJE (CONVERSIN ANLOGO/DIGITAL) Posicin Exoesqueleto Exoesqueleto derecho izquierdo Abduccin Frontal 0x17 0x26 horizontal Lateral 0x82 0x90 hombro Abduccin Horizontal 0xB8 0x1D lateral Vertical 0xFF 0x82 hombro Codo Extensin 0x87 0x1D Flexin 0xE9 0x82 Pronacin/ Pronacin 0x00 0x00 supinacin Supinacin 0xFF 0xFF Mueca 60 palmar 0x57 0x60 60 dorsal 0xBE 0xC8 Pinza Cerrado 0x7D 0x78 Abierto 0x89 0x8F

MCU 1 (XBEE)
Fig.2 Funcionamiento XBEE

MCU 1 (XBEE)

Se configur el USART 0 del MCU del exoesqueleto para el envo de el nmero de la articulacin, comparando el canal del conversor que est operando (ADMUX). El ngulo se obtiene segn la tabla 2, donde se tiene el intervalo de funcionamiento para cada ngulo, y se procede como sigue:

(1)

Donde, voltaje mnimo <conversin< voltaje mximo y ngulo corresponde al valor mximo que puede girar la articulacin. Por su parte, la modulacin PWM, una vez recibido el ngulo desde el exoesqueleto se obtiene como sigue, utilizando la tabla 2:

Informe de laboratorio N 5 //Lopp infinito } } Donde, anglemx es el valor mximo que puede girar la articulacin y tanto PWMX como PWMN corresponden a los valores extremos de modulacin (ms). Cabe mencionar que se utilizaron 2 timer para el control de los motores servo: timer 1 y timer 3, ambos de 16 bits A.2 Cdigo Cdigo 1: Exoesqueleto //CDIGO PRIMER MICRO (EXOESQUELETO, BRAZO DERECHO): VOLTAJE POTENCIOMETROS (NGULO Y ARTICULACION) -> CONVERSION A/D //LIBRERAS #include <avr/io.h> #include <avr/interrupt.h> //DEFINICIONES #define VOLTAJE1_MIN 23 //0x17 #define VOLTAJE1_MAX 130 //0x82 #define VOLTAJE2_MIN 184 //0xb8 #define VOLTAJE2_MAX 255 //0xff #define VOLTAJE3_MIN 135 //0x87 #define VOLTAJE3_MAX 233 //0xe9 #define VOLTAJE4_MIN 0 //0x00 #define VOLTAJE4_MAX 255 //0xff #define VOLTAJE5_MIN 87 //0x57 #define VOLTAJE5_MAX 190 //0xbe #define VOLTAJE6_MIN 125//0x7d #define VOLTAJE6_MAX 137 //0x89 //VARIABLES GLOBALES uint8_t cont_conv = 0; uint8_t conversion = 0; uint8_t angle = 0; //INICIALIZACIN FUNCIONES void init_puertos(void); void init_USART0 (void); void init_conversor(void); void init_timer0(void); void convierte(void); void out_usart0 (uint8_t articulacion, uint8_t angulo); int main(void) { init_puertos(); //Iniciliaza puertos init_USART0(); //Iniciliaza USART0 init_conversor(); //Iniciliaza conversor init_timer0(); //Iniciliza timer 0 sei(); //Habilita interrupciones while(1) { void init_puertos(void) { DDRF = 0x00; //Inicializa entrada conversor }

(2)

void init_USART0 (void) { UBRR1L = 25; // Baud rate = 19200 UCSR1A = 0; UCSR1B = 0b00001000; // Habilitar transmision. UCSR1C = 0b00000110; // Operacin asncrona, paridad sin, 1 stop bit, dato 8 bits } void init_conversor(void) { ADCSRB = 0x00; //Inicializa conversor } void init_timer0(void) { TCCR0 = 0b00000100; // CS02:1 = 100 (f/64)--> 8us/tic, periodo 2.048ms (125ns x 64 x 256) OCR0 = 125; //(125ns x 64 x 125)=1 ms TIMSK = 0b00000010; // HABILITADAS INTERRUPCIONES POR COMPARACION CON OCR0 } void convierte(void) { if(cont_conv==1) { ADMUX = 0b01100000; //Canal 0 ADCSRA = 0b11011110; } if(cont_conv==2) { ADMUX = 0b01100001; //Canal 1 ADCSRA = 0b11011110; } if(cont_conv==3) { ADMUX = 0b01100010; //Canal 2 ADCSRA = 0b11011110; } if(cont_conv==4) { ADMUX = 0b01100011; //Canal 3 ADCSRA = 0b11011110; } if(cont_conv==5) { ADMUX = 0b01100100; //Canal 4

Informe de laboratorio N 5 ADCSRA = 0b11011110; } if(cont_conv==6) { ADMUX = 0b01100101; //Canal 5 ADCSRA = 0b11011110; cont_conv = 0; } } void out_usart0 (uint8_t articulacion, uint8_t angulo) //Recibe Nnmero de articulacin, de acuerdo a la articulacin (ADMUX) y el ngulo a enviar { UDR0 = articulacion; //Enva primer dato while(!( UCSR0A & (1<<UDRE0))) //Espera a que termine de enviar primer dato UDR0 = angulo; //Enva segundo dato } ISR(TIMER0_COMP_vect) //Interrupcin timer 0 cada 1 [ms] { static uint8_t contador = 0; contador++; if (contador==10/6) { cont_conv++; convierte(); //Llama a funcin convertir, de acuerdo al ADMUX } } ISR(ADC_vect) //Interrupcin fin de conversin { conversion=ADCH; //Conversion a 8 bits //Se restringen los valores hexadecimales para cada canal. De acuerdo al ADMUX, se selecciona la articulacin y se calcula el ngulo if(ADMUX==0b01100000) //Hombro abduccin horizontal { if(conversion>VOLTAJE1_MAX) conversion=VOLTAJE1_MAX; if(conversion<VOLTAJE1_MIN) conversion=VOLTAJE1_MIN; angle = ((conversionVOLTAJE1_MIN)/(VOLTAJE1_MAXVOLTAJE1_MIN))*90; out_usart0(1,angle); } if(ADMUX==0b01100001)//Hombro abduccin lateral { if(conversion>VOLTAJE2_MAX) conversion = VOLTAJE2_MAX; if(conversion<VOLTAJE2_MIN) conversion=VOLTAJE2_MIN; angle = ((conversionVOLTAJE2_MIN)/(VOLTAJE2_MAXVOLTAJE2_MIN))*90; out_usart0(2,angle); } if(ADMUX==0b01100010)//Codo { if(conversion>VOLTAJE3_MAX) conversion=VOLTAJE3_MAX; if(conversion<VOLTAJE3_MIN) conversion=VOLTAJE3_MIN; angle = ((conversionVOLTAJE3_MIN)/(VOLTAJE3_MAXVOLTAJE3_MIN))*90; out_usart0(3,angle); } if(ADMUX==0b01100011)//Antebrazo (supinacin/pronacin) { angle = conversion/(VOLTAJE4_MAXVOLTAJE4_MIN)*180; out_usart0(4, angle); //Supinacin = 0/Pronacin = 180 } if(ADMUX==0b01100100);//Mueca { if(conversion>VOLTAJE5_MAX) conversion=VOLTAJE5_MAX; if(conversion<VOLTAJE5_MIN) conversion=VOLTAJE5_MIN; angle = ((conversionVOLTAJE5_MIN)/(VOLTAJE5_MAXVOLTAJE5_MIN))*120; out_usart0(5,angle); } if(ADMUX==0b01100110)//Pinza { if(conversion>VOLTAJE6_MAX) conversion=VOLTAJE6_MAX; if(conversion<VOLTAJE6_MIN) conversion=VOLTAJE6_MIN; angle = (conversionVOLTAJE6_MIN)/(VOLTAJE6_MAX-VOLTAJE6_MIN); out_usart0(6,angle); //0 = cerrado / 1 = abierto } }

Cdigo 2: Brazo robtico //LIBRERAS #include <avr/io.h>

Informe de laboratorio N 5 #include <avr/interrupt.h> #define TOP 20000 #define PW_MIN1 1360 #define PW_MAX1 2200 #define PW_MIN2 960 #define PW_MAX2 1520 #define PW_MIN3 600 #define PW_MAX3 1520 #define PW_MIN4 602 #define PW_MAX4 2480 #define PW_MIN5 880 #define PW_MAX5 2080 #define PW_MIN6 920 #define PW_MAX6 1241 //INICIALIZACIN FUNCIONES void init_USART0 (void); void init_timers(void); //VARIABLES GLOBALES uint8_t contador = 0; uint32_t angulo1, angulo2, angulo3, angulo4, angulo5, angulo6; int main(void) { init_timers(); //Inicializacin timer 0, 1 y 3 init_USART0(); //Inicilizacin USART 0 sei(); //Habilita interrupciones while(1) { //Loop infinito } } void init_USART0(void) { UBRR1L = 25; // baud rate = 19200 UCSR1A = 0; UCSR1B = 0b10010000; // habilitar recepcion y habilitar interrupcion de recepcion UCSR1C = 0b00000110; // operacin asncrona, paridad sin, 1 stop bit, dato 8 bits } void init_timers(void) { //Timer0 TCCR0 = 0b00000100; // CS02:1 = 100 (f/64)--> 8us/tic, periodo 2.048ms (125ns x 64 x 256) OCR0 = 125; //(125ns x 64 x 125)=1 ms TIMSK = 0b00000010; // HABILITADAS INTERRUPCIONES POR COMPARACION CON OCR0 //Timer1 DDRB |= (_BV(5) | _BV(6) | _BV(7)); // OC1A, OC1B, OC1C (PB5, PB6, PB7) salidas OCR1A = PW_MIN1; OCR1B = PW_MIN2; OCR1C = PW_MIN3; ICR1 = TOP; TCCR1A = 0b10101010; TCCR1B = 0b00011010; TCCR1C = 0; //Timer3 DDRE |= (_BV(3) | _BV(4) | _BV(5)); // OC3A, OC3B, OC3C (PE3, PE3, PE5) salidas OCR3A = PW_MIN4; OCR3B = PW_MIN5; OCR3C = PW_MIN6; ICR3 = TOP; TCCR3A = 0b10101010; TCCR3A = 0b00011010; TCCR3C = 0; } ISR(USART1_RX_vect) { static uint8_t movimiento, articulacion; uint8_t dato; //Se reciben los datos enviados por MCU de exoesqueleto para el clculo de la modulacin PWM de la seal dato = UDR0; //Recibe dato enviado por exoesqueleto contador++; if(contador==1) //Recibe nmero de articulacin articulacion = dato; if(contador==2) //Recibe el ngulo movimiento = dato; if(contador==2 && articulacion ==1) //Abduccin horizontal hombro { angulo1 = PW_MIN1 + (uint32_t)((PW_MAX1PW_MIN1)*movimiento/90); OCR1A = angulo1; contador = 0; } if(contador==2 && articulacion ==2) //Abduccin lateral hombro { angulo2 = PW_MIN2 + (uint32_t)((PW_MAX2PW_MIN2)*movimiento/90); OCR1B = angulo2; contador = 0; } if(contador==2 && articulacion ==3) //Codo {

Informe de laboratorio N 5 angulo3 = PW_MIN3 + (uint32_t)((PW_MAX3PW_MIN3)*movimiento/90); OCR1C = angulo3; contador = 0; } if(contador==2 && articulacion ==4) //Pronacin, supinacin { angulo4 = PW_MIN4 + (uint32_t)((PW_MAX4PW_MIN4)*movimiento/180); OCR3A = angulo4; contador = 0; } if(contador==2 && articulacion ==5) //Mueca { angulo5 = PW_MIN5 + (uint32_t)((PW_MAX5PW_MIN5)*movimiento/120); OCR3B = angulo5; contador = 0; } if(contador==2 && articulacion ==6) //Pinza { angulo6 = PW_MIN6 + (uint32_t)((PW_MAX6PW_MIN6)*movimiento); OCR3B = angulo6; contador = 0; } } void init_USART0 (void) { UBRR1L = 25; // Baud rate = 19200 UCSR1A = 0; UCSR1B = 0b00001000; // Habilitar transmision. UCSR1C = 0b00000110; // Operacin asncrona, paridad sin, 1 stop bit, dato 8 bits } void out_usart0 (uint8_t articulacion, uint8_t angulo) { UDR0 = articulacion; while(!( UCSR0A & (1<<UDRE0))) UDR0 = angulo; }

void init_timer0(void) { TCCR0 = 0b00000100; // CS02:1 = 100 (f/64)--> 8us/tic, periodo 2.048ms (125ns x 64 x 256) OCR0 = 125; //(125ns x 64 x 125)=1 ms TIMSK = 0b00000010; // HABILITADAS INTERRUPCIONES POR COMPARACION CON OCR0 } ISR(TIMER0_COMP_vect) { static uint8_t dato1 = 1; static uint8_t dato2 = 2; static uint16_t contador = 0; contador++; if (contador==1000) { out_usart0(dato1,dato2); dato1++; dato2+=2; contador=0; } }

} A.3 Cdigos de prueba Cdigo de prueba: MCU 1: Enva dos datos por comunicacin serial inalmbrica. Adems incrementa en 1 el primer dato y el segundo dato en 2, todo lo anterior cada 1 segundo. Utiliza la misma funcin de envio de datos que se utilizar en el cdigo definitivo. //LIBRERAS #include <avr/io.h> #include <avr/interrupt.h> int main(void) { init_USART0(); init_timer0(); sei(); while(1) { }

Cdigo de prueba: MCU 2: Recibe los dos dato por comunicacin serial inalmbrica y lo despliega en un diplay LCD, va comunicacin SPI.

//LIBRERAS #include <avr/io.h> #include <avr/interrupt.h> void string_SPI(char *string); void init_SPI(void); void init_USART0 (void); char *clear = "\x1B[j";

Informe de laboratorio N 5 char *fila2 = "\x1B[1;0H"; char display[17]; char display2[17]; } int main(void) { init_USART0(); sei(); while(1) { } } void init_USART0 (void) { UBRR1L = 25; // Baud rate = 19200 UCSR1A = 0; UCSR1B = 0b00001000; // Habilitar transmision. UCSR1C = 0b00000110; // Operacin asncrona, paridad sin, 1 stop bit, dato 8 bits } void out_usart0 (uint8_t articulacion, uint8_t angulo) { UDR0 = articulacion; while(!( UCSR0A & (1<<UDRE0))) UDR0 = angulo; } void init_SPI(void) { // SCLK, SS y MOSI salida, MISO entrada DDRB |= _BV(1) | _BV(0) | _BV(2); // Interrupciones no habilitadas, SPI habilitado, MSB primero, MCU maestro // SCK bajo ocioso, dato en primer canto, divisor de reloj por 128 SPCR = 0b01010001; // Velocidad doble deshabilitada SPSR = 0; // LLevar SS a 1 PORTB |= _BV(0); // deshabilita SS } ////////////////////////////////////////////////// //USO SPI LCD void string_SPI(char *string) { PORTB &= ~_BV(0); // habilita SS while (*string != 0) { SPDR = *string; string++; while ( (SPSR & _BV(7)) == 0 ) ISR(USART0_RX_vect) { static nbyte=0; static uint8_t dato1; static uint8_t dato2; if(nbyte==0) dato1=UDR0; else dato2=UDR0; nbyte=1; {} // espera SPIF } PORTB |= _BV(0); // deshabilita SS

sprintf(display, "dato1 = %d ", dato1); //Despliegue de angulo sprintf(display2, "dato2 = %d ", dato2); string_SPI(clear); string_SPI(display); string_SPI(fila2); string_SPI(display2); { } }

Cdigo de prueba: MCU con potencimetro: Recibe voltaje de potencimetro por medio del conversor anlogo-digital, convierte el dato recibido en ngulo en grados mediante la ecuacin (1), cuyo valor es enviado a travs de comunicacin serial, de la misma forma que en el Cdigo de prueba: MCU 1. //LIBRERAS #include <avr/io.h> #include <avr/interrupt.h> void init_adc(void); void triggerADC(void); void init_USART0 (void); void out_usart0 (uint8_t articulacion, uint8_t angulo); void init_timer0(void); uint8_t dato1; int main(void) { init_USART0();

Informe de laboratorio N 5 init_timer0(); init_adc(); sei(); while(1) { } } void init_adc(void) { // Bit 0 de puerta F es entrada (entrada anloga ADC0) DDRF = 0x00; ADCSRB = 0x00; // ADTS2:ADTS0=000: Conversor en modo free running, no afecta en este caso porque no hay auto-trigger } void triggerADC(void) { ADMUX = 0b01100000; // REFS1:REFS0=01: ref=AVCC, ADLAR=1: justificado izquierda, MUX4:MUX0=00000: entrada=ADC0 (bit 0 puerta F) ADCSRA = 0b11011111; // ADEN=1; ADC habilitado, ADSC=1: iniciar conversin, ADATE=0: no auto-trigger, ADIE=1: interrupciones habilitadas, ADPS2:ADPS0=110: fclock/64: conversin en 104us } } { static uint8_t contador_adc=0; contador_adc++; if (contador_adc==200) { triggerADC(); contador_adc=0; }

ISR(ADC_vect) { static uint8_t conversion=0; static uint8_t angle=0; conversion=ADCH; angle = (conversion/255)*180; //0x00 = 0/ 0xff = 255 out_usart0(angle, 1); //Supinacin = 0/Pronacin = 180 }

Cdigo de prueba: MCU con servo: Recibe articulacin y ngulo, por medio de comunicacin serial, adems el dato de ngulo recibido es convertido en la ecuacin (2) para la modulacin del servo.

//LIBRERAS #include <avr/io.h> #include <avr/interrupt.h> #define TOP 20000; void string_SPI(char *string); void init_SPI(void); void init_USART0 (void); char *clear = "\x1B[j"; char *fila2 = "\x1B[1;0H"; char display[17]; char display2[17]; uint32_t angulo; int main(void) { init_USART0(); init_timer1(); init_SPI(); sei(); while(1) { } }

void init_USART0 (void) { UBRR1L = 25; // Baud rate = 19200 UCSR1A = 0; UCSR1B = 0b00001000; // Habilitar transmision. UCSR1C = 0b00000110; // Operacin asncrona, paridad sin, 1 stop bit, dato 8 bits } void out_usart0 (uint8_t articulacion, uint8_t angulo) { UDR0 = articulacion; while(!( UCSR0A & (1<<UDRE0))) UDR0 = angulo; } void init_timer0(void) { TCCR0 = 0b00000100; // CS02:1 = 100 (f/64)--> 8us/tic, periodo 2.048ms (125ns x 64 x 256) OCR0 = 125; //(125ns x 64 x 125)=1 ms TIMSK = 0b00000010; // HABILITADAS INTERRUPCIONES POR COMPARACION CON OCR0 } ISR(TIMER0_COMP_vect)

Informe de laboratorio N 5 void init_USART0 (void) { UBRR1L = 25; // Baud rate = 19200 UCSR1A = 0; UCSR1B = 0b00001000; // Habilitar transmision. UCSR1C = 0b00000110; // Operacin asncrona, paridad sin, 1 stop bit, dato 8 bits } void out_usart0 (uint8_t articulacion, uint8_t angulo) { UDR0 = articulacion; while(!( UCSR0A & (1<<UDRE0))) UDR0 = angulo; } void init_SPI(void) { // SCLK, SS y MOSI salida, MISO entrada DDRB |= _BV(1) | _BV(0) | _BV(2); // Interrupciones no habilitadas, SPI habilitado, MSB primero, MCU maestro // SCK bajo ocioso, dato en primer canto, divisor de reloj por 128 SPCR = 0b01010001; // Velocidad doble deshabilitada SPSR = 0; // LLevar SS a 1 PORTB |= _BV(0); // deshabilita SS } //USO SPI LCD void string_SPI(char *string) { PORTB &= ~_BV(0); // habilita SS while (*string != 0) { SPDR = *string; string++; while ( (SPSR & _BV(7)) == 0 ) {} // espera SPIF } PORTB |= _BV(0); // deshabilita SS } void init_timer1(void) { //Timer1 DDRB |= _BV(5) ; // OC1A, (PB5) salida OCR1A = 0; ICR1 = TOP; TCCR1A = 0b10101010; TCCR1B = 0b00011010; TCCR1C = 0; } ISR(USART0_RX_vect) { static nbyte=0; static uint8_t dato1; static uint8_t dato2; static uint8_t movimiento; if(nbyte==0) dato1=UDR0; else dato2=UDR0; nbyte=1; movimiento = dato1; angulo = 600 + (1520-600)*movimiento/90; OCR1A = angulo;

sprintf(display, "angulo = %d ", angulo); //Despliegue de angulo sprintf(display2, "dato2 = %d ", dato2); string_SPI(clear); string_SPI(display); string_SPI(fila2); string_SPI(display2); } Cdigo prueba: Matlab, ofrece en consola los puertos disponibles para conectar, una vez elejido el puerto permite enviar un dato en angulo desde 0 a 180, el cual simula el envo del dato por el MCU 1 correspondiente al exoesqueleto. Dicho dato de angulo ser recibido por el MCU2 encargado de controlar el brazo. Este cdigo se utilizara con el Cdigo de prueba: MCU con servo. clear all close all clc %% Configuracin serialPorts = instrhwinfo('serial'); portlist = (serialPorts.SerialPorts); nport= length(portlist); j=1; for i=1:nport if (isempty(portlist{i})) i=i+1; else opcion(j)=i; fprintf('El Puerto "%s" Esta Disponible , su Opcion es %d\n', portlist{i},j); j=j+1; end end n = input('\nIngrese la Opcion del Puerto que desee seleccionar:'); opcionmax = length(opcion);

Informe de laboratorio N 5 y=1; while(y) if (n>0 && n<=opcionmax) puerto = opcion(n); y=0; else disp('Opcion Invalida'); n = input('\nIngrese la Opcion del Puerto que desee seleccionar:'); y=1; end end % Redondear y convertir nmero a entero de 8 bits sin signo (1 byte) angulo = uint8( angulo ); % Enviar fprintf( ' Enviando %d... ', angulo ); fwrite( PS, angulo, 'uint8' ); fprintf( 'OK\n' ); dato2=1; pause(0.2); fwrite( PS, dato2, 'uint8' )

10

end com_port = portlist{puerto}; %% si no funciona bien seleccionar puerto manualmente, cambiado com_port por el puerto deseado % ejemplo com_port = 'COM1'; %% Abrir puerto % Crear objeto PS = serial( com_port ); % Configurar set( PS, 'Baudrate', 19200 ); % Velocidad set( PS, 'DataBits', 8 ); % Bits de datos set( PS, 'Parity', 'none' ); % Paridad set( PS, 'StopBits', 1 ); % Bits de parada set( PS, 'FlowControl', 'none' ); % Control de flujo % Tratar de abrir puerto, o salir de la rutina try fopen( PS ); catch err msgbox( {['Con el error "' err.identifier '" y el mensaje:'] err.message}, 'Error al abrir el puerto') delete( PS ); return; end %% Enviar y recibir datos x=1; while( x ) y=1; % Preguntar que valor enviar angulo = input( 'Ingrese un angulo (0 a 180) [Vacio + Enter para Salir]: ' ); % Condicin de salida del loop: Valor vacio, mayor a 255 o menor a 0 if( isempty(angulo) || (angulo > 180) || (angulo < 0) ) break; end %% Cerrar puerto y borrar objeto fclose( PS ); delete( PS );

A.4 Implementacin de circuito El brazo robtico dispone de ocho cables, dos de los cuales corresponden a la alimentacin del mismo (VCC y GND), que se deben conectar a una fuente externa, regulada a 4.8 [v], cuyo GND debe ser comn al MCU. Los otros seis, corresponden al control de los motores servo. Por su parte, el exoesqueleto, posee la misma cantidad de cables, dos de los cuales corresponden a la alimentacin, obtenida del MCU y los restantes a los voltajes de los potencimetros. Para el caso de los mdulos XBEE se tienen 4 conexiones: Pin1 (VCC), Pin 10 (GND), Pin 2 (DATA OUT) y Pin 3 (DTA IN), El modulo XBEE se conecta en los pines 0, 1 ,2 y 3 del puerto E, fsicamente en el micro los pines JC1, JC2, JC3 y JC4.
Brazo robtico Exoesqueleto

Fig.3 Conexin ambos MCU

Informe de laboratorio N 5

11

Fig.4 Conexin XBEE

VI. CONCLUSIN Los microcontroladores (MCU) son de gran utilidad a la hora de implementar circuitos digitales o analgicos, previo uso de conversores A/D. Su fundamento se basa en el estudio del lenguaje a utilizar, sea ste el C, assembly, Basic, entre otros. La diferencia radica en la cercana (nivel) con el microcontrolador, lo que se traducir en el grado de control. En el caso del lenguaje Assembly se tiene un mayor control bit a bit de los registros a utilizar, lo que logra un aprovechamiento eficiente de los recursos del MCU. Sin embargo, el lenguaje C, permite una mayor fluidez de cdigo, ya que muchas funciones ya estn implementadas (timmers). VII. REFERENCIAS [1] Laboratorio de microcontroladores: Gua de laboratorio N 5, Universidad de Concepcin, Departamento de Ingeniera Elctrica, 2011, pp 1-3