Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Comunicaciones en Arduinio Uno - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 13 de marzo de 2023 por Juan Luis C.

49 visualizaciones

Más información Transcripción

Descargar la transcripción

Hola, muy buenas. En esta práctica vamos a aprender a comunicar la placa de Arduino con el ordenador. 00:00:00
Como bien sabemos, la información en los ordenadores se codifica en forma de unos y ceros y se agrupan formando palabras. 00:00:06
De esta manera podemos tener palabras formadas por 8 bits, lo que conocemos como bytes, o palabras formadas por varios bytes. 00:00:13
Por ejemplo, en Arduino, para los caracteres se emplean palabras de un solo byte, mientras que para los números enteros se emplean palabras de 2 bytes. 00:00:21
Existen básicamente dos formas para que dos dispositivos se puedan enviar esta serie de bits de unos a otros. 00:00:31
Una es mediante conexiones paralelas. En este caso, se tendría que llevar un cable por cada uno de los bits. 00:00:38
La otra forma es la comunicación serie, de tal manera en la que con un único cable, o mejor dicho, un par de cables al menos, se van enviando bit a bit cada uno de los elementos que forman la palabra. 00:00:45
Típicamente, en los ordenadores conviven las dos formas de comunicación. 00:00:58
Ya sabemos que la comunicación que se utiliza entre la CPU y la memoria principal del ordenador es en paralelo. 00:01:02
Por el bus de datos iría cada uno de los bits de una palabra de la memoria. 00:01:09
Pero también existen otras conexiones donde la comunicación se realiza mediante puertos de tipo serie, como es el caso de los conectores USB. 00:01:14
También nos podemos encontrar, por ejemplo, puertos paralelos, el típico en el que se conectaban antiguamente las impresoras, o puertos serie donde antiguamente se enganchaban, por ejemplo, los fases. 00:01:24
Bien, si nos fijamos en nuestra placa de Arduino hay dos pines digitales, el 0 y el 1, que tienen las palabras RX y TX 00:01:37
Estos dos pines se utilizan para la comunicación serie, donde RX será para recibir y TX para transmitir 00:01:47
Pero además tenemos conectados esos dos pines con la conexión USB de la placa de Arduino 00:01:54
Si nos fijamos en un conector de USB vamos a encontrar realmente cuatro cables 00:01:59
Los dos exteriores se utilizan para alimentar la placa y los dos interiores para comunicación. 00:02:04
Pues bien, nuestra placa de Arduino tiene estos dos pines, el 0 y el 1, conectados con el USB, 00:02:10
de tal manera que podemos comunicarnos a través del USB con el ordenador, que es lo que vamos a hacer en esta práctica. 00:02:17
Una cosa que tenemos que tener en cuenta cuando utilizamos estos dos pines es que no los podemos tener activos cuando cargamos un programa 00:02:23
porque puede interferir con la comunicación con el ordenador. 00:02:30
Bueno, pues vamos a ver cómo podemos utilizar esto que hemos dicho para comunicarnos con el ordenador. 00:02:34
En la referencia de Arduino vamos a encontrar la clase Serial que va a tener una serie de métodos, es decir, funciones, 00:02:39
que nos va a permitir la comunicación entre el ordenador y nuestra placa de Arduino. 00:02:46
Pero vamos a verlo con un ejemplo. 00:02:51
En el setup vamos a utilizar la función Begin de la clase Serial. 00:02:52
Como la comunicación serie de Arduino es asíncrona, necesitamos decirle la cantidad de bits por segundo que vamos a enviar. 00:02:56
Un valor típico sería el de 9600. 00:03:05
Y tanto el transmisor como el receptor tienen que tener esta velocidad configurada porque si no, no funcionaría. 00:03:09
A continuación vamos a crearnos un dato de tipo carácter. 00:03:16
Char es el tipo de dato que se utiliza para los caracteres. 00:03:21
Así pues, vamos a crearnos la variable letra y le vamos a asignar el valor de la letra b. 00:03:23
Para asignar valores individuales de tipo carácter se utilizan las comillas simples. 00:03:31
Y a continuación vamos a enviar este dato utilizando la clase serial. 00:03:36
Serial.print letra. 00:03:41
Y para no saturar de letras nuestra pantalla vamos a esperar un segundo cada vez que escribimos una letra. 00:03:45
para ver en el ordenador la información que envía la placa, vamos a utilizar el monitor serie, que está aquí abajo. 00:03:53
Entonces, ahora cuando ejecutemos, tenemos que ver que van a ir apareciendo segundo a segundo la información que estamos enviando. 00:04:01
Ok, perfecto. Si queremos que estas letras aparezcan en líneas distintas, podemos utilizar el método println. 00:04:08
Probemos de nuevo 00:04:18
Bien, con esta técnica podemos enviar también cadenas de texto 00:04:20
Para las cadenas de texto se suele emplear el tipo de datos string 00:04:28
String en realidad es un objeto, pero se utiliza tanto que ya viene implementado dentro del lenguaje 00:04:33
De esta forma vamos a crearnos la variable texto 00:04:39
Y entre comillas dobles vamos a poner el texto que queremos enviar 00:04:42
Por ejemplo, hola mundo 00:04:47
Vamos a comentar esta línea de aquí 00:04:49
y vamos a enviar este texto. 00:04:51
Vamos a borrar lo que tenemos en el monitor serie con este botón 00:04:55
y vamos a iniciar la simulación. 00:04:58
Como vemos, cada segundo nos envía directamente la cadena de texto. 00:05:02
Y por último, para completar esta parte, vamos a mandar un número. 00:05:08
Nos creamos la variable. 00:05:12
Fijaros que aquí no se emplea ni comillas simples ni comillas dobles. 00:05:14
E igual que hicimos antes, comentamos esta línea y vamos a enviar el número. 00:05:17
Bien, perfecto. Ahí lo vemos. 00:05:26
Bien, ya hemos visto cómo podemos enviar información desde nuestra placa de Arduino al ordenador. 00:05:28
Ahora vamos a ver cómo enviar información desde el ordenador a la placa de Arduino. 00:05:35
Esto es muy útil porque nos va a permitir gobernar nuestro sistema mediante comandos que enviemos a través del ordenador. 00:05:40
Y para hacer esto vamos a montar un sencillo circuito. 00:05:46
Como siempre, vamos a utilizar nuestras conexiones, vamos a poner un LED, vamos a conectarlo a tierra, vamos a dar a la resistencia un valor de 250 ohmios y vamos a engancharla al pin 2. 00:05:50
Bueno, lo que vamos a hacer con este programa es encender o apagar la bombilla en función de los comandos que nos manda el ordenador. 00:06:12
Bueno, igual que antes tenemos que inicializar nuestro monitor, pero ahora en lugar de enviar letras vamos a recibirlas 00:06:20
Vamos a borrar todo esto que ya no lo necesitamos y lo primero que haremos será preguntar si hay datos disponibles 00:06:29
Para ello dentro de la estructura if utilizamos el método available que nos devuelve verdadero en caso de que haya datos disponibles y falso en caso contrario 00:06:36
Y ahora vamos a utilizar el método read para asignar a nuestra variable el valor que se haya enviado desde el ordenador 00:06:49
Es importante tener en cuenta que este método read lee un único byte 00:06:57
Y ahora haremos lo siguiente 00:07:01
Si la letra es una A, que no se nos olviden las notas iguales 00:07:03
Vamos a encender el let con la función digitalWrite 00:07:08
Donde tenemos que indicarle el pin 00:07:11
Por cierto, se me ha olvidado configurar los pines 00:07:13
Vamos a hacerlo, in pinLED igual a 12 y aquí en el setup tenemos que decir pinMode pinLED output y aquí utilizaremos pinLED y a nivel alto. 00:07:16
Y si no, tendremos que escribir un nivel bajo. 00:07:33
Vamos a borrar lo que había en el monitor serie y vamos a ver cómo funciona esto. 00:07:37
Interesante, como inicializamos la variable letra con la letra B 00:07:40
Hasta que se reciba la letra A desde el ordenador 00:07:45
El LED va a estar apagado 00:07:48
Vamos a comprobarlo 00:07:50
Efectivamente, inicialmente está apagado 00:07:52
Y si yo ahora envío una letra A 00:07:54
Pues se enciende 00:07:57
Bueno, aquí solo se ha encendido de forma muy rápida 00:07:59
Porque hemos declarado la variable dentro del loop 00:08:02
Entonces cada vez que se hace una vez el loop, pues inicializamos la letra AB, esto va a durar un A, el encendido, entonces si queremos que permanezca encendido más tiempo, tenemos que ponernos la variable aquí, es decir, tenemos que hacerla de tipo global. 00:08:06
Y si ahora ejecutamos, vemos que aparece apagado, cuando le damos a la A se enciende y cuando mandemos cualquier otra letra, por ejemplo la B o da igual, una E, la que sea, cualquier otra, va a estar apagado. 00:08:24
De nuevo, si damos a la A se enciende, cualquier otra letra se apaga. 00:08:42
Bien, vemos como verdaderamente estamos gobernando nuestro sistema mediante órdenes del ordenador. 00:08:47
Vamos a hacer un poquito más completo el programa para que, por ejemplo, cuando enviemos la letra P, el LED empieza a parpadear. 00:08:53
Para ello vamos a utilizar la estructura else if, donde aquí vamos a decirle que si la letra es igual a P, 00:09:02
pues lo que tenemos que hacer es encender, esperar, por ejemplo, 500 milisegundos, apagar y volver a esperar otros 500 milisegundos. 00:09:09
Y por último vamos a decirle que si no, si se recibe cualquier otra cosa, vamos a apagar el LED. 00:09:18
Vamos a probarlo. 00:09:25
Bueno, inicialmente como vemos está apagado. 00:09:26
Si ahora le damos una letra, por ejemplo la P, vemos que efectivamente parpadea. 00:09:29
Si le damos la A, se queda encendido de forma fija. 00:09:35
Y si le ponemos cualquier otra letra, por ejemplo la B, vamos a ver cómo el LED se apaga. 00:09:40
De nuevo podemos darle a P, vemos que vuelve a parpadear. 00:09:45
Bueno, vemos que efectivamente estamos gobernando nuestro sistema a través de órdenes que mandamos desde el ordenador. 00:09:50
Bueno, ya hemos visto cómo podemos enviar letras de forma individual a la placa. 00:09:58
Pero ¿qué pasa si queremos enviar una cadena de caracteres? 00:10:03
En principio no se puede hacer de esta forma porque Read no va a leer carácter a carácter. 00:10:07
Y eso puede suponer un problema. Para poder leer una cadena de caracteres, podemos hacerlo de la siguiente manera. 00:10:12
Bueno, lo primero que vamos a hacer va a ser cambiar nuestra variable, que ahora va a ser de tipo string, y la vamos a llamar texto. 00:10:20
Y por supuesto, ya no va entre comillas simples, sino entre comillas dobles, y le vamos a poner nada, porque nuestra variable texto la vamos a utilizar como un comando. 00:10:27
Y ahora, donde aparece letra, ponemos nuestra variable texto y hacemos un rateString hasta until y vamos a ponerle aquí un carácter que es el retorno de carro. Se hace con la tecla invertida, que es al gr y arriba a la izquierda del teclado donde aparece la a y la o, esta pequeñita, vale, y n. 00:10:36
Este es el carácter de retorno de carro. Por cierto, que podemos verlo en nuestra lista de caracteres acti, concretamente se corresponde con el valor decimal 13, sería este de aquí, el retorno de carro. 00:10:58
Y este carácter viene asociado con la tecla intro de nuestro teclado, de tal manera que cuando escribimos un texto y le damos a retorno de carro, nos vamos a la siguiente línea, ¿verdad? 00:11:13
Bien, pues ahora seguimos y decimos que nuestra variable texto cuando valga encender, y lo pongo entre comillas dobles, lo pondremos a nivel alto, y cuando nuestra variable texto valga parpadear, parpadearemos, y si no, bueno, vamos a completarlo, vamos a poner que si nuestra variable texto vale apagar, apagamos nuestro LED. 00:11:22
Si enviamos cualquier otra cadena de texto 00:11:48
No va a suceder nada 00:11:50
Vamos a probarlo 00:11:52
Me da un error 00:11:53
Porque se me ha olvidado de que esto 00:11:55
Tiene que ir entre comillas dobles 00:11:57
No comillas simples 00:11:59
Vale, vamos a ello 00:12:01
Bien, pues ahora abrimos el monitor 00:12:02
Y escribimos encender 00:12:05
Y efectivamente 00:12:07
Se ha encendido 00:12:12
Vemos que tarda un poquito más 00:12:13
Porque ya no estamos enviando solo un byte 00:12:15
Sino varios bytes 00:12:17
Varias letras 00:12:18
Pero bueno, funciona 00:12:20
Ahora le ponemos, por ejemplo, parpadear 00:12:21
Y efectivamente nuestro LED comienza a parpadear 00:12:23
Y si le escribimos apagar 00:12:31
Pues se ha apagado 00:12:33
Encender 00:12:37
Se enciende de nuevo 00:12:38
Y si escribimos cualquier otra cosa 00:12:41
Pues vamos a ver que sigue exactamente igual que esta 00:12:43
Que no cambia 00:12:47
Bien, pues ya vemos la técnica que podemos utilizar 00:12:47
Para enviar o recibir cadenas de texto 00:12:51
Bien, y por último vamos a hacer lo mismo pero con los números, pero en este caso vamos a cambiar el programa de tal manera que el LED siempre va a estar parpadeando y lo que vamos a enviar es el tiempo de espera entre los parpadeos, es decir, vamos a controlar la velocidad de parpadeo de nuestro sistema. 00:12:53
vamos a utilizar entonces una variable de tipo entero 00:13:11
le vamos a llamar espera 00:13:14
y vamos a ponerlo por defecto de 200 milisegundos 00:13:16
a continuación vamos a cambiar esta variable por la nuestra de espera 00:13:19
y vamos a utilizar el método partIn de la clase serial 00:13:24
vamos a quitar todo esto que no necesitamos 00:13:27
vamos a ordenar un poquito esta línea de aquí 00:13:31
por cierto, para cambiar varias líneas de posición hacia la derecha o hacia la izquierda 00:13:35
se seleccionan todas y se juega con el tabulador. Si yo doy una tabulación una vez seleccionado 00:13:40
veo que se mueven hacia la derecha todas las líneas a la vez. Y si mantengo apretada 00:13:46
la tecla de mayúsculas y doy al tabulador veo que viene hacia la izquierda todo el conjunto 00:13:53
de líneas. Y todo esto nos sobra. Y ahora eso sí, aquí en lugar de un valor fijo le 00:13:59
tenemos que decir nuestra variable espera. Vamos a probarlo. Vemos que está parpadeando 00:14:05
con el valor inicial y si nosotros ahora ponemos por ejemplo 1000, vemos que parpadea más 00:14:12
despacio. A la hora de introducir estos valores tenemos que tener cuidado porque si le ponemos 00:14:17
un valor muy grande, por ejemplo 10000, vamos a ver que se enciende y se apaga cada 10 segundos 00:14:20
y claro, cuando queramos mandar otro valor no va a ser inmediato porque hasta que nos 00:14:26
ejecuta toda esta línea de aquí, pues no vamos a llegar a leer. Para paliar un poco este efecto, podemos limitar el valor de espera, de tal manera que decimos que si espera es mayor que, por ejemplo, un segundo, mil milisegundos, decimos que nuestra variable espera sea mil milisegundos. 00:14:31
Esta es una técnica habitual para poner dentro de un rango de valores una variable, de tal manera que si ejecuto y pongo un valor, por ejemplo, de 10.000 como antes, vamos a ver que se limita al valor de un segundo solamente. 00:14:50
No dejamos poner valores excesivamente grandes. Ahora, por ejemplo, ponemos un valor de 100 y vamos a ver cómo a continuación el LED parpadea de forma muy rápida. 00:15:08
Bueno, pues ya hemos visto varias técnicas para poder comunicar la placa de Arduino con nuestro ordenador. 00:15:18
Y estas técnicas van a ser parecidas para comunicarnos con otros dispositivos. 00:15:23
Por ejemplo, podemos añadir un módulo de comunicación por Bluetooth a nuestra placa de Arduino de tal manera que podamos enviar y recibir comandos a través del móvil. 00:15:27
Pero eso ya lo veremos más adelante. 00:15:36
Venga, hasta la próxima práctica. 00:15:37
Valoración:
  • 1
  • 2
  • 3
  • 4
  • 5
Eres el primero. Inicia sesión para valorar el vídeo.
Idioma/s:
es
Autor/es:
Juan Luis Carrillo Arroyo
Subido por:
Juan Luis C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
49
Fecha:
13 de marzo de 2023 - 11:28
Visibilidad:
Público
Centro:
IES EL ALAMO
Duración:
15′ 40″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
179.90 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid