Acerca de Programación Curso de programación de Arduino utilizando Proteus[Proteus versión 8.1]
En lecciones anteriores hemos visto el uso de las entradas digitales y de las entradas analógicas. Vamos en esta lección a mezclar ambos conceptos para lograr utilizar en nuestro equipo Arduino entradas digitales con vigilancia de cable. Para entender que queremos decir, vamos a poner un ejemplo en el que sea necesario vigilar la correción del cableado en una entrada digital.
Supongamos que nuestro equipo Arduino lo utilizamos para controlar algún tipo de máquina móvil, por ejemplo la apertura y cierre de la puerta de un garaje. Cualquier máquina móvil encierra un cierto riesgo potencial para las personas que la utilizan. Siguiendo con nuestro caso, la puerta del garaje puede cerrarse cuando alguien está en el medio y pillarle. Para prevenir esta posibilidad, dotamos a nuestro sistema de control de un pulsador de parada, que detiene el movimiento de la puerta en cuanto se pulsa. El pulsador de parada lo hemos diseñado utilizando uno de sus contactos auxiliares como entrada digital de nuestro equipo Arduino. Por lo tanto tendríamos este esquema de montaje.
Así, cuando nuestro amigo ve que la puerta que se está cerrando puede pillarnos, pulsará sobre el botón de parada, activará una de las entradas digitales de nuestro equipo Arduino y éste se encargará de detenerla evitando el accidente y todos estaríamos muy satisfechos y orgullos de nuestro trabajo.
Pero, ¿qué ocurre si el cable que une el pulsador de parada con nuestro equipo Arduino se corta. Pues que cuando nuestro amigo vea el peligro y pulse sobre el pulsador de parada el equipo Arduino no recibirá la señal (porque el cable está roto) y no detendrá la puerta y nosotros acabaremos en el Hospital.
Para evitar este riesgo, nuestra primera solucion consiste en utilizar un contacto normalmente cerrado. De esta forma nuestro equipo Arduino necesita recibir una señal activa (un uno) en la entrada digital donde conectamos el pulsador de parada para permitir el funcionamiento de la máquina. Al actuar sobre el pulsador de parada interrumpimos el circuito, impedimos la llegada de la señal y el equipo ordenará detenerse a la puerta. Si el cable se corta, la señal del pulsador de parada tampoco llega y, por lo tanto, en caso de ruptura del cable, la máquina se para.
Sin embargo los riesgos aún contínuan. Los problemas con los cables no siempre están motivados por su ruptura. En ocasiones porque los cables están pillados o machacados por alguna máquina, o porque existen humedades y condensaciones en ciertas cajas de conexión, lo que se produce es el cortocircuito entre los dos hilos.
En estos casos, al actuar sobre nuestro pulsador de parada, el circuito no se interrumpe y el equipo Arduino no es capaz de ver la orden y, lógicamente, no ordena la parada de la puerta.
Así pues, es necesario buscar un sistema que nos asegure que en todos los casos conocemos la situación real de un pulsador y que diferencie entre pulsador abierto, cerrado, cable roto y cable cortocircuitado. Para ello, y si recordáis nuestras primeras lecciones, las entradas digitales no nos pueden ayudar. Una entrada digital sólo distingue entre dos estados posibles y aquí tenemos que distinguir entre cuatro. Por eso, las entradas analógicas deben venir en nuestra ayuda.
Para implementar nuestra solución nos vamos a basar en el esquema siguiente:
Básicamente, hemos utilizado dos entradas digitales IO2 e IO3 para manejar dos leds. De esta manera uno de ellos (D1) lo utilizaremos para mostrar la salida con la que controlamos nuestra puerta (luce cuando ordenamos detenerse a la puerta) y el otro (D2) lo utilizaremos para indicar que tenemos un problema en el cable (luce cuando el cable está mal y se apaga cuando el cable está en condiciones correctas).
También hemos conectado un terminal virtual para visualizar el valor de la entrada analógica.
Por último hemos hecho el siguiente esquema para controlar nuestro pulsador de parada. Mostramos esta parte ampliada para que se vea con más detalles y la comentamos.
Desde nuestro equipo Arduino salen los +5V hacia el campo. El cable se prolonga hasta el contacto situado en la parada de emergencia. Allí hemos hecho el siguiente montaje. En serie con el contacto colocamos una resistencia de 120 Ohms y en paralelo con el mismo otra de 220 Ohms. El cable retorna y lo conectamos a nuestra entrada analógica AD0. Además a la entrada (dentro de nuestro equipo) conectamos en ese mismo punto una resistencia de 220 Ohms a tierra. Es decir, que lo que estamos haciendo es un simple divisor de tensión que varía según que el pulsador esté actuado o no.
Además hemos añadido, con caracter pedagógico, cuatro contactos para ayudarnos a simular los posibles fallos que se pueden producir en nuestro cable. Una derivación a tierra del hilo conectado a +5V, una derivación a tierra del hilo conectado a la entrada analógica, un cortocircuito entre ambos hilos y la ruptura de uno de los hilos. De esta forma es sencillo comprobar todos los casos posibles y ver como reacciona nuestro circuito.
El programa que corre en nuestro Arduino es muy sencillo.
Primero definimos una variable que almacena la lectura analógica. Luego definimos los pines 2 y 3 como salidas y la velocidad de nuestro puerto serie a 9600 baudios. El bucle principal del programa lee el valor de la entrada analógica, lo envía por el puerto serie (hemos puesto un retardo de 0,1 segundos para no volvernos locos con tantas medidas) y luego evaluamos el valor leído. Si es menor de 350 o mayor de 700 generamos un error y activamos la salida del led D2. Si está comprendida entre 350 y 500 el pulsador está sin cerrar. Si, por último está comprendido entre 500 y 700 el pulsador está cerrado y activamos nuestra salida del led D1 (la orden de parada de la puerta).
La ejecución de este ejemplo y el estudio detallado de los valores obtenidos en cada posible situación se ven sencillamente utilizando el terminal virtual. El circuito con el interruptor cerrado se muestra a continuación. El valor leído es de 663:
El circuito con el cable cortocircuitado genera una lectura de 1023:
Por último queremos destacar el caso de que el hilo que lleva los +5V se derive a tierra. Observe que Proteus nos permite seguir la simulación. En realidad, en la vida real estaríamos cortocircuitando la fuente de +5V que alimenta nuestro Arduino y el equipo se apagaría. Por eso es necesario siempre proteger y separar la alimentación de las entradas que salen al campo, pero eso lo dejamos para otro momento. Por ahora, a los efectos de lo que nos ocupa en esta leccion nos sirve este esquema.
De esta manera terminamos con la utilización de las entradas analógicas para implementar entradas digitales con vigilancia de cable.
[Proteus versión 8.1]
En las primeras lecciones de este curso abordamos el tema de las salidas digitales. En la lección de hoy queremos profundizar y ampliar nuestros conocimientos un poco más allá. Cuando tratamos el asunto de las salidas digitales, lo hicimos siempre, por motivos pedagógicos puesto que estábamos empezando, como si en el mundo todo funcionara con tensiones de corriente contínua de 5V. Esta simplificación fue muy conveniente, pero dista mucho de ser la realidad del día a día.
La mayoría de los equipos útiles que podemos gobernar con nuestro Arduino funcionarán con alimentaciones diferentes.Si queremos controlar el motor que se encarga de la apertura y cierre de la puerta del garaje, la bomba que alimenta de agua un depósito desde el que regamos nuestra huerta, el encendido y apagado autómatico de las luces de nuestro porche, sólo por citar algunos ejemplos, la posibilidad de que estos elementos funciones con una corriente contínua de 5V es prácticamente nula. Así pues, nos tenemos que enfrentar a la problemática en la que nuestro arduino se ve obligado a gestionar elementos externos que funcionan con otras tensiones y/o que tienen un consumo de corriente más elevado que el que se puede gestionar directamente con una salida digital.
Afortunadamente tenemos a nuestra disposicion numerosas técnicas que nos permiten afrontar esta problemática eligiendo la mejor opción en cada caso para nuestro problema. El aspecto más importante que tenemos que tener en cuenta es mantener la independencia entre uno y otro circuito. Por un lado, se encuentra el circuito de mando (gestionado por nuestro Arduino y que, por fuerza, debe funcionar con las especificaciones de tensión y corriente de las placas Arduino) y por otro lado, debemos diseñar el circuito de potencia (que alimentará o dejará sin alimentación el equipo gobernado). Nuestro objetivo es interelacionar los dos circuitos, pero manteniendo aislados el uno del otro. Precisamente, el nivel de seguridad que deseemos obtener respecto al aislamiento de los dos circuito, nos determinará la solución que debemos seleccionar en cada caso.
Primera solución: Utilizar un transistor (o componente similar) para relacionar un circuito con otro.
Este es, posiblemente el caso más sencillo. Supongamos que queremos controlar con nuestro arduino, con ayuda de un interruptor, una lámpara de incandescencia que funciona a 220VAC y que consume 60W. Antes de empezar con nuestro equipo Arduino, queremos hacer aquí un inciso referente a la simulación con Proteus. La forma más gráfica de simular un circuito que alimente una bombilla de 220VAC se muestra en la imagen siguiente:
Hemos utilizado un componente del tipo LAMP (al que configuramos para que funcione a 220VAC y 50Hz) para simulara la bombilla y un componente tipo ALTERNARTOR (al que también configuramos para que funcione a 220VAC y 50Hz) para simular la alimentación de la red. En este caso hemos puesto un interruptor para encender y apagar, así el lector puede comprobar que todo funciona correctamente. Por último queremos destacar el hecho de que hemos cerrado el circuito alternador y lámpara uniendo los dos extremos a un terminal de tierra. Esto puede parecer chocante y muchos hubieran optado por cerrar directamente el alternador con la lámpara sin usar el terminal de tierra. Sin embargo, cuando se utilizan simuladores siempre es muy conveniente fijar todos los potenciales para facilitar la tarea de resolución de los circuitos al motor del simulador. Por eso es una buena práctica colocar un terminal del generador a GND. Como en Proteus todos los terminales del mismo potencial están unidos internamente, nos ha bastado con poner el extremo libre de la lámpara también unido a un terminal de tierra para que todo el circuito esté cerrado y funcione.
Si activamos la simulación, la luz debe aparecer luciendo al cerrar el interruptor.
Ahora ya podemos empezar a ver nuestro primer circuito utilizando Arduino y un transistor a la salida. Sustituyamos el interruptor por un transistor y cebemoslo con una salida digital de nuestro equipo. El montaje, muy simple para centrarnos en lo fundamental, lo hemos diseñado como sigue:
El código fuente de nuestro programa, que también es muy sencillo, lo hemos escrito como sigue:
Si ponemos en marcha la simulación y actuamos sobre la entrada digital, nuestro Arduino activará su salida y encenderemos la lámpara a 220VAC.
Acabamos de aprender la manera de gobernar un elemento que funciona con alimentaciones diferentes a la de nuestro equipo Arduino. Pero, ojo, la solución tiene limitaciones importantes. Sugongamos que el transistor se cortocircuita. En este caso, pondríamos uno de los pines de nuestro Arduino a una tensión de 220VAC y, muy probablemente, lo dejemos inservible. Por eso es conveniente, utilizar otras opciones que aislen los dos circuitos.
Segunda solución: Utilizar un relé.
La segunda solucion consiste en la utilizacióin de un relé para separar ambos circuitos. Nuestro montaje en este caso sería el siguiente:
Hemos utilizado un elemento de tipo RELAY al que hemos configurado para funcionar a 5V. Vemos que en este caso el aislamiento entre ambos circuitos está garantizado, puesto que el circuito de mando circula a través de la bobina del relé, mientras que el circuito de potencia lo hace a través de uno de los contactos libres de potencial.
Tercera solución: utilización de un optoacoplador.
En determinadas ocasiones podemos encontrar problemas para la utilización de los relés. Por ejemplo, porque necesitemos velocidades de conmutación por encima de las posibilidades de un dispositivo electromecánico como el relé. En esos casos podemos encontrar una solución en la utilizacion de un optoacoplador con un transistor de potencia a su salida. Dependiendo de los casos (voltaje y corrientes demandadas a la salida) podríamos prescindir del transistor, pero corregir nuestro circuito prescindiendo del transistor de salida no nos supondría mayor dificultad.
Veamos un esquema de este tipo de conexionado.
Hemos utilizado como optoacoplador, el componente CNY70 incluido en Proteus como un modelo activo puesto que en los objetivos de este curso habíamos fijado la intención de poder simular todos los circuitos que utilizamos utilizando Proteus. De todas formas, al lector no le resultará complicado trasladar este esquema para adaptarlo y utilizar cualquier otro optoacoplador disponible en el mercado.
Alimentamos la entrada del optoacoplador desde la salida del Arduino y cerramos el circuito con un terminal de tierra. Utilizamos la salida del optoacoplador para la alimentación del circuito de potencia con un esquema similar al que vimos en la primera de las opciones estudiadas. La diferencia entre aquella y esta, radica que el acoplamiento entre los dos circuitos se realiza en esta segunda ocasión mediante la utilización de un dispositivo óptico (el optoacoplador) que nos garantiza un alto nivel de aislamiento (del orden de los 2,5kV) entre ambos circuitos.
Con esto terminamos el repaso a las diferentes soluciones disponibles para implementar salidas de potencia en nuestros equipos arduino.
[Proteus versión 8.1]
Hasta este momento hemos visto que nuestro Arduino era capaz de saber lo que pasaba a su alrededor utilizando las entradas digitales. De esta manera podía conocer el estado de determinados dispositivos que sólo eran capaces de discernir entre dos estados: activo-desactivo (abierto-cerrado, conectado-desconectado, verdadero-falso, etc). El ejemplo más sencillo consiste en determinar si un interruptor estaba abierto o cerrado, pero existen muchos otros dispositivos disponibles que reciben el nombre de transductores (finales de carrera, células fotoeléctricas, detectores de proximidad, detectores de presión, etc).
Hay muchos otros casos en los que necesitamos saber el valor de una determinada magnitud. La distancia a un determinado lugar, la temperatura de un horno, el nivel de agua de un depósito, el voltaje de una fuente de alimentación, son algunos ejemplos. Para que nuestro Arduino pueda conocer estos valores utilizamos las entradas analógicas.
El esquema de funcionamiento de una entrada analógica es el siguiente. El transductor convierte una determinada magnitud física (distancia, calor, caudal, etc) en una magnitud eléctrica (tensión o corriente). El transductor se conecta a uno de los pines de entrada analógica de nuestro Arduino. Como las entradas analógica del Arduino sólo son capaces de leer valores de tensión comprendidos entre 0 y 5V, si el transductor suministrara otros valores diferentes necesitariamos poner entra la salida del transductor y la entrada analógica un conversor adecuado. Por último, el microprocesador incluido en nuestro Arduino dispone de una unidad de conversión analógico-digital que convierte los valores de tensión de la entrada en valores numéricos comprendidos entre 0 y 1023. El número 1023 no es una casualidad. Los conversores incluidos en el micro tienen una precisión de 10bits. Los valores posibles que se pueden obtener con 10 bits van de 0 a 1023. En la imagen siguiente se muestra un esquema de una solución completa compleja.
El termómetro (transductor) situado en el horno nos devuelve valores de corriente comprendidos entre 4 y 20mA. Cuando la temperatura es de -20°C devuleve 4mA y cuando al temperatura es de 200°C devuleve 20mA. Por eso necesitamos utilizar un conversor que pase de 4-20mA a 0-5V. Por último el conversor analógico-digital del Arduino nos devolverá valores comprendidos entre 0 (cuando la temperatura sea de 0°C) y 1023 (cuando la temperatura sea de 200°C). Conocer a qué temperatura corresponde un determinado valor que nos proporciona Arduino es sólo una cuestión de utilizar una regla de tres.
Arduino dispone de seis entradas analógicas conectadas a los pines 23 a 28 y que reciben los nombres ADC0 - ADC5.
Para poder probar una entrada analógica, la forma más sencilla es utilizar un potenciómetro haciendo las veces de un divisor de tensión. De esta manera, si conectamos un extremo a los 5V y el otro a GND obtendremos los diferentes valores posibles moviendo el potenciómetro. Veamos el esquema electrónico del montaje para esta lección donde utilizaremos el terminal virtual que vimos en la lección 4 y el montaje del potenciómetro para simular valores de tensión en la entrada analógica (en la zona inferior derecha del montaje).
La función que nos permite recuperar el valor leído en un pin de entrada analógico se llama analogRead(). Su formato es:
<valor devuelto entre 0 y 1023> = analogRead( <numEntradaAnalogica>)
Donde numEntradaAnalogica es un valor comprendido entre 0 y 5.
El código de nuestro programa es el siguiente:
El funcionamiento es muy simple. Leemos el valor de la entrada analógica 0 (la que se conecta en el pin AD0) y enviamos el valor al terminal virtual. Esperamos un segundo y volvermos a repetir el proceso. La espera de un segundo la hacemos con objeto de no estar enviado constantemente valores al terminal lo que dificulta mucho la lectura. Si ejecutamos la simulación y movemos el potenciómetro iremos obteniendo los valores calculados entre 0 y 1023 en nuestro terminal virtual.
Utilizar entradas analógicas es muy sencillo con Arduino.
Veamos otro ejemplo de utilización de entradas analógicas donde Arduino toma decisiones en funicón de los valores leídos en una entrada digital. Supongamos el ejemplo de configuración de nuestro horno que vimos antes. Imaginemos que deseamos que nuestro Arduino mantenga el horno encendido hasta alcanzar una determinada temperatura. Al hacerlo pararemos el horno. Cuando la temperatura vuelva a bajar, nuestro Arduino volverá a encender el horno. De esta forma podemos mantener nuestro horno a una temperatura constante.
El código de nuestro programa sería el siguiente:
Como se puede ver el programa es muy sencillo. Cuando la lectura analógica es menor que 300 se activa la salida digital y en caso contrario se apaga. Para comprobar el funcionamiento, simularemos la salida que acitva el horno con un led y la entrada del termómetro con un potenciómetro. La simulación se muestra a continuación. Moviendo el potenciómetro simulamos la temperatura y cuando se alcanza el valor adecuado se activa o desactiva la salida y se enciende o apaga el led.
Ya somos capaces de utilizar entradas digitales en nuestro equipo Arduino.
[Proteus versión 8.1]
En lecciones anteriores vimos que nuestro equipo Arduino era capaz de controlar diferentes dispositivos en función de la lógica de su programa. Para hacerlo utilizábamos las salidas digitales. Cuando queríamos encender un led, activábamos una salida digital y cuando lo queríamos apagar, la desactivábamos.
Al igual que sucedía con las entradas, el mundo de las salidas no acaba en lo meramente digital. Cuando necesitamos gobernar un determinado dispositivo no solo controlando que esté activado o desactivado, sino que deseamos manejar el grado mayor o menor de una determinada magnitud, utilizamos las salidas analógicas. Algunos ejemplos de utilización de las salidas analógicas son variar la intensidad luminosa para que un foco dé más o menos luz, controlar el caudal de sálida de un líquido variando el nivel de apertura de una electroválvula o modificar la velocidad de un motor.
Cuando vimos en la lección anteror las entradas analógicas, vimos que el microprocesador leía el valor de tensión que se generaba en uno de sus pines (dentro de un rango que oscilaba entre 0 y 5V) y lo traducía a valores entre 0 y 1023. En muchos microprocesadores, el procedimiento para generar salidas digitales es exactamente el contrario. Escribimos en un determinado registro un valor entre 0 y 1023 y el microprocesador se encarga de poner uno de sus pines a un valor de tensión correspondiente entre el rango 0 y 5V.
Sin embargo nuestro querido Arduino no dispone de pines de salida analogíca. Así que tiene que utilizar otra técnica diferente denominada modulación de ancho de pulso (PWM pulse width modulation). Con esta técnica se puede utilizar un pin de salida digital haciéndole funcionar como una salida analógica. La técnica consiste en generar en el pin de salida un tren de pulsos de frecuencia constante (490Hz) y de tensión igual a cinco voltios en el ciclo alto y 0 voltios en el ciclo bajo (los únicos posibles en un pin digital).
Para obtener los diferentes valores analógicos se modifica el ciclo de trabajo de la señal periódica. Si hacemos que el 0% del tiempo la señal esté en el nivel bajo y el 100% en el nivel alto, obtendremos una señal de 5V. Si hacemos que el 25% del tiempo esté en el nivel bajo y el 75% en el nivel alto, obtendremos una señal de 3,75V. Con la señal al 50% de nivel alto y bajo, tendremos una señal de 2,5V. Con la señal al 75% de nivel bajo y 25% de nivel alto, tendremos una señal de 1,25V. Y si la señal está el 100% del tiempo a nivel alto, la señal de salida será de 0V.
Ejemplo de señal con el 75% del ciclo en nivel alto que genera una salida de 3,75V.
Ejemplo de señal con el 25% del ciclo en nivel alto que genera una salida de 1,25V.
Utilizando la técnica PWM podemos tener salidas analógicas en nuestro Arduino utilizando algunos de sus pines digitales. Por ejemplo, el ATmega8 habilita la función PWM para los pines 9,10 y 11. El ATmega168 y el ATmega328P nos permite usar PWM con los pines 3,5,6,9,10 y11.
Para controlar el ciclo de trabajo de nuestra señal PWM podemos utilizar la función analogWrite(). El formato de esta función es:
analogWrite( <número pin> , <valor> )
Donde <número pin> se utilizar para seleccionar el pin en el que vamos a generar nuestra señal pwm y <valor> es un número comprendido entre 0 y 255.
Como es habitual en nuestro curso, vamos a realizar ejemplos prácticos que nos permitan aprender el funcionamiento de las salidas analógicas. Utilizaremos el siguiente circuito:
Hemos utilizado en esta ocasión el instrumento virtual osciloscopio que nos proporciona Proteus. Con este instrumento virtual podemos usar en nuestra simulación un osciloscopio como lo haríamos en la vida real. Hemos conectado el pin IO3 al primero de los cuatro canales disponibles en nuestro osciloscopio.
Nuestro primer programa va a ser muy sencillo. Simplemente crearemos una variable entera, le asignaremos el valor 100 y utilizaremos la función analogWrite() que acabamos de ver. El código completo es el siguiente:
Y el resultado de ejecutar nuestra simulación se muestra en la siguiente imagen.
Practiquemos cambiando el valor de la variable valor_salida en el rango 0 a 254 y compruebe el efecto obtenido en la salida de nuestro arduino con ayuda de nuestro osciloscopio virtual. Para un valor 200, la señal leída por nuestro osciloscopio virtual es la siguiente.
Como modificar nuestro programa cada vez, para variar la salida pvm es un poco tedioso, vamos a cambiar un poco nuestro programa para variar nuestra salida analógica en función de la lectura de una entrada analógica que iremos manipulando con ayuda de nuestro potenciómetro. El nuevo código sería:
Observe como asignamos el valor de la entrada analógica a la variable valor_salida. Como los valores de lectura analógica abarcan un rango de 0 a 1023 y las salidas utilizan el rango de 0 a 254, dividimos el valor de entrada entre 4 para obtener valores proporcionales en la salida.
El resultado de la simulación con tres valors posibles de nuestro potenciómetro se muestran en las siguientes imágenes:
En próximas lecciones ahondaremos en el uso de las salidas digitales.
[Proteus versión 8.1]
Hemos visto en las lecciones anteriores como nuestro Arduino puede interactuar con el mundo exterior recibiendo información por sus entradas digitales y generando órdenes con sus salidas digitales. A estas alturas del curso todavía las "capacidades sociales" de nuestro Arduino son muy limitadas, pero en esta lección vamos a intentar aumentar su círculo social. Las comunicaciones serie son una forma sencilla y flexible de comunicar nuestro Arduino con otros equipos. Por ejemplo con otro arduino, con nuestro ordenador personal o con cualuqier otro dispositivo que sea capaz de comunicarse por un puerto serie.
Habilitar las comunicaciones serie entre dos equipos involucra tareas referntes al hardware y al software. El hardwre posibilita el intercambio de señales eléctricas entre los dos equipos con unos valores normalizados que entienden ambos interlocutores. El software se apoya en el hardware para intercambiar información entre los equipos. Las librerías de comunicaciones serie suministradas con Arduino nos liberan de prácticamente todo el trabajo y sólo tenemos que preocuparnos de dos cosas: conectar los dos equipos en los pines correctos y utilizar las funciones disponibles para mandar las cadenas de caracteres deseadas. Sin embargo hay unas nociones básicas que nos resultarán útiles para poder solucionar problemas cuando nuestras comunicaciones fallen. Si el lector está familiarizado con las comunicaciones serie entre microprocesadores puede saltar esta introducción.
[Introducción a las comunicaciones serie]
La comunicación entre dos dispositivos se establece intercambiando cadenas de caracteres. Por ejemplo podemos querer enviar la cadena de caracteres "Saludos". Cada caracter de nuestra cadena se codifica utilizando un byte según un código que se conoce con el nombre de ASCII. Cada byte se compone de un conjunto de ocho bits distintos. El bit es la unidad mínima de información y sólo toma valores digitales (verdadero o falso). Es decir que para enviar nuestra cadena de ejemplo entre los dos microprocesadores, lo que tenemos que enviar es una "serie" de bits concreta.
Por ejemplo, para enviar nuestra cadena "Saludos" tendríamos que enviar una serie de 56 bits (7 bytes).
Las comunicaciones serie a nivel de hardware se establecen enviando cadenas de pulsos eléctricos unos a continuación de otros (en serie), cada uno de los cuales representa un bit de información. Si el nivel eléctrico del pulso es bajo, es decir su tensión es de 0V, significa que el valor de ese bit es 0. Si el nivel del pulso es alto, es decir su tensión es 5V, significa que el valor de ese bit es 1. Por lo tanto nuestra cadena de 56 bits se tiene que convertir en un tren de pulsos de niveles alto o bajo.
Muchas de las tarjetas Arduino tiene incluido un chip que se encarga de traducir los valores de tensión TTL a los niveles estándar utilizados por las comunicaciones serie que cumplen el estándar USB. De la misma forma podríamos utilizar un chip para convertir nuestro puerto serie en otro de un estandar diferente (por ejemplo RS232, CANBUS, etc). En cualquier caso el funcionamiento del software sería el mismo.
Por último, con objeto de realizar labores de sincronizacióin y de verificación de errores entre el emisor y el receptor, la cadena de bits se enmarca entre códigos de control estandarizados por el protocolo de comunicaciones (bits de arranque, bits de parada y bits de control).
[Fin de la introducción de las comunicaciones serie]
Como todo este curso lo estamos realizando utilizando Proteus como simulador, necesitamos simular de alguna manera nuestro ordenador PC realizando funciones de terminal para comunicarse con nuestro equipo Arduino. En la barra de herramientas de la izquierda seleccionamos el botón instrumentos virtuales y en la lista que aparece escogemos "virtual terminal".
Colocamos el terminal virtual en nuestro esquema y lo unimos a los terminales TXD y RXD.
El terminal TXD está unido por una resistencia al pin IO1 y el terminal RXD al pin IO2 del Arduino (los pines del puerto serie). Observar que hemos unido el terminal TXD del Arduino con el RXD del terminal y el RXD del Arduino con el TXD del terminal. De esta manera cruzada el emisor de uno se une al receptor del otro. De esta forma tan sencilla ya tenemos enlazado nuestro equipo Arduino con nuestro ordenador PC.
A continuación tenemos que escribir nuestro programa que se encargará de enviar una cadena de caracteres hacia el terminal virtual utilizando el protocolo serie.
Nuestro programa es muy sencillo. En la zona de configuración inicializamos el puerto serie para que se comunique a una velocidad de 9600 baudios. El baudio es la unidad de medida de la velocidad de las comunicaciones serie. Un baudio equivale a un bit por segundo. Y en la zona del lazo de ejecución enviamos la cadena Saludos por el puerto serie, esperamos un 1 segundo y volvemos a iniciar el ciclo. El resultado, si ejecutamos nuestro programa, tiene que ser ver en el terminal virtual una cadena de saludo cada segundo.
Si no puede ver el terminal virtual, compruebe que lo tiene activo en el menú Depuración en la opción 5. Virtual terminal.
El siguiente programa combina varios de los conceptos vistos en lecciones anteriores y utiliza variables, salidas digitales, comunicaciones serie para enviar un mensaje cada segundo, cambiar el estado de un led cada nuevo mensaje. Utilizamos un variable llamada número para hacer las funciones de contador y distinguir cada mensaje enviado.
Observe que hemos utilizado dos funciones diferentes para enviar cadenas por nuestro puerto serie. La función Serial.print(), ya vista antes, envía una cadena de caracteres o un número por el puerto serie. Sin embargo, la función Serial.println(), después de enviar la cadena de caracteres o el número por el puerto serie, envía también un código de control que genera un salto de línea. De esta forma, en este nuevo programa resulta más sencilla la lectura en el terminal virtual de la información recibida porque cada nuevo mensaje, y el contador que los numera, se muestra en una línea diferente.
La función Serial.println() nos permite enviar números con formatos diferentes (decimal, octal, hexadecimal, binario, etc). El siguiente programa muestra un ejemplo de utilización de estas posibilidades.
