informe5

Informe de laboratorio Nº 5

1

Laboratorio 5 Microcontrolador Microcontrolador (MCU): Control remoto brazo mecánico (Diciembre 2012) Germán F. Cárdenas y Christopher A. Flores,  Ingeniería Civil Biomédica, DIE  Profesor: Miguel E. Figueroa Ayudantes: Enrique I. Germany; Nicole A. Labra

Se implementará en el laboratorio el control de un brazo mecánico, mediante un exoesqueleto, vía comunicación inalámbrica. Potenciómetros conectados en el exoesqueleto entregarán voltaje proporcional a la angulatura de la articulación, que será convertida digitalmente para su envío en grados a través del módulo XBEE a otro microcontrolador, cuyos motores servos serán modulados para cumplir con el movimiento angular solicitado. Resumen   — 

Palabr as claves  claves   — 

Atmega64, XBEE, PWM

I. INTRODUCCIÓN

U

n microcontrolador es un dispositivo programable. Posee una Unidad Central de Procesamiento (CPU), memoria y periféricos de entrada/salida. El MCU a utililizar  en el laboratorio es el Atmel ATmega 64, que posee las siguientes características: Reloj de hasta 16 [MHz], 64 [Kb] de flash de programa, program a, 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 interrupción es un llamado a procedimiento que afecta el actual estado de trabajo del MCU para ejecutar una nueva función. En el laboratorio se utilizarán interrupciones  periódicas por timmer, para todos los tiempos y para la generación de ondas PWM. A continuación se muestran los resultados obtenidos en el laboratorio.

- Desarrollar un sistema para medir y controlar el ángulo de diversas articulaciones de un brazo robótico. III. COMPONENTES Y EQUIPOS - Microcontrolador Atmel ATmega 64 - Cable alimentación microcontrolador  - Protoboard - 1 Cable JTAG -2 Módulos XBEE -1 Exoesqueleto (6 potenciómetros) -1 Brazo robótico (6 motores servo) - 1 Source power  - Cables -Alicates -Multímero -Ordenador  -Software AVR Studio -Software -Software AVR Programmer  IV. METODOLOGÍA -Simular programa en C en Proteus y Matlab -Conectar el cableado del exoesqueleto y el del brazo robótico según corresponda: 6 cables de datos (ángulos y control de servos) y 2 de alimentación (VCC y GND). -Cargar en MCU el programa -Encender el MCU y verificar verificar funcionamiento V. DESARROLLO  A.1 Solución propuesta

II. OBJETIVOS -Programar un MCU Atmel ATmega64 en lenguaje C -Familiarizarse con la comunicación inalámbrica entre dos MCU

Se tiene un sistema exoesqueleto para el control de 6 movimientos: Abducción horizontal del hombro, abducción lateral del hombro, flexión y extensión del codo, pronación y supinación del antebrazo, giro de muñeca y apertura (cierre) de una pinza. Este sistema posee 6 potenciómetros que darán lugar a diferentes voltajes según el ángulo en que se

Informe de laboratorio Nº 5

2

encuentre la articulación, que será controlada por uno de los integrantes del grupo de trabajo. Dichos voltajes serán digitalizados y convertidos a un valor angular, para ser  enviados vía comunicación serial inalámbrica por un módulo XBEE a un microcontrolador de un brazo robótico. Este El módulo XBEE permite la comunicación inalámbrica segundo sistema modificará el ángulo de la articulación por  entre dispositivos MCU, con distancias que van desde los medio de 6 motores servo, mediante modulación PWM. A 100 [m] hasta los 1.6 [km] para el caso de XBEE pro, con un continuación se muestra la relación del ancho de pulso con el  bajo consumo energético. movimiento a realizar por el servo, así como el intervalo digital (hexadecimal) de dichos ángulos: TABLA1: ANCHOS DEL PULSO Posición Brazo derecho Articulación Ángulo Movimiento [ms] giro Abducción 90° Frontal 2.2 horizontal Lateral 1.36 hombro Abducción 90° Horizontal 1.52 lateral Vertical 0.960 hombro Codo 90° Extensión 0.600 Flexión 1.52 Pronación/ 180° Pronación 2.48 supinación Supinación 0.602 Muñeca 120° 60° palmar 0.880 60° dorsal 2.080 Pinza -Cerrado 0.920 Abierto 1.241

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 Módulo XBEE 

A continuación se muestra un diagrama de funcionamiento general del sistema a implementar:

Unidades de medida utilziadas: ms = milisegundo

