Mbed – Introducción al lenguaje y su compilador Mbed es un lenguaje de programación para sistemas embebidos. Su principal ventaja es que puede compilarse en la nube, es decir desde Internet. Mbed se desarrolló pensando en el Internet de las Cosas. Además está enfocado a la programación de sistemas embebidos basados en arquitecturas ARM. Por ejemplo, existen más de 100 tarjetas de desarrollo que puedes elegir. Todas ellas con arquitectura ARM. El compilador que usa Mbed está en la” nube “. En otras palabras, se requiere de un explorador web como chrome, firefox o explorer para crear tus aplicaciones y programas. COMPILADOR DE MBED El compilador de Mbed funciona desde un explorador web. La primera vez que lo utilizamos, buscaba un hardware o tarjeta de desarrollo que pudiera ser utilizado tanto en Windows como en Linux. Entonces, cuando hicimos una pequeña investigación encontré a Mbed. Una de las cosas que más me llamo la atención fue que podía usarse desde internet. El usar el compilador Mbed desde internet es tanto una ventaja como en parte una desventaja. La principal ventaja es que a donde quiera que voy tengo mis programas y bibliotecas disponibles. Por el contrario, su desventaja es que se requiere una conexión a Internet. La herramienta es muy sencilla de utilizar. Además en cada programa que realizas siempre tienes acceso a las clases y objetos del lenguaje Mbed. Lo que no me gusta mucho es que la ayuda está en un formato de texto que no te permite copiar el texto a tu código. REGISTRO Y AGREGAR TARJETAS NUEVAS AL COMPILADOR MBED

PASO #1

Primero, tenemos que ingresar al siguiente enlace: https://os.mbed.com/account/login/ y posteriormente crear una cuenta. Mbed compilador registrar cuenta

PASO # 2 Después de registrar la cuenta y validarla con el correo electrónico, se procede a acceder al compilador, colocando el usuario y el login registrado.

PASO #3 Una vez ingresada a la cuenta, seleccionar el botón de “Compiler”.

PASO # 4 Si es la primera vez que usas el compilador, primero hay que agregar a una tarjeta de desarrollo. Puedes ver todas las tarjetas compatibles en el siguiente enlace: https://os.mbed.com/platforms/. Existen más de 100 modelos distintos. Te sugiero que busques aquella que se ajuste a tus necesidades. Dado que cada semestre cambio de tarjeta para mis clases de sistemas embebidos, siempre busco una opción que sea económica para los estudiantes. Por ejemplo, inicialmente había considerado la tarjeta KL25Z. Pero está no cuenta con pines hembra y estos se venden por separado. Mi segunda opción fue la NUCLEO-F401RE , está tiene pines compatibles con la KL25 y con Arduino (casi la misma disposición de pines) y además incluye tanto pines hembra como pines macho. Durante un semestre utilice esta tarjeta, pero después la cambie por la Nucleo L432LC . Debido a que no usaba en realidad todos los puertos de la F401RE y el precio era menor. Para agregar la tarjeta, se selecciona una opción en la parte superior derecha. Como en las siguientes figuras.

PASO # 5 Una vez que se seleccionó la tarjeta, en la ventana principal se selecciona la opción:” add to my Mbed compiler”. Agregar a mi compilador Mbed.

Paso # 6. Verificar que aparezca el mensaje que se agregó la tarjeta correctamente. Posteriormente, seleccionar la opción compilador. Esta vez, en la parte superior, cuando se agrega una tarjeta ya deberá aparecer la opción seleccionada.

CREAR UN PROYECTO EN EL IDE DE MBED. PASO # 1 – 2 Seleccionar la tarjeta de desarrollo a utilizar.

Paso # 3 Seleccionar la opción “new” y” new program” para crear un nuevo proyecto.

PASO # 4. Seleccionar una plantilla de inicio o un proyecto en blanco. ” Empty program ” – Proyecto en blanco. Dependiendo de la tarjeta que se haya seleccionado, aparecerán distintos programas de plantilla. Por ejemplo, un led blink. Si estas comenzando te recomiendo empezar con el programa blink. Ojo. Dependiendo de la tarjeta, si crees que no esté actualizada a la última versión del firmware, te recomiendo que debilites la casilla que dice: “update this program and libraries to lastest version”. Este semestre tuve la mala experiencia de que mis programas no funcionaban y era porque esta opción. Al parecer mi tarjeta que use no tenía el último firmware y esta opción entraba en conflicto.

Paso # 5 Agregar un nombre al proyecto y seleccionar OK.

PASO # 6 Abrir el código generado, seleccionando con un doble click a la siguiente opción.

RESUMÉN El lenguaje MBED y su compilador es una excelente herramienta para desarrollar aplicaciones con sistemas embebidos. El poder programar a bajo costo, microprocesadores de la arquitectura ARM nos permite tener una mayor capacidad de procesamiento que con los tradicionales microcontroladores de 8bits. Mbed es un sistema operativo, que atrevas de funciones muy sencillas, podemos desarrollar aplicaciones en un corto tiempo. Si a esto le agregamos que existen muchos fabricantes que han hecho compatibles sus tarjetas con Mbed, tenemos una gran diversidad de tarjetas de desarrollo. Mbed tiene una comunidad de más de 200 mil desarrolladores, ingenieros y hobbistas, que desarrollan las últimas aplicaciones tecnológicas en Mbed.

Proyecto Final de clase Sistemas Embebidos

como objetivo principal de proyecto final de semestre se requiere la construcción y el diseño de una araña Rebotica, la cual permita realizar movimientos hacia adelante, hacia atrás, hacia la izquierda y hacia la derecha , y con la introducción de un sensor de color pueda detectar un color y realizar una acción diferente con cada uno, ademas de que pueda tener interrupciones que permitan su detección al momento de ir caminando y ubicar un color, adicional mente se tiene que manejar la araña con un dispositivo joystick.

Plano de la araña

1. Estructura completa

2. Estructura

3. Parte 1

3. Parte 2

3. Parte 3

3. Parte 4

3. Parte 5

4. servos

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

Código de Programación

Movimiento de las extremidades :

Empezamos con la asignación de los terminales de la salida Digital Out PWM, para cada uno de los servos.

PwmOut myServo1(PB_10); PwmOut myServo2(PA_8); PwmOut myServo3(PA_9); PwmOut myServo4(PC_7); PwmOut myServo5(PB_6); PwmOut myServo6(PA_7); PwmOut myServo7(PA_6); PwmOut myServo8(PA_5); Para crear la función asignamos cada una en este caso para mover y adicionamos el del sensor de color que mas adelante explicaremos

1. ifndef MAIN_H
2. define MAIN_H
3. include "mover.h"
4. define DEBUG 1

void debug_m(char *s , ... ); uint32_t read_command(); void init_serial(); void moving(); void moverconjunto(); void movercolor(); void adelante(); void atras(); void derecha(); void izquierda();

1. endif En el main .cpp Inicializamos y definimos el contenido y la función de cada uno.
2. include "mbed.h" inicio programa.
3. include "main.h"
4. include "mover.h"

DigitalOut led (PB_4); Serial command(USBTX, USBRX); cremos una clase de comunicación por USB llamada "command"

char init_c; int read_cc; uint32_t posicion; uint32_t nmotores; int endc; int main(){ init_servo(); llamamos a ejecutar la función "init_servo" para parametrizr los servos. Función en página mover.cpp init_serial(); Lamamos a ajecurae la función "intit_servo" para parametrizr la trnsferencia de información. Función esn esta página.

debug_m("\n inicio \n"); se ejecurá la funsión "debug_m" para publicar "inicio". La función está al final de esta página. uint32_t read_cc; Se crea una variable llamada "read_cc",varible de 32 bi while(1){ init_c=command.getc(); if( init_c==0xFF){ read_cc=command.getc(); nmotores=command.getc(); posicion=command.getc(); endc=command.getc(); if(endc==0xFD){ switch (read_cc) { con el valor retornado y almacenado en la varible "read_cc" se realiza un switch para elegir qué operación se va ejecutar. case 0x01: led=0; command.printf(" **Se movera de a un solo motor.** \n\n"); moving(); break; en este caso solo hay una posible operación, mover un servo, se ejecuta la función "moving" al final de esta página. case 0x02: led=0; moverconjunto(); break; case 0x03: led=1; movercolor();break; default: debug_m("error de comando. \ncomando no especificado \n"); led=0; break ; } } else command.printf("Error de codigo de cierre \n"); } else command.printf("Error de codigo de inicio. \n"); } }

void init_serial() { command.baud(9600); velocidad de tranmisión } void moving(){ debug_m("se inicia el comado mover..\n"); se ejecuta la función "debug_m" con el dato "se inicia el comado mover.." mover_ser(nmotores,posicion); se ejecuta la función "mover_ser", página "mover.cpp",esta función se ejecutará con los datos "nmotor" y "grados" obtenidos anteriormente debug_m("fin del comado mover..\n"); se ejecuta la función "debug_m" para publicar el texto. }

