consultas@firtec.com.ar
Por cuestiones de trabajo suelo ausentarme de mi casa y a pesar de tener sistemas de cámaras uno no siempre esta viendo el móvil para saber que esta pasando es por eso que se me ocurrió un pequeño sistema que conectado a las puertas de acceso me envía un mensaje por Telegram avisando de que tal puerta se ha abierto o cerrado.
El sistema tiene ademas una interfaz web para cambiar la configuración por ejemplo la red Wi-Fi o las credenciales Telegram, para esto un pequeño botón que al ser accionado borra el archivo de configuración y envía un reset a la placa que inicia en modo setup.
Desde luego que para todo esto tenemos que tener instalado en el móvil la aplicación de Telegram.
Lo primero que hacemos es crear un grupo dentro de Telegram y luego mediante el BotFather creamos un bot que agregamos al grupo creado.
El proceso de crear un bot es muy sencillo y la propia aplicación te guía de como hacerlo con el comando /newbot. Pero lo importante aquí es el Token, algo parecido a esto 123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11 este será el ID del bot y lo necesitará para configurar el acceso y poder enviar mensajes al bot.
Lo siguiente es obtener el ID del usuario, es importante que este bot este agregado al grupo, luego desde un computador enviamos un mensaje al bot y tomamos nota del número ID que aparece en la barra del navegador.
Observe la siguiente imagen donde se puede ver el nombre de mi bot y el ID correspondiente (no olvide el signo menos).
Tenemos los datos necesarios para conectar con Telegram y el bot, ahora solo necesitamos un programa en Pico W que haga el trabajo.
La aplicación que construí puede funcionar de dos formas.
Modo Usuario: Controla el estado de las puertas asignadas.
Modo Programación: El sistema crea una red Wi-Fi propia abierta con el SSID firadmin. En esa red se accede http://firtec.net que básicamente es una página de configuración donde se cargan las credenciales de acceso tanto a la red Wi-Fi adonde se conectará Pico W como las credenciales de acceso a Telegram.
En la siguiente imagen se puede ver el aspecto de la página web de configuración para el sistema.
Una vez que los datos son salvados la red firadmin desaparece y el sistema pasa al modo usuario intentando validar las credenciales de acceso a la red Wi-Fi y cuando sea necesario las credenciales de Telegram.
Para entrar al modo programación se ha colocado un pequeño pulsador en el GPIO_16 que si se oprime el sistema se desconecta de la red Wi-Fi, borra todas las credenciales y pasa a modo programación.
Para detectar la actividad de las puertas se usaron sensores magnéticos que activan una interrupción por cambio de estado en el GPIO_11.
Para el servidor web y todo lo referente a los procesos web usaremos el módulo phew.
Es un pequeño servidor web y una biblioteca de plantillas ya diseñadas específicamente para Micropython en Pico W.
Su objetivo es proporcionar un juego de herramientas completo para crear fácilmente interfaces basadas en la web de alta calidad para todos los proyectos que requieran soporte web.
Es un módulo ideal para crear interfaces de configuración basadas páginas web embebidas que se conectan con sistemas electrónicos.
Un servidor web básico optimizado para la velocidad y recursos de pico w.
Uso mínimo de los recursos de memoria y CPU.
Motor de plantilla que permite expresiones de Python en línea con los métodos Get y Post.
Soporte de conexión Wi-Fi.
Como en ejemplos anteriores lo instalamos en la memoria de pico w usando el administrador de paquetes de Thonny.
Cuando el sistema ha sido configurado crea un archivo que en mi caso he llamado wifi.json y dentro de este archivo encontramos los siguientes datos.
{"ssid": "red_lab","telegramDmUid":"-0100164953574", "password":"1a2b2s2d","botToken": "6146323100:AAGlItE2Mj38mZSRuXxRMRW9t_oR12dYaS4"}
Estos datos son las credenciales de acceso tanto a la red Wi-Fi como al bot de Telegram. Este archivo será borrado automáticamente si se oprime el botón de programación cuando el sistema pasa a modo programación y es por eso que cuando el sistema inicia la primer tarea es verificar que este archivo está en memoria, si no lo encuentra pasa automáticamente al modo programación.
La presencia de este archivo determina en que modo arranca el sistema.
Continuando con el encabezado del programa podemos ver las declaraciones de las variables usadas como el son el punto de acceso que se crea cuando el sistema es programado, el nombre del dominio para acceder a la página de programación etc.
Se han colocado unos indicadores LED´s para conocer el estado operativo del sistema. En este caso el indicador verde indica que el sistema está conectado a la red Wi-Fi y el indicador rojo indica que el sistema está en modo programación.
El código completo de la aplicación es el siguiente.
El archivo index.html tiene el siguiente contenido.
En la carpeta ap_templates también vamos a necesitar el archivo configured.py que tiene el siguiente contenido.
También el archivo redirect.html con el contenido.
Recuerde que en wifi_credentials se encuentran las credenciales de acceso tanto para el Wi-Fi como para Telegram.
Cuando el mensaje se envía se extraen las credenciales de la siguiente forma send_message(wifi_credentials['telegramDmUid'], text_1) por ejemplo para el primer mensaje.
El método que envía el mensaje es bastante simple y también lee el Token Telegram desde el archivo de credenciales.
En la siguiente imagen se puede ver la estructura de archivos que debe contener el proyecto.
En lo personal he editado la biblioteca para eliminar la creación del archivo log.txt que eventualmente podría crecer demasiado con el tiempo y ocupar mucha memoria.
Una vez que el sistema esta funcionado los mensajes enviados tienen el siguiente aspecto.
Todo el sistema lleva funcionando mas de un año en distintas puertas sin problemas enviando mensajes a mi móvil.
Si tiene alguna duda puede consultarnos en Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo..
Este y otros muchos ejemplos se encuentran en nuestro libro "Electrónica con MicroPython".
Si usted esta programando PIC, ATMEL, ARDUINO en lenguaje C sin duda es momento de investigar un poco sobre MicroPython.
El continuo avance en el hardware de los microcontroladores hace que la línea que los separa de los microprocesadores sea cada vez mas borrosa.
Al tener microcontroladores mas rápidos y con capacidad para gestionar mucha mas memoria ahora es posible correr programas que son derivaciones directas de los entornos informáticos.
Es el caso de MicroPython, una derivación de lenguaje Python 3 escrita en C.
MicroPython es un compilador completo del lenguaje Python y un motor e intérprete en tiempo de ejecución, que funciona en el hardware del microcontrolador. Incluye una selección de bibliotecas y módulos que permiten al programador el acceso completo al hardware en bajo nivel.
MicroPython lo creó originalmente el programador y físico australiano Damien George y soporta un amplio número de arquitecturas basadas en ARM, siendo de código libre y actualizado constantemente, en la actualidad es una de las herramientas de programación que se perfila como de gran desarrollo y uso común en el futuro inmediato.
Con MicroPyton tenemos el control de la electrónica que ofrece C pero con el agregado de las bibliotecas y módulos de Python 3.
Otra gran ventaja es que al ser un lenguaje interpretado no se necesita de un compilador y un sistema operativo especifico, tampoco necesitamos licencias de programas. Podemos escribir un código completo en un editor de texto plano, tomar el archivo escrito agregarle la extensión py y simplemente transferirlo a la memoria del microcontrolador, con esto tendremos el controlador programado y funcionando.
Esto suena bien pero puedo hacer esto con cualquier microcontrolador?
La respuesta es NO, para poder usar MicroPython necesitamos un microcontrolador con una arquitectura que permita manejar archivos. Esto es un microcontrolador rápido y con capacidad para gestionar grandes cantidades de memoria RAM y FLASH.
Es necesario cargar en esta memoria el propio interprete MicroPython, es decir que antes de que el microcontrolador ejecute el código que el programador a escrito el interprete debe estar en memoria para poder “traducir” lo que el programador a escrito a un nivel entendible por la propia CPU del controlador.
Tenemos en la actualidad opciones como el microcontrolador RP2040 que viene ya montado en placas Arduino y Raspberry Pico entre otras.
Si compara el costo de una Raspberry Pico con un Arduino UNO, verá que es mucho mas conveniente usar Raspberry Pico.
El controlador RP2040 tiene a bordo dos CPU ARM Cortex M0 trabajando a 133 Mhz, 264 KB de memoria RAM y 2 MB de memoria FLASH, puertos I2C, SPI, UART, etc. Como se puede ver hay una gran diferencia con un Arduino UNO.
Una de las criticas que se suele escuchar sobre MicroPython es que al ser un lenguaje interpretado el código escrito por el programador esta en texto plano lo que hace que sea sencillo copiarlo o duplicarlo pero podríamos tomar un trozo del código y encriptarlo en una memoria exterior de tal forma que si alguien copia el programa principal tendrá también que reescribir los métodos encriptados para que todo funcione.
Otra forma de proteger el código sería compilar y generar un archivo uf2 y descargar este archivo en la memoria de Pico, esto no solo ofrece una protección ante la copia del código, también mejora la velocidad de ejecución ya que al ser MicroPython un lenguaje interpretado para que el código llegue a ejecutarse en la CPU se necesitan algunos pasos extra si lo comparamos con un código compilado donde el interprete ya no es necesario.
Sin embargo con estos nuevos microcontroladores como el RP2040 tenemos el control y manejo de sensores y electrónica que tendríamos con un Arduino, PIC, Atmel, etc pero al ser MicroPython un lenguaje mas limpio es mucho mas sencillo de aprender lo que significa tiempos de aprendizaje y estudio mucho mas cortos.
Si necesitamos conectividad TCP-IP, algo absolutamente necesario si vamos a trabajar en plataformas de IOT, entonces tenemos Pico W que suma a lo anterior un enlace WiFi muy simple de usar.
Con Pico W tenemos la posibilidad de desarrollar aplicaciones con páginas web embebidas.
El poder desarrollar este tipo de aplicaciones son muy interesantes puesto que no necesitamos de costosas pantallas gráficas para desplegar información, la pantalla gráfica la tiene el cliente con su móvil, tableta o computadora además de poder acceder al dispositivo desde cualquier lugar del mundo.
Se podría por ejemplo acceder a variables de campo mediante un microcontrolador RP2040 consultando el estado de sensores y actividad de terreno para publicar los datos en la red mediante su propio enlace WiFi.
Con estos nuevos microcontroladores y MicroPython el desarrollar sistemas de enlaces TCP-IP, bases de datos, control de casas inteligentes o sistemas domóticos es ahora mucho mas sencillo y sobre todo económico.
Todos estos temas y muchos otros los encontrará explicados en nuestro libro "Electrónica con MicroPython".
Puede consultarnos en Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo.
En este libro encontrará una introducción a electrónica digital, un pantallazo de como funciona el mundo de los transistores, resistencias, bits y compuertas lógicas.
Sensores y protocolos de comunicaciones todos conocimientos necesarios para poder conectar periféricos a una placa Pico W y no morir en el intento.
Aprenderemos a programar con Micropython un placa Pico W y manejar distintos tipos de sensores, sistemas de comunicaciones, protocolos de red para construir sitios web embebidos en electrónica todo orientado a poder iniciar un verdadero camino con electrónica programable usando MicroPython.
No se pretende que al finalizar la lectura de este libro usted sea un experto programador en Micropython pero si le interesa el mundo de la electrónica programable y nunca se animó por falta de conocimientos electrónicos este libro sin dudas le será útil.
Encontrará una gran cantidad de ejemplos simples y no tan simples todos explicados que pueden servir como punto de partida para algún proyecto personal o laboral.
Este libro se distribuye en formato pdf con mas de 340 páginas cubre una gran cantidad de temas abordados con ejemplos explicados en detalle con un lenguaje simple y fácil de seguir.
El siguiente es el temario de este libro en su tercera edición y como se puede ver en la diversidad de temas tratados es un verdadero curso sobre MicroPython y Pico W.
Este libro tiene un costo de $10 dólares o el equivalente en su moneda local pagados mediante la plataforma Paypal o también por Mercado Pago.
Capítulo I.
Circuito eléctrico básico...............................................................................10
La Ley de OHM........................................................................................11
Las Resistencias........................................................................................12
Código de colores para resistencias..............................................................14
Resistencias en Serie................................................................................15
Resistencias en Paralelo...........................................................................15
Condensadores (Capacitores).......................................................................19
El código Jis.............................................................................................24
Resumen de condensadores......................................................................25
Fuente de alimentación para los proyectos electrónicos..............................25
Conociendo algunos Símbolos Electrónicos................................................27
Componentes electrónicos............................................................................29
Las pantallas o displays LCD...................................................................30
Bobinas o Inductancias.................................................................................34
Manejo del Multímetro (Tester)...................................................................35
Selección de Escalas y Rangos.................................................................37
Medir Corriente en Continua....................................................................39
Medir Condensadores...............................................................................39
Diodos.......................................................................................................41
Funcionamiento teórico de un Transistor.....................................................43
Funcionamiento práctico de un Transistor...................................................44
Repaso de configuraciones para transistores............................................45
Conectando un relevador a un pin de un controlador...............................46
Transistores de Efecto de Campo (fet).....................................................47
Transistores de Potencia...........................................................................48
Los IGBTS................................................................................................49
Repaso de Transistores.............................................................................49
Disipadores Térmicos...............................................................................51
Tiristores.......................................................................................................52
Conceptos finales sobre compuertas y lógica digital...............................53
Técnica de soldado.......................................................................................57
Lógica Digital...............................................................................................60
Compuertas Lógicas.....................................................................................61
Conceptos finales sobre compuertas y lógica digital...............................65
Capítulo II.
Electrónica programable...............................................................................66
Historia de la Arquitectura ARM.................................................................68
RP2040 de ARM..........................................................................................69
Versiones de Raspberry PI Pico...................................................................70
MicroPython con Raspberry Pico W........................................................71
Hola Mundo con un led............................................................................76
Manejo de un display de siete segmentos.................................................80
Comentando el ejemplo del contador............................................................86
Contador con botón de cuenta..................................................................87
Interrupciones en GPIO............................................................................89
Termómetro con LM35 y display de siete segmentos..............................93
Termostato Relevador y display de siete segmentos.....................................95
Generación de números aleatorios............................................................98
Display LCD Hitachi 44780...................................................................100
Ejemplo para el conversor A/D y pantalla LCD....................................106
Sensor 1-Wire DS18x20.........................................................................109
Sensor DS18B20 1-Wire y pantalla LCD................................................111
Múltiples sensores 1-Wire y pantalla LCD............................................113
Pantallas LCD con solo dos conexiones.................................................116
Capítulo III.
PIO (Programmable Input Output).........................................................119
PIO + UART...........................................................................................125
Evaluando el estado de un botón con PIO..............................................128
Pantalla OLED con MicoPython y Pico.................................................130
DHT22 + Pantalla OLED.......................................................................136
Pantallas Nextion con MicroPython.......................................................141
Ejemplo simple con Nextion NX4024K032...........................................142
RTC Pantallas Nextion NX4024K032...................................................146
Memorias SD..........................................................................................151
Ejemplo simple para memoria SD..........................................................154
Algunos detalles del acceso a memoria SD............................................155
Simple colector de datos en memoria SD...............................................161
Memoria I2C 24LC256..........................................................................166
El bus I2C.............................................................................................167
Algunos detalles para manejar la memoria 24LC256..........................171
Control de acceso por NFC..................................................................172
Reloj Calendario I2C DS3231................................................................176
DS3231 usando la pantalla LCD............................................................182
DS3231 con ISR y LCD.............................................................................184
Control PWM.............................................................................................186
Control de un LED mediante PWM.......................................................188
Control de un Servo Motor mediante PWM...........................................189
Motores paso a paso Unipolares.............................................................193
Motores paso a paso Bipolares...............................................................194
Pololu A4988..........................................................................................194
Usando un sensor de distancia por ultrasonido.......................................196
Puerto UART..........................................................................................198
Ejemplo básico de comunicación por UART.........................................200
Voltímetro UART...................................................................................201
Ajuste por UART del DS3231...............................................................204
Capítulo IV.
Conectividad en redes.................................................................................207
Capa 1: FÍSICA........................................................................................207
Capa 2: ENLACE DE DATOS...........................................................................208
Capa 3: RED..................................................................................................208
Capa 4: TRANSPORTE...................................................................................208
Capa 5: SESIÓN.............................................................................................208
Capa 6: PRESENTACIÓN................................................................................208
Capa 7: APLICACIÓN.....................................................................................209
Protocolo IP............................................................................................209
Direcciones IP........................................................................................209
El protocolo HTTP.................................................................................210
Que es HTML?......................................................................................210
Ejemplos de algunas etiquetas HTML...................................................212
Servidores web con electrónica.............................................................214
Que es Ajax?...........................................................................................214
GET( ) y POST( )...................................................................................218
Que es un socket?.....................................................................................219
Primera web con Raspberry Pico W...........................................................220
Contador Web.........................................................................................225
Control web de un LED..............................................................................229
Sensor BME280.........................................................................................237
Driver MicroPython para BME280........................................................238
Usando Ajax para leer datos del sensor BME280..................................248
XLMHttpRequest( )................................................................................249
Web en Archivo Index.html...................................................................255
Los Sockets UDP..................................................................................257
Como funciona el socket servidor.........................................................260
Como funciona el socket cliente............................................................262
Sensor DHT22 por Socket UDP............................................................262
Control de un LED por UDP..................................................................267
Enviando datos a Telegram con Pico W.................................................272
Módulo phew..........................................................................................276
Como trabaja el ejemplo propuesto.......................................................278
Pico W con enlace NRF24L01...............................................................290
Que es MQTT.........................................................................................298
Por qué MQTT.......................................................................................299
Como funciona MQTT?.........................................................................299
QoS.......................................................................................................300
MicroPython con MQTT.........................................................................301
Configurando un Broker en la nube.......................................................302
Sensor BME280 con MQTT y Pico W.................................................304
Suscripción a un tema con MQTT y Pico W..........................................314
Mejorando MQTT con unTimer.............................................................318
ESP32 con MicroPython........................................................................320
MicroPython con ESP32........................................................................321
Hola Mundo con ESP32 y MicroPython................................................323
ESP32 y sus conversores analógicos....................................................324
Pantalla OLED con MicoPython y ESP32.............................................326
Conectado ESP32 a la red WiFi con MicroPython................................330
Lectura del sensor BME280 con Ajax y ESP32.....................................335
Mosquitto como broker MQTT en Raspberry PI...................................340
Ejemplo con Mosquitto + MQTT + ESP32 + BME280...........................341
Si tiene alguna consulta nos encuentra en Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo.
Siendo el microcontrolador ATMEGA328P un dispositivo de uso común por ser el procesador de la popular placa Arduino Uno, es también un microcontrolador con un potencial no explotado ni conocido en su totalidad debido a la forma en que Arduino transparenta muchos de los procesos y configuraciones que ocurren cuando un programa se ejecuta en su memoria.
Por otro lado tenemos los procesadores de ARM, en particular su núcleo Cortex M4. Un poderoso microcontrolador totalmente programado en 32 bits con recursos no solo para el control, también podemos ejecutar programas que involucren audio y video.
Siendo los 32 bits la evolución natural para los programadores que avanzan en su camino con microcontroladores, las unidades de ARM son una buena opción por su alto desempeño y costos razonables.
No se espera que al terminar la lectura de este libro usted sea un experto programador en C, pero sí que tenga una idea clara de lo que es el lenguaje con uno de los compiladores más simple de usar.
Un comentario que siempre hago a mis alumnos es que la evolución es un paso hacia adelante, un cambio superador y en el campo de la electrónica programable eso es C.
A partir de este punto dependerá de usted hasta donde quiera llegar y que tan largo será el camino.
También se encuentra disponible en formato PDF pude consultar costos y formas de obtenerlo en el correo Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo. siempre indicando desde donde nos escribe.