TABLA 2: VOLTAJE (CONVERSIÓN ANÁLOGO/DIGITAL) Posición Exoesqueleto Exoesqueleto derecho izquierdo Abducción Frontal 0x17 0x26 horizontal Lateral 0x82 0x90 hombro Abducción Horizontal 0xB8 0x1D lateral Vertical 0xFF 0x82 hombro Codo Extensión 0x87 0x1D Flexión 0xE9 0x82 Pronación/ Pronación 0x00 0x00 supinación Supinación 0xFF 0xFF Muñeca 60° palmar 0x57 0x60 60° dorsal 0xBE 0xC8 Pinza Cerrado 0x7D 0x78 Abierto 0x89 0x8F

Exoesqueleto

Brazo robótico

Potenciómetros

Motores servos

MCU 1 (XBEE)

MCU 1 (XBEE)  Fig.2 Funcionamiento XBEE 

Se configuró el USART 0 del MCU del exoesqueleto para el envío de el número de la articulación, comparando el canal del conversor que está operando (ADMUX). El ángulo se obtiene según la tabla 2, donde se tiene el intervalo de funcionamiento para cada ángulo, y se procede como sigue:

(1) Donde, voltaje mínimo
Informe de laboratorio Nº 5

3

//Lopp infinito }

(2) } Donde, anglemáx es el valor máximo que puede girar la articulación y tanto PWMÁX como PWMÍN corresponden a los valores extremos de modulación (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 Código Código 1: Exoesqueleto //CÓDIGO PRIMER MICRO (EXOESQUELETO, BRAZO DERECHO): VOLTAJE POTENCIOMETROS (ÁNGULO Y ARTICULACION) -> CONVERSION A/D //LIBRERÍAS #include #include //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; //INICIALIZACIÓN 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  } void init_USART0 (void) { UBRR1L = 25; // Baud rate = 19200 UCSR1A = 0; UCSR1B = 0b00001000; // Habilitar transmision. UCSR1C = 0b00000110; // Operación asíncrona, 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  Nnúmero de articulación, de acuerdo a la articulación (ADMUX) y el ángulo a enviar  { UDR0 = articulacion; //Envía primer dato while(!( UCSR0A & (1<VOLTAJE1_MAX) conversion=VOLTAJE1_MAX; if(conversionVOLTAJE2_MAX) conversion = VOLTAJE2_MAX;

if(conversionVOLTAJE3_MAX) conversion=VOLTAJE3_MAX; if(conversionVOLTAJE5_MAX) conversion=VOLTAJE5_MAX; if(conversionVOLTAJE6_MAX) conversion=VOLTAJE6_MAX; if(conversion

4

Informe de laboratorio Nº 5 #include #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 //INICIALIZACIÓN 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(); //Inicialización timer 0, 1 y 3 init_USART0(); //Inicilización USART 0 sei(); //Habilita interrupciones while(1) { //Loop infinito } }

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 cálculo de la modulación PWM de la señal dato = UDR0; //Recibe dato enviado por exoesqueleto contador++; if(contador==1) //Recibe número de articulación articulacion = dato; if(contador==2) //Recibe el ángulo movimiento = dato;

void init_USART0(void) { UBRR1L = 25; // baud rate = 19200 UCSR1A = 0; UCSR1B = 0b10010000; // habilitar recepcion y habilitar  interrupcion de recepcion UCSR1C = 0b00000110; // operación asÌncrona, paridad sin, 1 stop bit, dato 8 bits }

if(contador==2 && articulacion ==1) //Abducción horizontal hombro

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;

if(contador==2 && articulacion ==2) //Abducción lateral hombro { angulo2 = PW_MIN2 + (uint32_t)((PW_MAX2PW_MIN2)*movimiento/90); OCR1B = angulo2; contador = 0; }

{ angulo1 = PW_MIN1 + (uint32_t)((PW_MAX1PW_MIN1)*movimiento/90); OCR1A = angulo1; contador = 0; }

if(contador==2 && articulacion ==3) //Codo {

5

Informe de laboratorio Nº 5 angulo3 = PW_MIN3 + (uint32_t)((PW_MAX3PW_MIN3)*movimiento/90); OCR1C = angulo3; contador = 0; } if(contador==2 && articulacion ==4) //Pronación, supinación { angulo4 = PW_MIN4 + (uint32_t)((PW_MAX4PW_MIN4)*movimiento/180); OCR3A = angulo4; contador = 0; } if(contador==2 && articulacion ==5) //Muñeca { 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; } }  A.3 Códigos de prueba Código de prueba: MCU 1: Envía dos datos por comunicación serial inalámbrica. Además incrementa en 1 el primer dato y el segundo dato en 2, todo lo anterior cada 1 segundo. Utiliza la misma función de envio de datos que se utilizará en el código definitivo.

6

 } void init_USART0 (void) {  UBRR1L = 25; // Baud rate = 19200 UCSR1A = 0; UCSR1B = 0b00001000; // Habilitar transmision. UCSR1C = 0b00000110; // Operación asíncrona,  paridad sin, 1 stop bit, dato 8 bits  } void out_usart0 (uint8_t articulacion, uint8_t angulo) {  UDR0 = articulacion; while(!( UCSR0A & (1< 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;  }  }

 //LIBRERÍAS  #include #include

Código de prueba: MCU 2: Recibe los dos dato por  comunicación serial inalámbrica y lo despliega en un diplay LCD, vía comunicación SPI.

int main(void) {  init_USART0(); init_timer0();  sei();

 //LIBRERÍAS  #include #include

while(1) { 

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];

{}

7 // espera SPIF 

 }  PORTB |= _BV(0); // deshabilita SS   }

int main(void) {  init_USART0();  sei(); while(1) { 

 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;

 }  } void init_USART0 (void) {  UBRR1L = 25; // Baud rate = 19200 UCSR1A = 0; UCSR1B = 0b00001000; // Habilitar transmision. UCSR1C = 0b00000110; // Operación asíncrona,  paridad sin, 1 stop bit, dato 8 bits  } void out_usart0 (uint8_t articulacion, uint8_t angulo) {  UDR0 = articulacion; while(!( UCSR0A & (1<
 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); {   }  }

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 )

Código de prueba: MCU con potenciómetro: Recibe voltaje de  potenciómetro por medio del conversor análogo-digital, convierte el dato recibido en ángulo en grados mediante la ecuación (1), cuyo valor es enviado a través de comunicación serial, de la misma forma que en el Código de prueba: MCU 1.  //LIBRERÍAS  #include #include 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();

8

{   static uint8_t contador_adc=0; contador_adc++; if (contador_adc==200) {  triggerADC(); contador_adc=0;  }

 sei(); while(1) {   }  }

 }

void init_adc(void) {   // Bit 0 de puerta F es entrada (entrada análoga 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 conversión, ADATE=0: no auto-trigger,  ADIE=1: interrupciones habilitadas, ADPS2:ADPS0=110:  fclock/64: conversión en 104us  }

 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); //Supinación = 0°/Pronación = 180°  }

void init_USART0 (void) {  UBRR1L = 25; // Baud rate = 19200 UCSR1A = 0; UCSR1B = 0b00001000; // Habilitar transmision. UCSR1C = 0b00000110; // Operación asíncrona,  paridad sin, 1 stop bit, dato 8 bits  } void out_usart0 (uint8_t articulacion, uint8_t angulo) {  UDR0 = articulacion; while(!( UCSR0A & (1<
Código de prueba: MCU con servo: Recibe articulación y ángulo, por medio de comunicación serial, además el dato de ángulo recibido es convertido en la ecuación (2) para la modulación del servo.  //LIBRERÍAS  #include #include #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();

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  }

while(1) {   }  }

 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; // Operación asíncrona,  paridad sin, 1 stop bit, dato 8 bits  } void out_usart0 (uint8_t articulacion, uint8_t angulo) {  UDR0 = articulacion; while(!( UCSR0A & (1<
9

 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);  } Código 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 envío del dato por el MCU 1 correspondiente al exoesqueleto. Dicho dato de angulo será recibido por el MCU2 encargado de controlar el brazo. Este código se utilizara con el Código de prueba: MCU con servo. clear all  close all  clc %% Configuración  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 

com_port = portlist{puerto}; %% si no funciona bien seleccionar puerto manualmente, cambiado com_port por el puerto deseado % ejemplo com_port = 'COM1'; %% Abrir puerto

10

% Redondear y convertir número 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' )

end  %% Cerrar puerto y borrar objeto  fclose( PS ); delete( PS );  A.4 Implementación de circuito

% 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]: ' ); % Condición de salida del loop: Valor vacio, mayor a 255 o menor a 0 if( isempty(angulo) || (angulo > 180) || (angulo < 0) ) break; end 

El brazo robótico dispone de ocho cables, dos de los cuales corresponden a la alimentación del mismo (VCC y GND), que se deben conectar a una fuente externa, regulada a 4.8 [v], cuyo GND debe ser común 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 alimentación, obtenida del MCU y los restantes a los voltajes de los potenciómetros. Para el caso de los módulos 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, físicamente en el micro los pines JC1, JC2, JC3 y JC4. Brazo robótico Exoesqueleto

 Fig.3 Conexión ambos MCU 

Informe de laboratorio Nº 5

 Fig.4 Conexión XBEE 

VI. CONCLUSIÓN Los microcontroladores (MCU) son de gran utilidad a la hora de implementar circuitos digitales o analógicos, 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 cercanía (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 código, ya que muchas funciones ya están implementadas (timmers). VII. REFERENCIAS [1] Laboratorio de microcontroladores: Guía de laboratorio  N° 5, Universidad de Concepción, Departamento de Ingeniería Eléctrica, 2011, pp 1-3

11