void moverconjunto(){ command.printf("______________\n **Se movera un conjunto de motores.** \n\n"); mover_conjunto(nmotores,posicion); } void movercolor(){ command.printf("______________\n **Se movera el cuadrupedo.** \n\n"); sensor_color(nmotores,posicion); } void debug_m(char *s , ... ){ función para publicar.

1. if DEBUG command.printf(s); se publica el valor enviado.
2. endif } ----------------------------------

Función detección color.

Para esta función es necesario usar un sensor de color para nuestro caso RGB TCS3200, Iniciamos con la definición de la librería y los pines que usaremos de nuestra tarjeta.

1. include "mbed.h" DigitalOut s0(PA_3); DigitalOut s1(PA_2); DigitalOut s2(PA_10); DigitalOut s3 (PB_3); DigitalOut led (PB_4); DigitalIn out(PB_5); Usamos la variable de conteo Timer y activar los puertos seriales de comunicación. Timer tiempo; Serial pc(USBTX, USBRX); unsigned int lectura(void); int on; Este sensor fue ubicado en la parte inferior del cuadrúpedo. Los colores que detectara la función son Rojo, verde, azul y Claro"blanco"; el sensor genera una lectura que con el contador en pantalla dará unas lecturas numéricas para las cuales daremos un valor y asignaremos a cada color así interpretar el color que esta detectando nuestro sistema. El sensor esta equipado con led que emiten luz blanca y el reflejo sera captado por el foto receptor, es necesario activar este dispositivo y sus luces así empezar la lectura solo cundo se llame la función. unsigned int rojo=0; unsigned int verde=0; unsigned int azul=0; unsigned int clean=0; while(1){ on=pc.getc(); if(on==0x01){ s0=1; s1=1; led=1; s2=0;s3=0; rojo=lectura(); s2=0;s3=1; azul=lectura(); s2=1;s3=1; verde=lectura(); s2=1;s3=0; clean=lectura(); if (((verde>=8)&&(verde<=11))&&((azul>=10)&&(azul<=13))&&((rojo>=8)&&(rojo<=10))){ pc.printf("\n verde"); } else if(((verde>=25)&&(verde<=27))&&((azul>=11)&&(azul<=14))&&((rojo>=30)&&(rojo<=32))){ pc.printf("\n azul"); } else if (((verde>=14)&&(verde<=18))&&((azul>=12)&&(azul<=14))&&((rojo>=5)&&(rojo<=7))){ pc.printf("\n rojo"); }else pc.printf("\n %d %d %d %d \n",verde,azul,rojo,clean); wait(1); } else if (on==0){ led=0;} } } unsigned int lectura (void){ unsigned int inicio=0, final=0, resultado=0; tiempo.start(); while(out){} while(!out){} while(out){} inicio=tiempo.read_us(); while(!out){} final=tiempo.read_us(); resultado=(final-inicio); tiempo.reset(); return(resultado); } Para tener lecturas precisas y evitar el ruido lumínico instalaron un protector negro alrededor del sensor así captar la luz del led y tomar mejores lecturas. ----------------------------------

Función lectura análoga, manejo de Joystick con interruptor.

Por medio de este sensor tendremos lectura de movimiento en los ejes X y Y, junto con el interruptor, así asignar una función de movimiento a nuestro cuadrúpedo, o alguna función de interrupción. Este sensor lo alimentaremos con 3v, al deslizar la palanca nos dará una lectura de voltaje de salida la cual nos indicara la posición, dicho voltaje de salida sera leído por la tarjeta en el pin asignado. El inicio se indicaran los pines de entrada y salida de la tarjeta tal como lo indica su manual o clases en Mbed.

1. include "mbed.h" AnalogIn analog_value(A0); AnalogIn analog_y(A1); DigitalOut led(LED1); int main() { float meas_r; float meas_v; printf("\nAnalogIn example\n"); while(1) { Posterior a esto indicamos el rango: while(1) { meas_r = analog_value.read(); Read the analog input value (value from 0.0 to 1.0 = full ADC conversion range) meas_v = meas_r * 3300; Converts value in the 0V-3.3V range Display values printf("measure = %f = %f mV\n", meas_r, meas_v); Dependiendo de estos valores asignamos la función que debe realizar la tarjeta, aqui podemos asignar lo que neccesitamoss que realice el sistema. LED is ON is the value is below 1V if (meas_v < 1000) { led = 1; LED ON } else { led = 0; LED OFF }

wait(1); 1 second } }