En clases anteriores hemos revisado el modelamiento también hemos visto la simulación en esta clase.
Vamos a ver ya la parte de experimentación.
En primer lugar vamos a ver cómo podemos comunicarnos con un Jaguar en este caso vamos a utilizar Arduino
para realizar las pruebas experimentales y comparar con las pruebas simuladas.
Entonces vamos a ver cómo recibir múltiples datos y enviar múltiples datos desde Arduino.
En primer lugar vamos a hacer una prueba en el cual solamente vamos a enviar un solo dato entonces vamos
a ver cómo es la estructura de programación en la parte de Arduino.
En primer lugar vamos a declarar las variables que vamos a necesitar para recibir y enviar los datos.
Acá podemos ver una variable Data Stream el cual va a almacenar en forma de string todos los valores
que vienen desde MATLAB.
Acá tenemos un dato booleano este dato booleano va a ser una bandera indicándome que el dato o la trama
que se ha enviado desde MATLAB ha sido correcta.
Inicialmente lo vamos a declarar como falso.
Una vez que llegue los datos de manera correcta alzarán esta bandera y la pondrá en verdadero.
A continuación acá tenemos un separador este separador es necesario debido a que vamos a enviar múltiples
datos.
Entonces debemos tener un separador para poder separar cada uno de estos datos que vamos a enviar desde
MATLAB.
Entonces lo vamos a poner con un separador de Comas aquí podría ir cualquier otro valor por ejemplo
una letra digamos una mayúscula u otro tipo de carácter que me permita distinguir entre un dato y otro
dato.
Aquí tenemos el tamaño del dato.
En este caso les había mencionado que sólo vamos a enviar un dato en las siguientes pruebas vamos a
enviar dos y hasta tres datos y vamos a ver que simplemente cambiando algunas cosas podemos enviar una
cantidad de datos que necesitemos.
Acá declaramos un vector en el cual se va a ir almacenando los datos un dato de tipo entero que va a
ir almacenando en cada posición cada uno de los datos que va a enviar MATLAB.
Acá tenemos las variables medidas en este caso nosotros al trabajar con robots móviles vamos a medir
los RPM.
Entonces acá declaramos una variable float que me permite almacenar aquí las rpm que vamos a leer mediante
un Encode.
Eso lo vamos a ir viendo en las siguientes clases de MATLAB vamos a recibir un valor de r.p.m de referencia
para que nuestro robot se mueva.
A continuación vamos al Setup y acabamos a realizar la configuración en primer lugar vamos a configurar
el puerto serial a 9600 baudios.
Estos baudios de aquí deben coincidir con los que vamos a programar y MATLAB.
Aquí vamos a inicializar las variables que habíamos declarado acá arriba con cero.
Luego tenemos nuestra función bailout donde se va a ejecutar nuestro programa repetidamente.
Aquí vamos a verificar si la bandera que habíamos declarado acá arriba se encuentra como verdadera.
Es decir que los datos han llegado de una manera correcta.
Para ello vamos a irnos a esta función.
Esta función serial Eben es propia de Arduino y se ejecuta cada vez que existen datos en el buffer.
Entonces al existir datos en el buffer nosotros vamos a entrar en un bucle guey en el cual vamos a estar
repitiendo de manera consecutiva toda esta programación.
Entonces lo que va a hacer aquí es almacenar cada uno de los caracteres que vienen de MATLAB y como
acá vamos a tener un carácter Char hinchar el cual lo vamos a leer con el serial RIT y luego lo vamos
a ir concatenando en el Data string que habíamos mencionado para recibir la trama completa y luego verificamos
si el carácter leído es igual a un salto de línea.
Si es así nuestra trama ha llegado completa y se levanta la bandera como pueden ver acá.
Entonces acá entraría ya este gif entonces de aquí data completo ya es verdadero entonces centralice
y luego aquí lo que va a hacer en este fork es separar cada uno de los datos.
En este caso como sólo tenemos un dato simplemente almacenará en la posición cero en data Zero almacenará
el primer dato.
Esto lo vamos a ver más a fondo cuando tengamos más de dos datos listo entonces eso lo vamos a dejar
ahí por el momento y luego lo que vamos a hacer es asignar el data a cero los r.p.m de referencia que
envía MATLAB y nosotros lo que vamos a hacer es de enviarlos r.p.m medidos en este caso aún no he leído
ningún tipo de r.p.m.
Entonces lo que voy a hacer es simplemente recibir el dato de MATLAB y voy a enviar el mismo dato y
vamos a ver qué sucede en nuestro caso sólo vamos a trabajar con datos enteros por lo tanto es necesario
convertir el dato de los r.p.m medidos a un tipo entero.
Esto lo hacemos con el caset y entonces lo que vamos a hacer es encerrar el Data string y además vamos
a bajar la bandera a Fool's.
A continuación vamos a ver la parte de MATLAB nos vamos a MATLAB y vamos a crear un nuevo escrit.
En primer lugar vamos a ubicar estos comandos que ya lo habíamos analizado en la parte de simulación
Clear Clow celeste y warning luego acá tenemos el tiempo de simulación lo vamos a ejecutar durante unos
20 segundos nuestro tiempo de muestreo de 0.1 y vamos a crear nuestro vector de tiempo acá vamos a crear
una variable con el tamaño del vector de tiempo acá tenemos el COM aquí debemos escoger el com en el
cual se encuentra conectado el Arduino.
Eso lo podemos ver en el Administrador de dispositivos para observar dónde se encuentra conectado nuestro
Arduino.
Entonces ustedes deberían cambiar esta parte de aquí.
Luego esta parte de aquí me permite cerrar este puerto en el caso de que esté abierto porque lo que
tenemos que hacer en una comunicación es abrir el puerto enviar y recibir los datos y cerrar el puerto
una vez que hayamos terminado de leer o escribir los datos.
Luego vamos a declarar un objeto de tipo serial y lo vamos a nombrar que sería puerto serial.
Luego vamos a enviar algunos parámetros tenemos aquí los baudios como los ya había mencionado debe coincidir
los baudios de la configuración de MATLAB con las de Arduino en este caso 9600 baudios.
Luego vamos a enviar la configuración del bit de parada que sería 1.
Tenemos también el tamaño del dato en bits que sería de 8.
Luego vamos a enviar la paridad en este caso no tiene paridad y también vamos a enviar un carácter que
finaliza el envío esto es muy importante esta configuración para poder enviar y recibir los datos de
una manera correcta.
Acabamos aceptar el tamaño del buffer de entrada y de salida en este caso se da en bits.
Nosotros podemos poner un valor más grande más pequeño siempre y cuando no sea menor al número de partes
que vamos a recibir.
Luego acá tenemos un tiempo de espera de dos segundos hasta que los datos lleguen.
Listo entonces lo que vamos a enviar nosotros son las rpm de referencia.
La vamos a enviar Arduino y luego vamos a recibir las rpm medidas para esto vamos a crear un vector
de ceros del tamaño del vector tiempo para almacenar las rpm que vamos a medir.
En Arduino esto lo hacemos para almacenar memoria y que nuestro programa corra mucho más rápido entre
menos tiempo se demora es mucho mejor.
Esto debido a que nosotros debemos hacer todo esto en menos del tiempo de muestreo es decir en menos
de 100 milisegundos.
Listo entonces todas las variables que vayamos a utilizar dentro de este foro que vemos acá ya lo vamos
a revisar.
Deben declararse como ceros como un vector de ceros del tamaño de el vector tiempo.
Por ejemplo acabamos almacenar también el tiempo en el que se demora en realizar este procedimiento
entonces también vamos a declararlo con un vector de ceros.
Luego vamos a abrir el puerto vamos a abrir el puerto y vamos a poner un retardo de tres segundos esperando
hasta que el dispositivo en este caso el Arduino se comunique con MATLAB.
Luego que haya transcurrido este tiempo vamos a imprimir un indicador en el cual me va a mostrar que
ya estoy recibiendo los datos en el bucle for.
Vamos a inicializar como ya lo habíamos visto con k igual a uno hasta el tamaño del vector en este caso
no es necesario poner estos signos directamente porque ya habíamos declarado esta variable acá dentro
del foro vamos a utilizar unos nuevos comandos que son el tic y el TOC lo que me permite estos dos comandos
es obtener cuánto se demora en ejecutar este código de aquí y este tiempo lo vamos a almacenar en este
vector que habíamos declarado acá arriba.
Entonces acá vamos a ver la trama vamos a realizar la trama como les había dicho en este caso simplemente
vamos a enviar un solo dato para enviar este dato en primer lugar debemos considerar el tipo de dato
MATLAB.
Acá no considera el tipo de dato simplemente lo declara de manera automática en este caso es un tipo
float pero si recordamos nosotros habíamos mencionado que sólo vamos a trabajar con datos de tipo entero
para ello vamos a utilizar esta función Rouget que me permite redondear este valor y convertirlo a un
valor de tipo entero luego acá vamos a convertir este valor a un string.
Entonces esto lo hacemos con este comando juntos etcétera.
Con esto convertimos este valor redondeado a string.
Entonces tendríamos lista nuestra trama de un solo valor luego lo que vamos a hacer es escribir estos
datos en el buffer de salida.
Acá tenemos nuestro objeto del puerto serial el tipo de dato en este caso de string y también vamos
a agregar el final de trama como un salto de línea ya que es necesario para levantar la bandera que
habíamos colocado en Arduino.
Enviamos la trama y todo esto lo va a hacer de manera sincrónica luego vamos a recibir el dato.
Para ello lo vamos a almacenar en el vector que habíamos declarado anteriormente y para esto vamos a
utilizar la función f scam entonces esta me permite leer este dato.
En este caso de tipo entero como vemos aquí y también que venga con salto de línea ahora este tiempo
puede ser variable por ejemplo puede ser de 10 20 30 15 milisegundos.
Nosotros necesitamos un tiempo estable un tiempo que sea constante de 0.1 segundos.
Entonces nosotros para asegurar este tiempo de muestreo de 100 milisegundos vamos a utilizar esta parte
de aquí el cual me permite tener el tiempo de muestreo de una manera constante.
Le decimos que mientras Tok es decir va a estar constantemente leyendo el tiempo sea menor al tiempo
de muestreo es decir 0.1 segundos entonces no hace nada sigue en el bucle hasta que se complete y cumpla
su tiempo de muestreo sale y continúa para la siguiente iteración.
Luego vamos a imprimir acá fin en la ventana de comandos vamos a imprimir lo pin para saber que ya ha
terminado de recolectar los datos.
Luego acá vamos a enviar un nuevo valor en este caso vamos a enviar un valor de cero.
Esto debido a que por ejemplo cuando estemos haciendo el control de los motores vamos a necesitar que
el robot se pare entonces nosotros vamos a enviar unas DPM de cero.
Entonces por esto también es necesario al finalizar el bucle for luego acá simplemente es realizar las
gráficas.
Vamos a comparar tanto las rpm medidas como las rpm de referencia luego que hemos hecho todo esto lo
que vamos a hacer es cerrar el puerto.
Entonces esto debería ir antes eso lo vamos a colocar después de que realiza esto vamos a cerrar el
puerto cerramos el puerto borramos el objeto y luego vamos a realizar la gráfica de tiempo para observar
cuánto tiempo se demoró en ejecutar este código de aquí.
Esto es muy importante tener en cuenta que al momento de correr MATLAB debemos tener cerrado todos los
otros programas porque van a afectar en este tiempo de medición.
Entonces hay que tener en cuenta eso en mi caso yo estoy utilizando algunos programas que están abierto
entonces el tiempo va a ser un poco más de lo esperado digámoslo así entonces vamos a correr el programa
como podemos observar y aparece el mensaje en el cual me dice que está recibiendo los datos ahora debemos
esperar el mensaje que me dice que ha finalizado la recepción de los datos.
Entonces vamos a esperar y podemos observar que ha finalizado en esta gráfica podemos observar el tiempo
de muestreo que en promedio se ha demorado unos 55 milisegundos en realizar todo este procedimiento
entonces es bastante bueno porque aún tenemos tiempo para realizar otras operaciones como el control.
Acá podemos observar la gráfica de las señales tenemos la señal medida de color azul y la señal de referencia
de color rojo bueno en este caso deberían coincidir las señales verdad es decir la que estamos enviando
desde MATLAB luego la estamos pasando por Arduino y de nuevo estamos regresando hacia MATLAB pero recordemos
que en Arduino estamos trabajando con variables sólo de tipo entero entonces las de rojo como habíamos
visto acá es de tipo float como vemos acá y la que retorna es de tipo entero por lo tanto se va a redondear
ciertas partes.
Es por ello que podemos notar que estos pequeños escalones que vemos aquí podemos observar ahí esa es
la parte de redondeo de la señal.
Entonces como vemos acá esta es de tipo entero y la variable de acá es de tipo float es decir tiene
mucha más precisión listo entonces lo siguiente que vamos a hacer ya las pruebas con más variables por
ejemplo cuando trabajamos con el robot mi ciclo necesitamos dos r.p.m es decir de la llanta izquierda
y de la llanta derecha.
Por ejemplo cuando trabajemos con robots donde ya tengan más motores necesitaremos agregar nuevas variables
entonces vamos a trabajar con dos y vamos a llegar hasta tres y vamos a ver que es muy fácil acoplar
este código tanto de Arduino como además para adquirir más señales.
Entonces vamos a cambiar primero un Arduino vamos a ir a un arduino entonces vamos a declarar otras
nuevas variables vamos a copiar esto de hacking y vamos a pegar la sacábamos a cambiarla de nombre simplemente
vamos a poner uno uno y aquí ya el tamaño de los datos va a ser de dos.
Vamos a recibir todos datos y también vamos en ciertos datos entonces vamos a ver acá también vamos
a declarar estas variables.
Como ven simplemente es copiar e ir cambiando los nombres vamos a cambiar aquí los nombres.
Esto como les había mencionado es automático acá me va a detectar la cantidad de datos en este caso
ya va a ser dos.
Luego acá mediante esta función me permite separar cada uno de los datos mediante este separador que
habíamos visto acá que es la coma.
Listo entonces se va a ir almacenando se va a ir almacenando estos datos en cada una de las posiciones
del vector data.
Listo entonces acá lo que vamos a hacer también es acá recibir este dato.
Vamos a recibir este dato.
Ahora vamos a tener también otra r.p.m de referencia pero va a ser la posición 1 y acá también sería
1 y acá de igual manera sería 1 listo y también vamos a imprimir.
Entonces como les había mencionado también vamos a enviar estos datos hacia MATLAB.
Listo.
Lo que debemos considerar para enviar de manera correcta los datos desde arruino MATLAB es que sea de
tipo entero y también tenga el salto de línea listo.
Entonces acá ya no hay nada más que realizar simplemente vamos a guardar y lo vamos a cargar en el Arduino
listo una vez que hemos cargado en el Arduino vamos a hacer lo siguiente Vamos irnos a MATLAB y vamos
a cambiar algunas cosas acá lo que vamos a hacer es vamos a enviar otra referencia diferente a esta.
Entonces vamos a crear otra variable que se va a llamar RPM rev 1 y vamos a enviar una función tipo
C listo.
De igual manera vamos a crear este vector para almacenar memoria.
Listo.
Luego vamos a QAM y acá en la trama.
Acá es importante la trama debemos armar la trama de tal manera que reciba de manera correcta en Arduino
para ello vamos a concatenar y esto lo vamos a hacer creando un vector.
Entonces vamos a hacer lo siguiente vamos a encerrar entre corchetes vamos a dar un espacio vamos a
poner el separador Koma vamos a dar un espacio y vamos a ubicar el otro valor.
En este caso vamos a copiar esto de acá y lo vamos a pegar y vamos a poner aquí el valor 1.
Listo.
Entonces aquí ya hemos hecho nuestra trama.
Acá se mantiene lo mismo y acá lo que deberíamos hacer es leer el otro dato entonces acá aumentaría
de igual manera 1 y esto lo mantendríamos listo entonces acá también deberíamos aumentar en la figura
ya vamos a tener dos variables.
Por lo tanto hay que poner su plot.
Vamos a ponerle dos filas una columna y vamos a activar la primera fila entonces podemos ver ACAM y
vamos a copiar esto de hacking y vamos a dar enter y vamos a pegar.
Vamos a activar la segunda fila y aquí vamos a pilotear la otra señal.
Vamos a plantear la otra señal y listo.
Vamos a correr el programa y vamos a observar el resultado listo a terminado pero hay un pequeño problema
no hemos colocado bien el nombre vamos ACAM y aquí es su vlogs.
Este es el nombre correcto no lo hemos ubicado bien ahora simplemente vamos a correr esta parte del
código para ello simplemente debemos dar control Enter.
Recuerden que podemos correr esta sección de código siempre y cuando tenemos acá.
Como ven estos dos símbolos de porcentaje damos controlé enter y podemos observar las gráficas en este
caso podemos ver que incluso aumentó más variables y el tiempo bajó en que debería hacerlo como les
había mencionado este tiempo va a variar dependiendo de las aplicaciones que estén abiertas y otros
factores entonces podemos ver qué hizo en menor tiempo.
Sin embargo hubo más código.
Entonces podemos observar a Kage hemos enviado la señal de referencia coseno y acá la variable C.
Entonces como ven se cumple.
Estamos recibiendo y enviando correctamente los datos.
Entonces como ven es sumamente sencillo acoplar este código que les voy a proporcionar de manera muy
fácil ir aumentando las variables que ustedes deseen.
Vamos a intentar en este caso con tres vamos a intentar con tres vamos irnos acá y acá vamos a crear
un pronombre y ya no vamos a enviar esto simplemente vamos enviarlo de esta manera.
Listo vamos a cambiar vamos a crear simplemente una pendiente cambiemos de este valor dejémosle en 9.
Listo.
Luego acá también vamos a crear este valor que vamos a leer vamos a crear igual otra variable.
Listo y acabamos de aumentar la trama.
Vamos a copiar esta parte de ACAM.
Como ven solamente hay que copiar y pegar e ir cambiando los nombres.
Esto sí hay que tener mucho cuidado al momento de copiar hay que tener en cuenta que debemos cambiar
los nombres.
Listo y acabamos de poner una variable más.
Podemos recibir sólo dos no hay ningún problema pero voy a recibir tres variables eso no hay ningún
inconveniente.
Podemos recibir por ejemplo enviar dos recibir tres o cuatro y así no debe ser exactamente el mismo
número de variables que se envían que las que se reciben.
Pero en nuestro caso sí debemos hacerlo entonces vamos a crear otra variable listo ya estamos leyendo
y también vamos a pilotear esta variable de aquí entonces vamos a crear otra tercera fila y listo y
vamos a copiar esta parte de aquí vamos a pegar y vamos a activar la tercera fila listo y vamos a cambiar.
Acá falta cambiar el nombre vamos a cambiar el nombre acá cambiamos aquí y creo que ya está todo listo
en la parte de MATLAB listo vamos a disminuir un poco el tiempo vamos a dejarlo solamente en 10 segundos
listo.
Ahora vamos a irnos Arduino.
Nos vamos a Arduino y nuevamente vamos acá importante primero cambiar el tamaño de los datos que van
a ser tres en este caso vamos a recibir tres datos entonces vamos a copiar estas variables vamos a pegar
vamos a poner dos vamos a poner dos listo y luego acá también vamos a inicializar las vamos a ponerlas
con el valor de cero entonces vamos a ubicar aquí el valor todos todos listo y acá copiamos este código
vamos a pegarlo y acá vamos a ponerlo dos acá recuerden también que vamos a recibir ya en el 2.
También tenemos dos y también dos y también vamos a enviar como les había mencionado podemos enviar
solamente esos dos datos pero hay que tener en cuenta que MATLAB también debemos poner solamente dos
es decir aquí también tendríamos que poner sólo dos es decir borrar esta parte de aquí pero también
vamos a recibir los datos todos los datos completos entonces vamos a copiar y vamos a pegar listo entonces
vamos a poner el valor número dos listo entonces ya hemos terminado la programación en Arduino.
Vamos a cargar vamos a cargar el código y vamos a observar cuál es el resultado en Matlab entonces ya
se cargó el código y vamos a ejecutar acá listo ejecutamos el código y vamos a observar cuál es el resultado
ha finalizado y vamos a ver en este caso como ven está dentro de los 50 milisegundos el tiempo en el
que se ha demorado la recepción de datos.
Vamos a cerrar y podemos observar que efectivamente se han recibido los datos de manera muy correcta.
Tenemos aquí la función seno la función coseno y aquí la pendiente que habíamos realizado.
Entonces como ven es muy sencillo leer múltiples datos en Matlab con Arduino.
Entonces esto nos va a servir para comunicarnos con Arduino y realizar los controladores aquí en MATLAB.
Vamos a realizar tanto la parte de simulación y la parte real aquí en MATLAB.
Esto sería todo en esta clase.