Tema 0. Introducción
Hola a tod@s.
El proyecto de programación de un semáforo aúna sistemas de control, electricidad, electrónica, circuitos analógicos y digitales, programación en arduino, impresión en 3D y programación de aplicaciones móviles con appinventor.
Será un proyecto que nos permita iniciarnos en cada una de las diferentes partes del curso como preparación a proyectos de programación más complejos con partes móviles por ejemplo.
En el siguiente enlace puede descargar el documento con la hoja de seguimiento de las fases del proyecto:
En los diferentes temas iremos desarrollando los contenidos necesarios para la realización del semáforo. Desde la conexión de los componentes a las placas protoboard y arduino hasta la creación de la aplicación para android, pasando por el diseño e impresión de sencilla piezas en 3D.
Saludos,
Raúl.Tema 1, parpadeo (blink) de led con Arduino y Bitbloq
Hola a tod@s.
En este primer tema vamos a conectar nuestra controladora de arduino con el ordenador y cargaremos un sencillo programa de prueba, el blink, que hará parpadear un led.
Las controladoras de arduino UNO que vamos a utilizar tienen un led incorporado (y asociado al pin 13) que permite comprobar que el programa está funcionando correctamente sin necesidad de añadir ningún componente extra a la controladora.
El programa arduino, su entorno de programación (denominado el IDE de arduino) puede descargarse en la web: https://www.arduino.cc/en/Main/Software
Para este primer ejercicio podemos seguir los pasos de este vídeo:
Como podréis ver en el vídeo el programa blink no hace falta crearlo ya que forma parte de los programas base de ejemplo de arduino (minuto 3:45 del vídeo).
Veremos también que es imprescindible seleccionar en herramientas (Tools) la placa que estamos usando (minuto 7:00 del vídeo) y el puerto COM (minuto 7:20 del vídeo) en el que aparezca que se ha conectado nuestra placa (debe ser un puerto COM diferente al 1).
Una cosa más antes de entrar en el vídeo es que si la controladora UNO que tenemos no es la original de la marca arduino si no una clónica tendremos que instalar unos drivers tal y como explican en esta web desde la que también se pueden descargar para los diferentes sistemas operativos: https://www.geekfactory.mx/tutoriales/tutoriales-arduino/driver-ch340-para-arduino-chinos-o-genericos/
USANDO BITBLOQ 2:
Gran parte de la programación para arduino que haremos será utilizando Bitbloq 2, el entorno de programación por bloques para arduino que ha creado la empresa BQ. Gracias a bitbloq simplificaremos la parte un poco más farragosa de evitar cometer errores de escritura al realizar nuestros programas y podremos centrarnos en la parte lógica y de programación de algoritmos, lo que se denomina la parte de pensamiento computacional.
Para utilizar bitbloq tendremos que registrarnos en su web: https://bitbloq.bq.com/#/
En el siguiente vídeo tenemos una explicación bastante detallada de los primeros pasos para enceder un led con bitbloq. Aunque en el vídeo utiliza la placa zumkit de bq en bitbloq se puede seleccionar también la genérica arduino UNO.
Algo importante a la hora de cargar programas en arduino usando bitbloq es que debemos tener instalado el componente web2board en nuestro ordenador. Si no lo tenemos instalado bitbloq nos avisará y nos pedirá que lo descarguemos e instalemos. Por otro lado, si lo tenemos instalado, nos saltará una ventana pidiendo que abramos en una nueva ventana una consola de MSDOS donde se ejecutará este componente. Es imprescindible decir que sí a esta pregunta y no cerrar la consola de MSDOS durante el tiempo que estemos trabajando con btibloq.
El vídeo anterior pertenece a una serie de vídeos para iniciarse en bitbloq 2. Aquí podéis ver el vídeo presentación del curso:
Una vez que ya sabemos como encender un led con bitbloq será bastante fácil usando los bloques realizar el programa blink para que el led se encienda y apague.
En el siguiente tema veremos como conectar a nuestro arduino los diferentes componentes electrónicos de nuestro proyecto de semáforo.
Un saludo,
Raúl.
Tema 2, conexiones protoboard y arduino
Hola a tod@s.
En este tema haremos una recopilación de imágenes y algún vídeo explicativo sobre la conexión de los componentes para nuestro proyecto del semáforo.Para poder hacer este proyecto necesitaremos por un lado conectar los leds:Tal y como dicen en esta web:
"Hay dos tipos de personas, los que conectan los LEDs con resistencia y los que no… y solo una de ellas lo está haciendo bien."
Es por eso que nosotros lo vamos a hacer bien, es decir, con resistencia.Para recordar el código de colores de la resistencia podemos usar estas imágenes en función de que lleve 3 o 4 lineas de colores + la tolerancia.
A continuación tendremos que conectar el zumbador:
El siguiente componente que tendremos que conectar es el LDR, la resistencia variable que nos permitirá saber si es de día o de noche.Para profundizar más sobre la conexión del LDR y entender porque se conecta de esta manera mediante un divisor de tensión es muy práctica la información de la siguiente web.
El último componente que será necesario conectar es el pulsador:
Conectar los componentes es una fase que parece que tiene menor importancia que la de programar, pero sin duda es realmente importante prestar la máxima atención y entender porque se conectan los componentes de esta manera para evitar fallos que puedan dañar a la placa o los componentes y además nos puedan hacer dar mil vueltas a la programación sin darnos cuenta de que el problema no es de código si no de instalación y conexión.Un saludo,Raúl.Tema 3, programación del semáforo usando la función Esperar / Delay
Hola a tod@s.
Una vez que ya hemos sido capaces, por un lado en el tema 1, de hacer parpadear un led cargando el programa blink de arduino o programándolo nosotros mismos en bitbloq y, por otro lado en el tema 2, de conectar todos los componentes necesarios mediante resistencias y la placa protoboard, en este tercer tema vamos a aprender a programar un semáforo con la siguiente secuencia de encendido de luces:
Estado de la luz de los coches Estado de la luz de peatones Tiempo de duración
VERDE ROJO 8s
ÁMBAR ROJO 4s (en los 2 últimos segundos la luz ambar de coches deberá parpadear 4 veces)
ROJO VERDE 6s (en los 2 últimos segundos la luz verde de peatones deberá parpadear 4 veces)
Para ello será necesario conectar correctamente 5 leds a nuestra controladora (recordar que siempre hay que dejar libres los pines 0 y 1 que son los necesarios para comunicarnos con la placa y cargar los programas por ejemplo) en los pines que después serán los mismos que usaremos en bitbloq para indicar la ubicación de nuestros leds tal y como puede verse en el ejemplo de la imagen.
.
Posteriormente pasaremos a la programación de la secuencia de encendido utilizando la función <esperar> o <delay> en inglés. Un ejemplo del código puede verse en la siguiente imagen.
En el próximo tema veremos como programar la secuencia de encendido sin usar la función esperar, programación mucho más avanzada pero imprescindible para que nuestra controladora no tenga momentos de esperar en los que la programación y los sensores por ejemplo no responderían.
Un saludo,
Raúl.
Tema 4, programación del semáforo usando Tiempos de Ejecución
Hola a tod@s.
En la parte de programación vamos a dar el salto de usar la función ESPERAR de Bitbloq a programar usando <Obtener tiempos de ejecución>, lo que nos permite tener un mayor control sobre el programa ya que la función esperar bloquea la programación y por tanto la recepción de información por parte de sensores o el control de las respuestas del semáforo.
Seguimos avanzando en el proyecto de programación en arduino, fabricación de maqueta y aplicación móvil de control de un semáforo.
Este nivel de programación nos llevará a trabajar con las diferentes opciones de código de arduino. Por un lado la Declaración de Variables, por otro Las Instrucciones iniciales (Setup) que se ejecutan una sola vez al iniciar el programa y por último el Bucle principal (Loop) en el que desarrollaremos la parte central del código que se repite en modo Loop.
A continuación dejamos las imágenes de una de las opciones de programación en bitbloq del semáforo en modo sencillo, alternando de rojo durante 8 segundos, a ámbar durante 4 segundos y por último a verde durante 6 segundos usando <Obtener tiempo de ejecución>.
En esta opción de programación se juega con las variables TIEMPO y TIEMPO_RESET para crear un ciclo de 18000ms en el que se van secuenciando las luces:
Otra opción es utilizar variables de estado que nos indiquen que luz está encendida y con esa variable de estado y el control del tiempo poder decidir cuando apagarla y encender la siguiente. En este código ya aparece la secuencia correcta verde coches (rojo peatones) - ambar coches (rojo peatones) - rojo coches (verde peatones):
Existen más soluciones como la de usar un contador que vaya aumentando cada 1000ms... Lo fundamental es dar el salto a programar usando los tiempos de ejecución del programa y así evitar usar la función delay/esperar.En el siguiente tema profundizaremos en la programación incluyendo los parpadeos, y algunos otros componentes al semáforo.
Un saludo,
Raúl.Tema 5, parpadeo de la luz ambar, y verde peatones
Hola a tod@s.Un siguiente paso es el de crear un parpadeo. En las siguientes imágenes puede verse como incluir las luces de peatones y el parpadeo. Para el parpadeo creamos dos nuevas variables, una de estado de parpadeo y otra de tiempo de parpadeo.En estas primeras imágenes vemos que usando las variables de estado de las luces para los coches podemos ir añadiendo las luces de peatones ya que hay una relación directa entre lo que hacen unas y otras.La siguiente fase del programa consistirá en mantener el mismo juego de luces, parpadeo y añadir el sonido controlador por un LDR.
Parpadeo del ambar del coches:
Parpadeo del verde de peatones:
Un saludo,Raúl.Tema 5b, Sonido en el semáforo, control con LDR
Hola a tod@s.
El siguiente paso de este modo es el de añadir el sonido del zumbador a la programación. En esta imagen puede verse la parte de código correspondiente al apagado y encendido del zumbador. En la siguiente imagen puede verse que añadimos en arduino el zumbador como un led ya que queremos controlar su encendido como con los parpadeos usando <obtener tiempo de ejecución>.
Recordar que en el tema 2 está la imagen de como se conecta un zumbador a la protoboard y a arduino.Por tanto el código de sonido intermitente será similar a los que ya hemos visto de parpadeo.
Por último para evitar que el zumbador pueda quedar activado en caso de que la luminosidad baje cuando está sonando hemos añadido una condición al inicio del programa.
Tendremos que añadir un LDR.
Recordar que en el tema 2 está la imagen de como se conecta un LDR a la protoboard y a arduino.
Finalmente para programarlo tendremos que crear una nueva variable, en el ejemplo llamada "luminosidad" que guardará el valor del LDR en cada momento y lo incluirá como condición para que el sonido se produzca solo de día, ya que de noche podría ser excesivamente molesto.En el ejemplo el valor de luminosidad que marca el cambio de día a noche es que el sensor de un valor de más de 40. Este valor no es fijo, dependerá de la resistencia que pongamos.
En el ejemplo el valor de luminosidad que marca el cambio de día a noche es que el sensor de un valor de más de 40. Este valor no es fijo, dependerá de la resistencia que pongamos y de la sensibilidad del LDR que estemos usando. En un futuro aprenderemos a ajustarlo con nuestro teléfono móvil, pero de momento aprenderemos a obtener este valor usando la información que arduino puede enviar al monitor serie mediante el puerto serie.
Primero tendremos que añadir el puerto serie como componente.
Posteriormente en la programación añadir el envío de los datos que necesitemos al puerto serie:
Y por último, tras cargar el programa en placa, abrir el monitor serie para comprobar los resultados.
En el siguiente tema profundizaremos en la programación incluyendo los parpadeos, y algunos otros componentes al semáforo.
Un saludo,
Raúl.Tema 5, Soluciones
Hola a tod@s.Solución al programa más básico de funcionamiento sin parpadeos ni sonido, simplemente la alternancia entre las luces:Un siguiente paso es el de crear un parpadeo en la parte final del encendido del semáforo de peatones. En la siguiente imagen puede verse como entre los 3000 y 6000 milisegundos de encendido del verde peatones (rojo coches) se hace parpadear la luz verde de peatones.
El siguiente paso de este modo es el de añadir el sonido del zumbador a la programación. En esta imagen puede verse la parte de código correspondiente al apagado y encendido del zumbador.
Por último para evitar que el zumbador pueda quedar activado en caso de que la luminosidad baje cuando está sonando hemos añadido una condición al inicio del programa:
La siguiente fase del programa consistirá en mantener el mismo juego de luces, parpadeo y sonido pero en el modo "peatón pulse".Un saludo,Raúl.Tema 6, programación del semáforo en modo "Peatón pulse"
Buenos días.
En esta entrada veremos como realizar el programa de control del semáforo mediante un botón.Recordamos la imagen del tema 2 que nos mostraba como conectar el pulsador a arduino mediante una protoboard:
El último componente que será necesario conectar es el pulsador:
Con los componentes correctamente conectados iremos a bitbloq para indicar en que pin está conectado y programarlos. Si tenemos programado el semáforo mediante tiempos de ejecución será realmente sencillo el paso a uso mediante botón.
Primero será necesario añadir una variable más para guardar el estado del botón.
Posteriormente tendremos que detectar si el botón ha sido pulsado y cambiar la variable. Colocamos un mientras en ese condicional para que el programa no avance hasta que el botón no haya sido dejado de pulsar.
Por último en el momento en que el semáforo tiene que dejar de estar en verde añadimos una opción más que es que la variable botón esté a 1. En ese momento deberemos volver a ponerla a 0.
Un saludo,
Raúl.Tema 7, maqueta semáforo e impresión en 3D
Buenos días.
Con toda la parte de programación y electrónica funcionando perfectamente vamos a dar el paso de llevarlo todo a una maqueta. Es importante no solo trabajar la parte abstracta y lógica de la programación y conexiones si no también la creativa de diseño de la maqueta y manipulativa de fabricación de la misma.
Como ejemplos de posibles soluciones presentamos estos dos vídeos, con un primer ejemplo de una solución sencilla pero que responde perfectamente a un trabajo limpio y bien acabado.
O esta otra en la que podemos ver un proyecto mucho más desarrollado.
Como curiosidad este otro vídeo en el que podemos ver todo el complejo circuito que maneja la maqueta de control de semáforo que seguro nos hará valorar mucho más el enorme potencial que tiene una "sencilla" placa de arduino con la que podemos conseguir mismo resultado o incluso superior.
Con el fin de comenzar a trabajar la impresión en 3D se valorará que la maqueta tenga algún componente impreso en 3D por nosotros mismos. Puede ser un componente descargado de internet en formato STL y después generado el archivo GCODE por nosotros mismo en el taller. Aquí tenéis algunos ejemplos:
O un STL descargado de internet y editado y modificado o incluso, porque no, íntegramente diseñado y fabricado por nosotros mismos.
Los programas que en principio vamos a usar para editar y generar archivos STL sono la nueva versión online de Sketchup:
En caso de trabajar con la versión de Sketchup de escritorio, para poder guardar los archivos de Sketchup en formato STL es necesario tener instalada esta extensión y seguir los sencillos paso de exportación que se indican.
Los archivos GCODE los generaremos con el programa CURA que tenemos instalado en el taller en el ordenador junto a la impresora en 3D, el modelo que tenemos en el taller es la WITBOX 2, una fantástica impresora en 3D que conseguimos el año pasado gracias a clasificarnos al concurso Retotech.
Un saludo,
Raúl.Tema 8, conexión Arduino - Teléfono mediante aplicación de AppInventor y bluetooth
Buenos días.
En esta entrada vamos a dar los primeros pasos para conectarnos a la placa mediante el móvil usando el dispositivo bluetooth HC-06.
Lo primero será cambiar el nombre por defecto (HC-06) y el pin (1234) del dispositivo bluetooth. Para ello hay que usar el siguiente programa de arduino. Deberemos editarlo, cambiar los datos de la variable NOMBRE y PIN, conectar el bluetooth en los pines 2 (RX) y 3(TX) de nuestra placa y subir el programa a la placa.
El siguiente paso será sincronizar el módulo bluetooth con nuestro teléfono móvil, activando el bluetooth del teléfono, buscando el dispositivo por su nuevo nombre y sincronizando con el nuevo pin.
(En esta entrada del blog tenéis más información sobre la conexión vía bluetooth.)
Una vez sincronizado el dispositivo pasaremos a crear la aplicación con AppInventor. Para usar AppInventor es necesario tener una cuenta de gmail. AppInventor pedirá acceso directo a la cuenta de gmail, es por eso que recomiendo que creéis una solo para trabajar con esta web. Para simplificar los primeros pasos de conexión podéis importar este programa en el que ya están creados el ListPicker de conectar y el botón de desconectar. Podéis descargarlo en vuestro ordenador y una vez dentro de appinventor importar el archivo .aia de proyecto.
A este programa básico habrá que añadirle en un principio dos botones: Encender y apagar, que manden vía bluetooth información para que luego arduino la use para realizar las acciones de encender y apagar un led. En principio una forma sencilla de hacer esto es enviar las letras A para el encendido y B para el apagado.
Cuando tengamos terminada la aplicación debemos instalarla en el móvil, para ello hay que descargarla mediante el código QR o descargar el archivo .apk en el ordenador y enviarlo por mail al móvil o si lo conectamos con el cable usb al ordenador copiando y pegando el archivo. La opción de usar el código QR es muy cómoda. Una de las mejores aplicaciones gratuitas para leer códigos QR es QR Code Reader.
Solo nos queda programar la placa para que reciba la información del bluetooth. Para ello vamos a usar bitbloq y de momento hasta que veamos como usar el componente Bluetooth de bitbloq, las conexión vía bluetooth las vamos a realizar con el componente Puerto Serie. Es importante confirmar que el Baudrate del puerto serie es el mismo que el del bluetooth, en principio 9600 por defecto en los módulos HC-06.
Lo siguiente será programar los componentes. Para ello usaremos una variable "datos" que recibe la información del bluetooth y la almacena. Cuando la variable contenga algún dato (longitud>0) comprueba si es A o B para encender o apagar el led y a continuación borra el dato de la variable,
Es importante tener en cuenta que al usar el puerto de serie para las conexiones bluetooth será necesario conectar los pines TX y RX del módulo bluetooth a los pines 0 y 1 de arduino respectivamente (van cruzados el TX del bluetooth al RX de la placa que es el 0 y el RX del bluetooth al TX de la placa que es el 1) pero en el momento de cargar programas en la placa será necesario desconectarlos. Podemos mantener conectados los pines de Vcc y GND y por tanto seguir conectados al módulo con el móvil si ya está conectado. Una vez cargado el programa volveremos a conectar los pines del bluetooth a la placa para que la información que enviamos por el teléfono llegue hasta ella.
Una vez realizado este sencillo programa y comprobado que somos capaces de comunicarnos entre el teléfono móvil y la placa empezaremos a desarrollar la aplicación específica para el control del semáforo que deberá realizar al menos las siguientes funciones:- Encender y apagar el semáforo
- Cambiar de modo secuencia a modo botón
- Cambiar a modo ámbar parpadeando
- Permitir cambiar los tiempos de espera de cada fase: rojo, ámbar y verde
- Permitir activar y desactivar el sonido del zumbador
- Recibir la información del sensor de luz en el móvil
- Permitir variar el valor que determina si es de día o de noche
- Alguna otra opción de creación propia
En el siguiente enlace tenéis la hoja de seguimiento de esta fase del proyecto:
Con esta parte terminada concluiremos este primer proyecto del semáforo en el que hemos podido trabajar: electrónica digital, analógica, programación, impresión en 3D, realización de proyectos, aplicaciones móviles y conexiones inalámbricas. Todo esto formará la base para los proyectos que realizaremos en la segunda parte del curso.
Un saludo,
Raúl.Tema 8b. Bluetooth configuración y conexión
Hola a tod@s.
En esta entrada voy a resolver varias dudas sobre el bluetooth: como probar los programas sin necesidad de usar el bluetooth y como configurar y solucionar los problemas más comunes con el bluetooth.
Probar la programación de bitbloq o arduino sin usar el bluetooth
Esta es una opción muy interesante si creemos que el bluetooth nos está dando problemas y aún así queremos programar con bitbloq y probar el resultado de nuestros programas.
La solución es mandar las ordenes a la placa mediante el Serial Monitor de la pestaña Ver de bitbloq (opción Mostrar Serial Monitor). Desconectamos completamente el bluetooth de la placa y teniéndola conectada con el cable usb al ordenador podemos dar las ordenes correspondientes desde el Serial Monitor, simplemente hay que tener el cuidado de poner el Baudrate que hayamos puesto al componente Puerto Serie (que en principio para la placa UNO debería de ser 9600).
Desde el puerto de serie podemos mandar las letras o textos que hayamos predefinido para mandar las ordenes desde appinventor a bitbloq. Escribiremos A y le damos al botón de enviar si es ese el mensaje que queremos probar o cualquier otro. Para poder hacer esto hay que colocar el robot de manera que las ruedas no toquen el suelo ya que lo tendremos conectado al ordenador con el cable. No servirá por tanto para verlo en movimiento pero si para ver la respuesta de la programación a la entrada de comandos.
Dos consideraciones importantes para usar el Serial Monitor de esta manera:
- Hay que asegurarse de que el bluetooth no está conectado a la placa y que no están ocupados los pines 0 y 1 por ningún otro componente, ya que el puerto serie usa esos pines para enviar y recibir datos. (Esto también es imprescindible para cargar programas en la placa).
- Es necesario tener el interruptor encendido y por tanto las pilas alimentando a la controladora de motores, ya que aunque por el USB le llega corriente a la placa y resto de componente no es suficiente como para hacer girar los motores.
Cambio de nombre, pin y baudrate del bluetooth
Para ello es necesario conectar el bluetooth a los pines 2 y 3 de la placa. El RX debe conectarse al 3 y el TX al 2. Por otro lado el GND (ground) debe estar conectado a cualquier pin de G de la placa (normalmente lo ponemos al de G del pin 0 de la placa) y VCC a cualquier pin V de la placa (igualmente lo solemos dejar siempre en el V del pin 0).
A continuación descargamos el siguiente programa de arduino y lo abrimos con arduino.De este programa lo más importante son las siguiente líneas de código:SoftwareSerial blue(2, 3); //Crea conexion al bluetooth - PIN 2 a TX y PIN 3 a RX
char NOMBRE[21] = "PALBOT"; // Nombre de 20 caracteres maximo
char BPS = '4'; // 1=1200 , 2=2400, 3=4800, 4=9600, 5=19200, 6=38400, 7=57600, 8=115200
char PASS[5] = "1999"; // PIN O CLAVE de 4 caracteres numericos
En la primera nos recuerda donde hay que conectar los pines RX y TX tal y como ya hemos explicado. Las otras 3 líneas servirán para poner el nombre, baudrate y pin a la placa. El nombre sera PALBOT y el número correspondiente que hemos ido asignando, el PIN ya está puesto el 1999 y el baudrate dejamos de momento el 9600 (opcion 4 tal y como está) ya que parece que funciona bien con este módulo bluetooth. Así que solamente habría que añadir el número correspondiente después de la T de PALBOT.
Una vez cambiados el nombre y pin cargamos el programa en la placa (recordar que hay que marcar el puerto COM correspondiente en herramientas) y si aparece el mensaje "subido" ya habremos conseguido cambiar el nombre y el pin. Ahora tocará buscarlo con el movil y sincronizarlo antes de poder usarlo con la aplicación de appinventor.
Recordar que siempre para cargar programas hay que asegurar de que los pines 0 y 1 de la placa están libres (podemos dejar conectados cables a la parte de V y G, de tensión y tierra/ground pero no al pin de señal) y que después para que el módulo bluetooth funcione hay que volver a ponerlos.
Un saludo,
Raúl.Tema 9, control sencillo mediante el móvil de apagado / encendido del semáforo
Buenos días.
En las siguiente entradas vamos a ir incorporando a nuestro programa de arduino de control de un semáforo el código necesario para controlarlo desde el móvil.
En estas dos entradas previas se puede ver como fuimos programando el arduino para controlar el semáforo:En esta primera entrada comenzaremos por añadir al programa más sencillo de semáforo, en el que se iban encendiendo las luces de manera secuencial (sin usar la función esperar, todo mediante el uso de tiempos de ejecución), la opción de apagar o encender el semáforo o de ponerlo en modo ámbar intermitente.
Sobre este programa de base vamos a añadir el código que nos va a permitir manejarlo desde el teléfono. Previamente tendremos que haber creado una aplicación con appinventor que envíe mensajes a nuestro arduino. En la entrada anterior del blog vimos como crear una aplicación sencilla que permitía enviar una A y una B. Para poder añadir el modo ámbar intermitente o modo de emergencia del semáforo deberemos añadir un tercer botón que envíe por ejemplo la señal C.
Una vez confirmado que tenemos el componente puerto serie en bitbloq y el Baudrate del mismo coincidiendo con el del bluetooth (en nuestro caso 9600), lo primero que deberemos programar en bitbloq son las nuevas variables que vamos a utilizar:
Como veis hemos añadido dos variables. La variable "datos", de la que ya hablamos en la entrada anterior, que usaremos para guardar el texto que llegue vía bluetooth. Y la variable MODO, que indicará el modo de funcionamiento del semáforo. De momento tendremos tres modos de funcionamiento. 0 cuando este apagado, 1 para modo normal en secuencia de colores y 2 para el modo ambar parpadeante.
En la imagen anterior puede verse también que en el apartado Setup de instrucciones iniciales comenzamos por defecto con el MODO 1 de funcionamiento normal del semáforo.
Al comienzo del bucle principal LOOP añadiremos las opciones para que en función de la letra recibida el programa cambie de un MODO a otro.
Vamos a ver que hace cada una de las opciones:Si recibe una A, el semáforo pasa a modo normal (secuencia de encendidos) volviendo a comenzar como en las instrucciones iniciales por el rojo. Añadimos aquí que A_on y V_on pasen a ser 0 para asegurarnos que volverá a empezar de nuevo solo con una de las tres variables en 1, la de R_on.Si recibe una B, el semáforo pasa a modo apagado. Enviamos señal de apagado a los tres leds y pasamos las tres variables a 0.Si recibe una C el semáforo pasa a MODO 2, enciende solo el ámbar poniendo solo A_on a 1 y tomar el tiempo de ejecución como momento de encendido del ámbar.El MODO 0 no necesita más programación el semáforo estará apagado hasta que enviemos alguna otra señal.El MODO 1 es muy sencillo, simplemente tendremos que incluir todo el código que manejaba antes el semáforo dentro de esta opción como puede verse en la siguiente imagen:
Y por último programamos el MODO 2 de la siguiente manera:
Con esto conseguiremos un parpadeo de tiempo de encendido y apagado de 500ms en cada caso sin usar la función esperar que bloquearía el programa y dificultaría el envío de datos vía bluetooth.Como veis un programa ya de un nivel muy interesante en el que empezamos a trabajar con las variables y los condicionales de manera ordenada. Siguiendo esta misma dinámica podremos ser capaces de ir añadiendo a este programa el resto de opciones que proponíamos en la entrada anterior:En la siguiente entrada veremos como implementar algunas de ellas.Un saludo,Raúl.Tema 10, control de los tiempos de encendido del semáforo
Buenos días.
Seguimos trabajando con nuestro semáforo, ahora controlando sus funciones desde el móvil. La siguiente función de control que vamos a implementar es la del tiempo de duración de los encendidos. Existen muchas manera de hacerlo y una de las más sencillas es la que os propongo en esta entrada: Utilizando un dos botones para cada luz, uno para aumentar el tiempo de encendido y otro para disminuirlo.
Empecemos con la aplicación móvil en App inventor, Vamos a añadir 3 layouts, uno para cada luz, con dos botones y una etiqueta en cada uno. Podéis ver el resultado en la siguiente imagen.
La programación de los elementos es sencilla pero incluye algunos elementos que no hemos visto hasta ahora: Creación de variables en app inventor (initialize global), realización de operaciones matemáticas con las variables y modificación del contenido de cuadros de texto usando la función "join".
Como podéis ver hemos añadido un condicional en cada botón para que el tiempo nunca sea menor que 1 segundo ni mayor de 30.
Una vez hecho para una de las luces copiamos y pegamos los bloques para las otras dos, cambiando la letra de envío por bluetooth y las variables:
Como os habréis dado cuenta no enviamos por bluetooth al arduino el valor del tiempo de las variables de app inventor, seguimos enviando solamente una letra diferente para cada operación que después en el código arduino nos indicará lo que tenemos que hacer con las variables de arduino, que será una réplica de lo que hemos hecho en app inventor. Por supuesto que existe la posibilidad de mandar variables por bluetooth con los datos del tiempo pero esto complicaría un poco más la programación ya que la señal de bluetooth además de la nueva cifra debería indicar para cual de las luces se ha realizado el cambio. Esto se realiza creando cadenas en el mensaje de bluetooth con diferentes partes que después en arduino fragmentamos y obtenemos la información correspondiente. Lo veremos más adelante en otras entradas, pero de momento en esta probaremos a programarlo de esta sencilla manera, cambio el valor de la variable en app inventor e indicando una simple letra como señal a arduino.
Pasamos a la programación en arduino que es más sencilla todavía:
Por un lado tenemos que crear 3 nuevas variables que comienzan con el valor que hayamos puesto en appinventor que dura cada fase del encendido, en el ejemplo 5000ms (5 segundos), ya que en appinventor hemos puesto que empiecen con un valor de 5 los segundos:
En función de la letra que recibamos por bluetooth iremos añadiendo o quitando 1000ms a cada una de las variables. Como veis aquí también controlamos que la variable no baje de 1000ms ni suba de 30000ms. Existen formas mucho más eficientes de programar esto, pero de momento para ir aprendiendo, programarlo en cada apartado, creo que es una buena manera de iniciarse en las operaciones matemáticas con variables y los condicionales.
Y por último no debemos olvidar sustituir en nuestro programa los tiempos de espera que teníamos por las variables que hemos creado.
De esta sencilla manera podemos ir controlando muchos otros parámetros como por ejemplo el tiempo de encendido y apagado de emergencia o cualquier otra que necesitemos. Un buen ejercicio ahora sería intentar controlar algún parámetro programando todo por vuestra cuenta.
Un saludo,
Raúl.Tema 11, control del modo de funcionamiento del semáforo
Hola a tod@s.
En este tema vamos a añadir a nuestra aplicación la posibilidad de controlar desde el móvil el cambio de modo de funcionamiento del semáforo entre funcionamiento "peatón pulse" al que hemos llamado modo botón y el funcionamiento secuencial normal de las luces o modo secuencia.
También añadiremos dos botones para activar o desactivar el sonido del zumbador cuando el semáforo de los coches está en rojo que sería la señal acústica que indicaría que podríamos pasar.
Dejaremos para a próxima y última entrada sobre este proyecto el control del LDR desde el móvil que nos permitirá desactivar automáticamente el sonido cuando es de noche por ejemplo.
Empezamos por mostrar en la siguiente imagen el aspecto de la aplicación con estas dos funciones incorporadas. La estética sigue siendo bastante sencilla ya que de momento lo que estamos priorizando es el funcionamiento de la aplicación.
Los cuatro botones que hemos añadido tienen una programación realmente sencilla en app inventor que puede verse en la siguiente imagen. El modo secuencia manda por bluetooth la señal G, el modo botón la J, el apagado de sonido la L y el encendido la K.
Para poder usar el zumbador sin tener que dejar bloqueado el programa durante el tiempo en que está sonando una buena opción es cambiar el elemento de programación zumbador por un led (en la imagen led_zumbador) que nos permitirá activar o desactivar el pin al que se encuentra conectado el zumbador a la placa.
En la parte de bitbloq usaremos nuevas variables para gestionar la activación o desactivación del modo botón por un lado y del sonido por otro. Al recibir las letras correspondientes estas variables irán cambiando de valor:
Posteriormente estas variables serán las encargadas en nuestro código de hacer que el semáforo tenga que esperar a que se pulse el botón para cambiar o no:
O de que suene de día o no:
Con todo esto ya tendríamos prácticamente terminadas las diferentes fase de control que se habían planteado en la hoja de seguimiento del proyecto de control de semáforo por bluetooth.
En la próxima entrada veremos los puntos referentes a la señal LDR que nos permitirán recibir en el móvil los datos del sensor de la placa y actuar desde el móvil sobre ella.
Un saludo,
Raúl.
Tema 12, recepción de datos en el teléfono y control de la variable del LDR de cambio a modo noche
Hola a tod@s.En este tema terminaremos el proyecto del semáforo cubriendo todos los pasos que nos habíamos propuesto al inicio del mismo.Para poder controlar que el sonido del semáforo se apague por la noche vamos a recibir en el teléfono móvil la información del LDR enviados desde arduino y mediante un botón de la aplicación podremos asignar en cualquier momento ese valor al cambio entre día y noche. El valor inicial para diferenciar el día y la noche es de 40.Empezando por app inventor, será en la aplicación será necesario añadir un reloj. Este componente se añade como el bluetooth y el notifier, no se genera ningún elemento visible en la aplicación pero podremos usarlo para controlar cada cuanto tiempo queremos recibir la información vía bluetooth. Como puede verse en la imagen el tiempo asignado ha sido de 100ms. Podría haber sido menor (incluso 0ms) o mayor. Esto simplemente cambiaría el tiempo con el que se recibirán nuevos datos.
El siguiente paso en app inventor será programar la recepción de información. Que esos nuevos datos aparezcan en el label de información del LDR y que al pulsar el botón para asignar ese valor a la noche, ese valor quede registrado en el label correspondiente.
En arduino la parte de programación no es complicada. Podríamos prácticamente enviar mediante una línea el envío de datos pero para que el envío y recepción de los mismos pueda verse mejor y con el fin de aprender a controlar también el tiempo de envío, hemos programado que se envíe un dato desde la placa cada 500ms.Para ello primero se han creado tres nuevas variables: noche, LDR y tiempo. (es importante recordar que si hemos llamado LDR al componente no podemos llamar LDR a la variable ya que no se pueden tener dos cosas con el mismo nombre. En nuestro caso el componente se llama LDR_elemento).
Una vez creadas las variables realizamos el envío cada 500ms con el siguiente código al principio del bucle principal. Como puede verse en la siguiente imagen, tenemos que crear una variable de tiempo diferente y específica para el envío de datos cada 500ms, en este caso la hemos llamado "tiempo_envio_ldr".
Con esto habremos conseguido algo que no habíamos probado hasta ahora: enviar datos desde arduino a nuestro teléfono, ya que de momento solo enviábamos datos desde app inventor a arduino.Por otro lado cuando en arduino recibamos la letra Z, que es la que en appinventor hemos asignado al botón de cambio del valor del LDR, deberemos indicar que la variable noche cambie del valor que tiene por defecto (en nuestro ejemplo 50) por el valor que tenga el LDR en ese momento.
Ahora será necesario poner la variable noche en el lugar en el que antes poníamos ese valor de 50 como valor fijo para indicar cuando era de día y cuando era de noche para activar y desactivar el sonido:
En algunos casos el orden de encendido de las luces del semáforo puede que no sea el correcto. Es importante recordar que hay que dejar la secuencia de encendido tanto en modo secuencia como en modo botón. Dado que es un semáforo de coches la secuencia correcta es verde - ambar - rojo - verde. Ya que el ambar se enciende antes del rojo para que los conductores tengan tiempo de frenar antes de que cambie a rojo.Con la secuencia correcta quedaría así:
Con todo quedaría mucho por mejorar en la estética de la aplicación que ha quedado con un diseño bastante funcional para básicamente poder probar que toda la programación funciona correctamente.
Un saludo,Raúl.Tema 13. Imágenes de la programación final comentada
Hola a tod@s
En las siguientes imágenes vamos a ver los archivos finales de la programación de Appinventor y Bitbloq del semáforo comentadas.
Por un lado la parte de diseño de Appinventor
Nos fijamos en el detalle de que el clock está configurado cada 100ms de manera que esa será la velocidad de envío de datos. (después veremos que bitbloq recibe cada 500ms)
Y por otro la parte de bloques de programaciónY finalmente toda la secuencia de programación en bitbloq comentando el contenido de cada parte:
Un saludo,
Raúl.
No hay comentarios:
Publicar un comentario