Electrónica y programación para Microcontroladores.

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.

1. Modo Usuario: Controla el estado de las puertas asignadas.

2. 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.

def ISR_11(p):
         global bandera
         global enviado
         if (sensor.value() == 0):
             bandera = 2
             led_azul.value(1)
         if (sensor.value() == 1):
             bandera = 1
             enviado = 0
             led_azul.value(1)
         if (bandera ==1 and enviado == 0):
             send_message(wifi_credentials['telegramDmUid'], 				  text_1)
             enviado = 1
             wdt.feed()   # Borra el WD 
             print("Puerta de calle Abierta!!")
         if (bandera ==2 and enviado == 1):
             wdt.feed()   # Borra el WD 
             send_message(wifi_credentials['telegramDmUid'], 				  text_2)
             print("Puerta de calle Cerrada!!")
             enviado = 3

Para el servidor web y todo lo referente a los procesos web usaremos el módulo phew.

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.

Que podemos hacer con phew:

• 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.

Como trabaja el ejemplo propuesto.

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.

text_1 = 'Puerta de calle abierta!!!'
text_2 = 'Puerta de calle cerrada!!!'
AP_NAME = "firadmin" 		# Nombre del punto de acceso
AP_DOMAIN = "firtec.net" 	# Nombre del dominio
AP_TEMPLATE_PATH = "ap_templates" # Carpetas sitios html
APP_TEMPLATE_PATH = "app_templates" # Carpetas sitios html
WIFI_FILE = "wifi.json" #Donde se guardan las credenciales
LOG_FILE = "log.txt"
WIFI_MAX_ATTEMPTS = 3
bandera = 0
enviado = 0
sensor = Pin(11, Pin.IN, Pin.PULL_UP)
boton = Pin(16, Pin.IN, Pin.PULL_UP)  

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.

from phew import access_point, connect_to_wifi, is_connected_to_wifi, dns, server
from phew.template import render_template
import json
import machine
import os
import utime
import _thread
import ustruct as struct
from machine import Pin
from machine import WDT
import rp2
import network
import ubinascii
import urequests as requests
import time
 
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wdt = ''
led_rojo = Pin(22, Pin.OUT)
led_rojo.value(0)
red_ok = Pin(21, Pin.OUT)
red_ok.value(0)
led_azul = Pin(20, Pin.OUT)
led_azul.value(0)
 
text_1 = 'Puerta del Quincho Abierta!!!'
text_2 = 'Puerta del Quincho Cerrada!!!'
 
AP_NAME = "firadmin" #Nombre del punto de acceso
AP_DOMAIN = "firtec.net" #Nombre del dominio
AP_TEMPLATE_PATH = "ap_templates"
APP_TEMPLATE_PATH = "app_templates"
WIFI_FILE = "wifi.json" #Donde se guardan las credenciales
LOG_FILE = "log.txt"
WIFI_MAX_ATTEMPTS = 3
bandera = 0
enviado = 0
 
sensor = Pin(11, Pin.IN, Pin.PULL_UP)
boton = Pin(16, Pin.IN, Pin.PULL_UP)  
def ISR_11(p):
         global bandera
         global enviado
         if (sensor.value() == 0):
             bandera = 2
             led_azul.value(1)
         if (sensor.value() == 1):
             bandera = 1
             enviado = 0
             led_azul.value(1)
 
         if (bandera ==1 and enviado == 0):
             send_message(wifi_credentials['telegramDmUid'], text_1)
             enviado = 1
             wdt.feed()   
             print("Puerta de calle Abierta!!")
         if (bandera ==2 and enviado == 1):
             wdt.feed()   
             send_message(wifi_credentials['telegramDmUid'], text_2)
             print("Puerta de calle Cerrada!!")
             enviado = 3
             
sensor.irq(trigger=Pin.IRQ_RISING | Pin.IRQ_FALLING, handler= ISR_11)           
 
def machine_reset():
    utime.sleep(1)
    print("Reseteando sistema...")
    machine.reset()
 
def borrar():
        # Borrar el archivo de configuracion y hacer un reboot
        # como acces point.
        os.remove(WIFI_FILE)
        # Reboot en un hilo nuevo
        _thread.start_new_thread(machine_reset, ())
        red_ok.value(0)
          
def setup_mode():
    
    led_rojo.value(1)
    red_ok.value(0)
    print("Entra al modo setup...")
    def ap_index(request):
        if request.headers.get("host").lower() != AP_DOMAIN.lower():
            wdt.feed()   # Borra el WD 
            return render_template(f"{AP_TEMPLATE_PATH}/redirect.html", domain = AP_DOMAIN.lower())
        return render_template(f"{AP_TEMPLATE_PATH}/index.html")
 
    def ap_configure(request):
        print("Salvando las credenciales del wifi...")
        with open(WIFI_FILE, "w") as f:
            json.dump(request.form, f)
            f.close()
        # Reboot en un hilo nuevo
        _thread.start_new_thread(machine_reset, ())
        return render_template(f"{AP_TEMPLATE_PATH}/configured.html", ssid = request.form["ssid"])
        
    def ap_catch_all(request):
        if request.headers.get("host") != AP_DOMAIN:
            return render_template(f"{AP_TEMPLATE_PATH}/redirect.html", domain = AP_DOMAIN)
 
        return "Not found.", 404
    server.add_route("/", handler = ap_index, methods = ["GET"])
    server.add_route("/configure", handler = ap_configure, methods = ["POST"])
    server.set_callback(ap_catch_all)
    ap = access_point(AP_NAME)
    ip = ap.ifconfig()[0]
    dns.run_catchall(ip)
 
#-------- Envía el mensaje a Telegram ---------------
def send_message (chatId, message): 
    wdt.feed()   # Borra el WD -------
    response = requests.post(sendURL + "?chat_id=" + wifi_credentials['telegramDmUid'] + "&text=" + message)
    print('Mensaje Enviado')
    wdt.feed()   # Borra el WD -------
    response.close() # IMPORTANTE!! Cerrar para no desbordar la RAM
 
def application_mode():
    global wdt
    led_azul.value(0)
    wdt = WDT(timeout=8000)  # Habilita el watchdog para 8 Segundos
    wdt.feed()   # Borra el WD 
    led_rojo.value(0)
    global sendURL
    sendURL = 'https://api.telegram.org/bot' + wifi_credentials['botToken'] + '/sendMessage'
    print("Entrando en modo aplicacion.")
    while True:
        wdt.feed()   # Borra el WD 
        led_azul.value(0)
        if (boton.value() == 0 ):
            borrar()
 
# En que modo debe iniciar...
try:
    os.stat(WIFI_FILE)
    with open(WIFI_FILE) as f:
        wifi_current_attempt = 1
        wifi_credentials = json.load(f)
        while (wifi_current_attempt < WIFI_MAX_ATTEMPTS):
            ip_address = connect_to_wifi(wifi_credentials["ssid"], wifi_credentials["password"])
            if is_connected_to_wifi():
                print(f"Conectado con la IP {ip_address}")
                break
            else:
                wifi_current_attempt += 1
        if is_connected_to_wifi():
            red_ok.value(1)
            application_mode()
        else:
            print("ERROR!")
            print(wifi_credentials)
            #os.remove(WIFI_FILE) 
# Esta linea hace que pase al setup si falla wifi habilitar si # queremos que esto pase, 
            machine_reset()
except Exception:
    setup_mode()
server.run()

El archivo index.html tiene el siguiente contenido.

<!DOCTYPE html>
<html>
<meta charset="UTF-8">
    <body style=background:#F0FFFF>
    <FONT COLOR = "black">
    <center>
    <head>
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <title>SETUP</title>
    </head>
    <body>   
        <h1>Setup del Sistema.</h1>
        <h2>Credenciales de acceso:</h2>
        <form action="/configure" method="POST" autocomplete="off" autocapitalize="none">
            <label for="ssid">Red Wi-Fi:</label><br>
            <input type="text" id="ssid" name="ssid"><br>
            <label for="password">Password:</label><br>
            <input type="text" id="password" name="password"><br>
            <label for="telegramDmUid">Telegram ID:</label><br>
            <input type="text" id="telegramDmUid" name="telegramDmUid"><br>
            <label for="botToken">Token Telegram:</label><br>
            <input type="text" id="botToken" name="botToken"><br><br>
            <button>Salvar los Datos</button>
            <hr Size=5 noshade/><H5><font color='black'>by. Firtec Argentina </H5> 
        </form>
    </body>
    </center>
</html>

En la carpeta ap_templates también vamos a necesitar el archivo configured.py que tiene el siguiente contenido.

<!DOCTYPE html>
<html>
    <head>
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Wifi Configured</title>
    </head>
    <body>
        <h1>Wifi Configured</h1>
        <p>The Raspberry Pi Pico will now reboot and attempt to connect to the &quot;{{ssid}}&quot; wireless network...</p>
    </body>
</html>

También el archivo redirect.html con el contenido.

<!DOCTYPE html>
<html>
    <head>
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Redirigiendo...</title>
        <meta http-equiv="refresh" content="0;url=http://{{domain}}">
    </head>
    <body>
        <p>Redirigiendo...</p>
    </body>
</html>

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.  

Las pantallas Nextion serie K o mejoradas incorporan no solo mas memoria FLASH, también EEPROM y un reloj calendario.
Tener un calendario en la propia pantalla es muy útil porque evita tener que agregarlo en la propia electrónica .
En el siguiente ejemplo vemos un Raspberry Pico conectado a una pantalla Nextión mas dos botones.
Uno de estos botones se conecta al GPIO15 y el otro a RUN, para ajustar el calendario solo debemos apretar los dos botones, soltar RUN y luego GPIO15. El programa pasa a una rutina que espera recibir los datos desde una aplicación diseñada para esa tarea, cuando el RTC está correctamente configurado el LED de la propia placa se enciende indicando que podemos volver a presiona RUN (solo RUN) y el programa continua normalmente con los nuevos datos del calendario.

La pantalla envía cada segundo los datos del RTC a los que se les da el formato dd/mm/aa/ y el reloj hh:mm:ss, estos datos son enviados a la pantalla y se muestran en dos objetos del tipo texto. (El formato se puede ver en el siguiente vídeo). 

Para que esto funcione será necesario escribir unas líneas de código en IDE de Nextion, necesitamos de un Timer un conjunto de variables que serán las encargadas de hacer llegar la información a PICO al ritmo de un segundo cada vez.
El el evento del Timer escribimos el siguiente código (esto se escribe en el IDE de Nextion).
El comando cov pasa un dato a una variable en el campo seleccionado, txt en este caso.
El comando get envía los datos por la UART de la pantalla a 9600 baudios que es la velocidad por defecto. Desde el sitio de Nextion se puede descargar el set de instrucciones y comandos.

cov rtc0,year.txt,0
cov rtc1,mes.txt,0
cov rtc2,dia.txt,0
cov rtc3,hora.txt,0
cov rtc4,minutos.txt,0
cov rtc5,segundos.txt,0
get year.txt
get mes.txt
get dia.txt
get hora.txt
get minutos.txt
get segundos.txt
tm0.en=1

Aparte del Timer necesitamos una serie de variables que usaremos para enviar los datos desde la pantalla a PICO. 
Importante 1:  Todas estas variables deben ser ajustadas como globales, por defecto son locales y no pueden ser accedidas desde afuera de la propia ventana o pantalla.
Importante 2: El Timer debe ser disparado de nuevo cada vez que su tiempo termine de lo contrario solo se ejecuta una vez.

Como se explico en otro ejemplo, los mensajes Nextion siempre terminan con 0xFF 0xFF 0xFF y el aspecto de un mensaje enviando los datos del RTC es elsiguiente.

b'p2022\xff\xff\xffp1\xff\xff\xffp5\xff\xff\xffp11\xff\xff\xffp3\xff\xff\xffp1\xff\xff\xff'

De acuerdo al código escrito en el evento del Timer primero envía el año luego el mes, día, hora, minutos y segundos pero lo interesante es que antes de cada dato se envía una "p" que será muy útil a la hora de recuperar los datos. No podemos simplemente contar los casilleros de la cadena porque su longitud varía si los datos tiene un dígito o dos, entonce sabiendo que luego de la "p" está el dato solo es cuestión de usar ese carácter como marcador.
El único dato que siempre estará en la misma posición ocupando la misma cantidad de casilleros es el año pero el resto puede variar dependiendo de que tengan uno o dos dígitos.
Supongamos que los datos vienen en la variable mensaje observe el siguiente código:

mensaje = str(datos_nextion)        
            global _year
            _year = "".join((mensaje[3],mensaje[4],mensaje[5],mensaje[6]))
            a = mensaje.index("p")         
            a = mensaje.index("p", a + 1)
            global _mes
            if(mensaje[a+1] >= "0" or mensaje[a+2] <="9"):
                     _mes = "".join((mensaje[a+1],mensaje[a+2]))
            if(mensaje[a+2] >"9"):
                    _mes = mensaje[a+1]

Usando index() recorremos el mensaje usando el offset obtenido en "a" y recorremos la cadena hasta el primer marcador que esta antes del año, el segundo marcador esta antes del mes pero necesitamos saber si el mes tiene uno o dos dígitos para eso evaluamos el valor del primer casillero y del que le sigue si contiene información numérica válida, con join() concatenamos los dos caracteres en la variable _mes. Si no hay información numérica válida en el segundo casillero significa que el dato solo tiene un dígito.
Una vez que tenemos todos los datos simplemente se arma una cadena para calendario agregando el separador "/".

calendario = "/".join((_dia,_mes,_year))

Y lo mismo para el reloj con el separador ":". 

reloj = ":".join((_hora,_minutos,_segundos))

Luego solo resta enviar las dos cadenas a la pantalla y mostrar la información en dos objetos del tipo Texto.
   enviar("t1.txt=\""+ calendario +"\"")
   enviar("t2.txt=\""+ reloj +"\"")
El código completo del ejemplo es el siguiente.

#.................................................................................
# El ejemplo requiere de dos botones conectados a RUN y GPIO15.
# Si ambos botones son activados el programa espera recibir datos del soft
# de ajuste para el RTC. El LED de la placa Raspberry PICO se encenderá para
# indicar que el reloj ha sido configurado.
# Luego oprimir solamente el boton RUN y el sistema queda fucionando con los
# nuevos datos.
# Software de ajuste: https://www.firtec.com.ar/Python/rtc.zip
# La información del RTC es tratada y retorna a la pantalla con el formato
# dd/hh/yy  hh:mm:ss y se muestra en dos objetos tipo texto.
#
# Target:    RASPBERRY PICO
# ToolChain: MICROPYTHON
#
# www.firtec.ar - Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo. 
#.................................................................................
 
from machine import UART, Pin
from rp2 import PIO, StateMachine, asm_pio
import time
import os
 
BAUDIOS = 9600
 
HARD_UART_TX_PIN = Pin(4, Pin.OUT)
PIO_RX_PIN = Pin(3, Pin.IN, Pin.PULL_UP)
boton = Pin(15, Pin.IN, Pin.PULL_UP) # Botón para el modo ajuste.
 
@asm_pio(in_shiftdir=rp2.PIO.SHIFT_RIGHT,)
 
def uart_rx():
    label("inicio")
    wait(0, pin, 0) # Espera por el bit de inicio (pin a nivel bajo el tiempo de un bit)
    # Carga el registro x con la cantidad de bits desde el primer bit de datos y espera
    # 10 cilos + wait + set 12 ciclos. (12*13uS = 156uS)
    set(x, 7)                 [10]
    label("bit_bucle")
    in_(pins, 1)  # Desplaza un bit desde el pin 3 RX al registro de desplazamiento
    # Cada bucle toma 8 ciclos, 6 + dec + jmp = 8 (8*13uS = 104uS)
    jmp(x_dec, "bit_bucle")     [6]
    jmp(pin, "terminado")  # Si el pin esta a nivel alto llegó el bit de STOP
 
    irq(block, 4) # Coloca bandera para informar el error.
    wait(1, pin, 0) # Espera que el pin de datos este bajo
    jmp("inicio") # No hacer nada y volver al inicio porque a ocurrido un error
    label("terminado")  # Todo ha salido bien y se ha recibido un caracter!!
    push(block)
 
def error(sm):
    print("ERROR de tiempo", end="!!!")
 
def ajustar():
    while True:
        global cont
        rx = sm.get() >> 24
        if cont == 0:
            a = rx
        elif cont == 1:
            enviar("rtc1="+ str(rx))
        elif cont == 2:
            enviar("rtc2="+ str(rx))
        elif cont == 3:
            enviar("rtc3="+ str(rx))
        elif cont == 4:
            enviar("rtc4="+ str(rx))
        elif cont == 5:
            enviar("rtc5="+ str(rx))
        cont += 1
        if cont == 6:
            cont = 0
            led.value(1) # LED indicador de carga de datos finalizada
 
sm = StateMachine(
    0,
    uart_rx,             # Programa que se carga en la maquina
    freq=8 * BAUDIOS,    # Frecuencia de reloj 8*9600=76800 Hz(13uS)
    in_base=PIO_RX_PIN,  # Define el pin de entrada al registro de desplazamiento
    jmp_pin=PIO_RX_PIN,  # Cuando este pin este a nivel alto saltar
    )
 
sm.irq(error)
sm.active(1)
cont = 0
 
 
uart = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1),timeout=10)
 
led = Pin(25, Pin.OUT)
led.value(0) 
 
# Variables usadas en el ejemplo
bandera = 0
_year = 0
_mes = 0
_dia = 0
_hora = 0
_minutos = 0
_segundos = 0
 
def enviar(cmd):
     uart.write(cmd)
     uart.write(b'\xFF\xFF\xFF')
 
def main():
    if (boton.value() == 0 ):
            ajustar()
    while True:        
        while uart.any():  # Recibe los datos desde la pantalla Nextion
            led.toggle()
            datos_nextion = uart.readline()
            mensaje = str(datos_nextion)        
            global _year
            _year = "".join((mensaje[3],mensaje[4],mensaje[5],mensaje[6]))
            a = mensaje.index("p")         
            a = mensaje.index("p", a + 1)
            global _mes
            if(mensaje[a+1] >= "0" or mensaje[a+2] <="9"):
                     _mes = "".join((mensaje[a+1],mensaje[a+2]))
            if(mensaje[a+2] >"9"):
                    _mes = mensaje[a+1]
            global _dia
            a = mensaje.index("p", a + 1)
            if(mensaje[a+1] >= "0" or mensaje[a+2] <="9"):
                     _dia = "".join((mensaje[a+1],mensaje[a+2]))
            if(mensaje[a+2] >"9"):
                    _dia = mensaje[a+1]
            global _hora
            a = mensaje.index("p", a + 1)   
            if(mensaje[a+1] >= "0" or mensaje[a+2] <="9"):
                    _hora = "".join((mensaje[a+1],mensaje[a+2]))
            if(mensaje[a+2] >"9"):
                    _hora = mensaje[a+1]
            global _minutos
            a = mensaje.index("p", a + 1)     
            if(mensaje[a+1] >= "0" or mensaje[a+2] <="9"):
                    _minutos = "".join((mensaje[a+1],mensaje[a+2])) 
            if(mensaje[a+2] >"9"):
                    _minutos = mensaje[a+1]
            global _segundos
            a = mensaje.index("p", a + 1)
 
            if(mensaje[a+1] >= "0" or mensaje[a+2] <="9"):
                    _segundos = "".join((mensaje[a+1],mensaje[a+2]))
            if(mensaje[a+2] >"9"):
                    _segundos = mensaje[a+1]
            calendario = "/".join((_dia,_mes,_year))
            reloj = ":".join((_hora,_minutos,_segundos))
            enviar("t1.txt=\""+ calendario +"\"")
            enviar("t2.txt=\""+ reloj +"\"")
 
if __name__ == '__main__':
    main()

Para el receptor serial que recibe los datos de la aplicación de ajuste se ha usado código ensamblador PIO del controlador RP2040 y controlado por una interrupción.
Como se puede ver el uso de pantallas gráficas no solo se limita a detectar botones y desplegar datos, también podemos escribir programas completos dentro de la propia pantalla para  relacionarla con la electrónica a la que está conectada.
Por ejemplo podemos construir un datalogger para registrar y almacenar la temperatura en una memoria SD. 

El ejemplo crea una carpeta en la memoria SD cada nuevo mes con el nombre del mes y año, luego cada día crea un archivo que lleva por nombre la fecha del día y transcurrido un tiempo aleatorio que va desde 1 a 59 minutos almacena los datos de temperatura y hora de la muestra con un formato de hoja de cálculo.

El botón actualizar que se ve en la imagen tiene la función de actualizar los mínimos y máximos, sin embargo en este ejemplo la función principal es poder mostrar como se discriminan los distintos mensajes que llegan desde y hacia la pantalla.
El texto ha sido extraído de uno de nuestros libros "ELECTRÓNICA CON MICROPYHTON"

En los cultivos hidropónicos independientemente del sistema que se elija (NFT, Mixto, etc) el control de la bomba para la solución nutritiva es de vital importancia. 
En el siguiente ejemplo tenemos un Arduino Nano controlando el tiempo de apagado y funcionamiento de una bomba que impulsa los nutrientes por los tubos del sistema hidropónico.

 El sistema propuesto puede temporizar tanto el tiempo de funcionamiento como el de apagado en un rango que va desde 1 a 50 minutos. También tiene arranque y parada manual de la bomba y la visualización de temperatura de la solución nutritiva mediante un sensor DS18B20.
Las variables ambientales se obtienen con un sensor DHT22. El sistema almacena en memoria EEPROM los datos de tiempos de funcionamiento por lo que si todo el sistema se apaga, al encenderlo nuevamente el controlador retoma su tarea con los tiempos previstos.
El código completo para obtener los resultados como los mostrados en la imagen es el siguiente:

/*******************************************************************
** Descripción: Control de un sistema de bomba para hidroponia con
**              lectura de temperatura de la solución nutritiva y
**              condiciones ambientales como temperatura y humedad
**              Sensor DS18B20 conectado en pin 10 y DHT22 en pin 9
**              Botones de arranque/parada manual conectados en pines 
**              3 y 4. 
**              Boton de programación de tiempos en pin 2
**   Placa Arduino: NANO
**   Arduino IDE: 1.8.15
**   
**   www.firtec.com.ar
*******************************************************************/
#include <DHT.h>
#define DHTTYPE DHT22     // Tipo de sensor
#include <EEPROM.h>
#include <LiquidCrystal_I2C.h>
#include <OneWire.h>
#include <avr/wdt.h>
#include <DallasTemperature.h>
 
void Temperatura_Nutriente(void);  // Función para medir la temperatura 
void Programar_Tiempo(void);       // Función para los tiempos de la bomba
void Potenciometro(void);          // Función para ajustar los minutos de trabajo
void Pantalla(void);               // Función para mostrar los textos en pantalla
void Sensor_DHT22(void);           // Lee temperatura y humedad ambiente
 
LiquidCrystal_I2C lcd(0x27,20,4);
#define prog 2                  // Boton de programacion para el tiempo de bomba
#define arranque_manual 3      // Boton para el arranque manual de la bomba
#define parada_manual 4        // Boton para la parada manual de la bomba
#define relay_bomba 5           // Salida para activar/desactivar bomba de nutrientes
#define alarma_temperatura 18   // LED para indicar alarma de temperatura
#define calefactor 17           // Pin para activar/desactivar el calefactor 
 
OneWire UnWire(10);             // Sensor DS18B20 conectado en el pin 10
DallasTemperature sensor(&UnWire);
DHT dht(9, DHT22); // Instancia del sensor conectado en el pin 9
 
byte minutos = 0, segundos = 0, estado = 0;
byte tiempo_boton = 0; // Tiempo de espera para entrar en modo programacion
byte tiempo_funcionamiento = 10; // Valor por defecto si no hay nada previo
byte tiempo_apagado = 10;        // Valor por defecto si no hay nada previo
char buffer[5] = " ";            // Manejo de datos a ASCII para el LCD
unsigned int M0 = 0;             // Variable usada en el conversor
volatile bool flag_bomba = false; // Variable para avisar que ha pasado un segundo
bool estado_bomba = false;
bool flag_prog = false;
bool programando = false;
unsigned int dir_ep = 0;      // Variable para contener la dirección EEPROM donde se guarda los valores
double temp;         // Variable para contener la temperatura
float t;
float h;
static char Temperatura[5]="";
static char Humedad[5]="";
 
 
/******************* FUNCIÓN PARA ESCALAR EL CONVERSOR A/D ********************
** Potenciometro conectado en el Canal A0
******************************************************************************/
long map(long x, long in_min, long in_max, long out_min, long out_max){
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
 
/******************* FUNCIÓN DE CONFIGURACIÓN GENERAL ************************
** Configura las condiciones de arranque y Hardware.
******************************************************************************/
void setup() {
  Serial.begin(9600);
  pinMode(A0, INPUT);
  pinMode(alarma_temperatura, OUTPUT);
  digitalWrite(alarma_temperatura, LOW); 
  pinMode(calefactor, OUTPUT);  // Pin para activar/desactivar el calefactor 
  digitalWrite(calefactor, LOW); // Pin normal
  //digitalWrite(calefactor, HIGH);  // Pin invertido
  pinMode(relay_bomba, OUTPUT);
  digitalWrite(relay_bomba, LOW); // Pin normal
  //digitalWrite(relay_bomba, HIGH);  // Pin invertido
  pinMode(prog,INPUT_PULLUP); 
  pinMode(arranque_manual,INPUT_PULLUP); // Configura el pin de arranque manual de la bomba
  pinMode(parada_manual,INPUT_PULLUP); // Configura el pin de parada manual de la bomba
  noInterrupts(); 
  TCCR1A = 0;                // El registro de control A queda todo en 0
  TCCR1B = 0;                //limpia registrador
  TCNT1  = 0;                //Inicializa el temporizador
  OCR1A = 0x3D09;            // Carga el registrador de comparación: 16MHz/1024/1Hz = 15625 = 0X3D09
  TCCR1B |= (1 << WGM12)|(1<<CS10)|(1 << CS12);   // modo CTC, prescaler de 1024: CS12 = 1 e CS10 = 1  
  TIMSK1 |= (1 << OCIE1A);  // habilita interrupción por igualdade de comparación
  TIMSK1 |= (1 << TOIE1);   // enable timer overflow interrupt
  interrupts();             // enable all interrupts
  if(EEPROM.read(dir_ep) > 50){  // Recupera de memoria el ultimo tiempo de encendido
    tiempo_funcionamiento = 10;  // Si no es valido asigna uno por defecto 10 minutos
  }
  else
    tiempo_funcionamiento = EEPROM.read(dir_ep);
  
  if(EEPROM.read(dir_ep + 1) > 50){ // Recupera de memoria el ultimo tiempo de parada
    tiempo_apagado = 10;            // Si no es valido asigna uno por defecto 10 minutos
  }
  else
    tiempo_apagado = EEPROM.read(dir_ep + 1);
  lcd.init();                      
  lcd.backlight();
  dht.begin();
  Pantalla();
  wdt_disable();
  wdt_enable(WDTO_4S);
 
}
/******************* BUCLE PRINCIPAL DE PROGRAMA *****************************
** Verifica botones, sensor de temperatura y control general del programa.
******************************************************************************/
void loop() {
  wdt_reset(); // Borra el contador del wachdog
  Sensor_DHT22();
//********* VERIFICA LOS BOTONES DE CONTROL MANUAL DE BOMBA*********************** 
  if (digitalRead(arranque_manual) == LOW & programando == false){
     segundos = 0;
     minutos = 0;                     // Borrar minutos para nueva cuenta
     digitalWrite(relay_bomba, HIGH); // Activar la bomba de nutrientes (normal)
     //digitalWrite(relay_bomba, LOW);    // Activar la bomba de nutrientes (invertido)
     estado_bomba = true;             // Avisar que la bomba esta funcionando
     lcd.setCursor(6,2); 
     if(programando == false)
         lcd.print("SI");   // Mostrar cartel del estado de la bomba
  }
 if (digitalRead(parada_manual) == LOW & programando == false){
     segundos = 0;
     minutos = 0;                     // Borrar minutos para nueva cuenta
     digitalWrite(relay_bomba, LOW); // Activar la bomba de nutrientes (normal)
     //digitalWrite(relay_bomba, HIGH);  // Activar la bomba de nutrientes (invertido)
     estado_bomba = false;           // Avisar que la bomba esta funcionando
     lcd.setCursor(6,2);
     if(programando == false) 
          lcd.print("NO");  // Mostrar cartel del estado de la bomba
  }
  if(programando == false)
      Temperatura_Nutriente();  // Mide la temperatura de solución de nutrientes
  wdt_reset(); // Borra el contador del wachdog
 //********* CONTROL DE LA BOMBA DE NUTRIENTES ****************************  
  if(flag_bomba == true){           // Temporizador avisa que ya paso un segundo
    if (digitalRead(prog) == LOW){  // El boton de programación esta activado?
     tiempo_boton++;                // Incrementar el tiempo de control
     flag_prog = true;              // Avisar que el boton esta apretado
     if(tiempo_boton == 5 & digitalRead(prog) == LOW){ // Pasaron 5 segundos con el boton apretado?
        Programar_Tiempo();  // Programa tiempo de funcionamiento de la bomba
     }
    }
    if (digitalRead(prog)){ // El botón de programación se soltó?
      tiempo_boton =0;      // Ignorar todos los pasos anteriores!!
      flag_prog = false;    // Borrar bandera de programación.
    }
    segundos++;           // Incrementa los segundos
    if(segundos == 59){   // La cuenta llego al minutos?
      segundos = 0;       // Borra segundos para nueva cuenta
      minutos++;          // Incrementa los minutos    
      wdt_reset(); // Borra el contador del wachdog
    }
    if(minutos == tiempo_apagado & estado_bomba == false){ // Se cumplió el tiempo de apagado?
      minutos = 0;                     // Borrar minutos para nueva cuenta
      digitalWrite(relay_bomba, HIGH); // Activar la bomba de nutrientes (normal)
      //digitalWrite(relay_bomba, LOW);    // Activar la bomba de nutrientes (invertido)
      estado_bomba = true;             // Avisar que la bomba está funcionando  
      lcd.setCursor(6,2);
      if(programando == false) 
            lcd.print("SI");  // Mostrar cartel del estado de la bomba
      wdt_reset(); // Borra el contador del wachdog
    } 
    if(minutos == tiempo_funcionamiento & estado_bomba == true){  // Se cumplió el tiempo de funcionamiento? 
      minutos = 0;    // Borrar los minutos para nueva cuenta
      digitalWrite(relay_bomba, LOW);  // Apagar la bomba de nutrientes (normal)
      //digitalWrite(relay_bomba, HIGH);   // Apagar la bomba de nutrientes (invertido)
      estado_bomba = false;       // Avisar que la bomba está apagada
      lcd.setCursor(6,2); 
      if(programando == false)
            lcd.print("NO"); // Mostrar cartel del estado de la bomba
      wdt_reset(); // Borra el contador del wachdog
    }    
    wdt_reset(); // Borra el contador del wachdog
    flag_bomba = false; // Borra bandera de INTE
  }
}
/******************* INTERRUPCION POR CADA SEGUNDO ********************
** Ciclo de interrupción: 1 segundo
***********************************************************************/
ISR(TIMER1_COMPA_vect)          
{
   flag_bomba = true;   // Bandera para controlar los segundos
}
 
/****** MIDE LA TEMPERATURA DE LA SOLUCIÓN NUTRIENTE *******************
** Sensor: DS18B20
** Alarma Max/Min: 18 grados y 35 grados
** Calefactor: SI por debajo de 16 grados NO por encima de 14 grados
************************************************************************/
void Temperatura_Nutriente(){
  wdt_reset(); // Borra el contador del wachdog
  sensor.requestTemperatures();
  temp = sensor.getTempCByIndex(0);
  dtostrf(temp, 2, 0, buffer);
  lcd.setCursor(5, 1);
  lcd.print(buffer);
  lcd.print((char)223);
  wdt_reset(); // Borra el contador del wachdog     
}
/****** PROGRAMA EL TIEMPO DE FUNCIONAMIENTO DE LA BOMBA****************
** Sensor: 
** Tiempo Max/Min: 1 minutos y 50 minutos
************************************************************************/
void Programar_Tiempo(void){
  byte contador = 0;
  bool bandera = false;
  programando = true;
  digitalWrite(alarma_temperatura, LOW); // Apagar indicador de alarma
  digitalWrite(relay_bomba, LOW); // Apagar la bomba de nutrientes (normal)
  //digitalWrite(relay_bomba, HIGH);  // Apagar la bomba de nutrientes (invertido)
  lcd.clear();
  lcd.setCursor(0,0); 
  lcd.print("TIEMPO DE ENCENDIDO");  
  lcd.setCursor(0,1); 
  lcd.print("Minutos:--"); 
 m1:
 if (digitalRead(prog)== LOW){
    wdt_reset(); // Borra el contador del wachdog
    delayMicroseconds(50);
    goto m1;
    }
 m2:
  if (digitalRead(prog)== HIGH){
    Potenciometro();
    wdt_reset(); // Borra el contador del wachdog
    lcd.setCursor(8, 1);
    lcd.print(buffer);
    goto m2;
    }
  if (digitalRead(prog)== LOW){
    tiempo_funcionamiento = M0;
    EEPROM.write(dir_ep, M0);  // Salva el valor de funcionamiento en EEPROM
    wdt_reset(); // Borra el contador del wachdog
    }
 m3:
 if (digitalRead(prog)== LOW){
    wdt_reset(); // Borra el contador del wachdog
    delayMicroseconds(50);
    goto m3;
    }
  lcd.setCursor(0,0); 
  lcd.print("TIEMPO DE APAGADO");  
 m4:
 if (digitalRead(prog)== LOW){
    wdt_reset(); // Borra el contador del wachdog
    delayMicroseconds(50);
    goto m4;
    }
 m5:
  if (digitalRead(prog)== HIGH){
    Potenciometro();
    wdt_reset(); // Borra el contador del wachdog
    lcd.setCursor(8, 1);
    lcd.print(buffer);
    goto m5;
    }
  if (digitalRead(prog)== LOW){
    tiempo_apagado = M0;
    EEPROM.write(dir_ep + 1, M0);   // Salva el valor de apagado en EEPROM
    wdt_reset(); // Borra el contador del wachdog
    }
 m6:
 if (digitalRead(prog)== LOW){
    wdt_reset(); // Borra el contador del wachdog
    delayMicroseconds(50);
    goto m6;
    }
  Pantalla();
  programando = false;    
}
/****** OBTIENE UN NÚMEROENTRE 1 Y 50 PARA CONFIGURAR LOS MINUTOS ******
** Sensor: 
** Tiempo Max/Min: 1 minutos y 50 minutos
************************************************************************/
void Potenciometro(void){
byte muestras=0;
unsigned int M1=0;
do{ 
  M1 += analogRead(A0);    // Lee el A/D y acumula el dato en M1
  muestras++;         // Incrementa el contador de muestras
  wdt_reset(); // Borra el contador del wachdog
}while(muestras <=49);  
  M0 = M1/50;
  M0 = map(M0, 0, 1023, 1, 50);  // Escalar lectura para minutos de 1 a 50
  dtostrf(M0, 2, 0, buffer);    // Preparar el dato para el LCD
  muestras =0;
  M1 = 0;
}
/************* FUNCIÓN PARA MOSTRAR LOS TEXTOS EN PANTALLA*************
** 
***********************************************************************/
void Pantalla(void){
  wdt_reset(); // Borra el contador del wachdog
  lcd.clear();
  lcd.setCursor(0,1); 
  lcd.print("Temp:   ");
  lcd.setCursor(0,3); 
  lcd.print("Activa: ");
  lcd.setCursor(7,3); 
  lcd.print(tiempo_funcionamiento);
  lcd.setCursor(12,3); 
  lcd.print("Apaga:");
  lcd.setCursor(18,3); 
  lcd.print(tiempo_apagado);
  lcd.setCursor(0,2); 
  lcd.print("Bomba:NO");
  lcd.setCursor(11,0); 
  lcd.print("Ambiente");
  lcd.setCursor(10,1); 
  lcd.print("Temp:");
  lcd.setCursor(10,2); 
  lcd.print("Hum:");
  lcd.setCursor(0,0); 
  lcd.print(" Solucion");
  lcd.setCursor(10,3); 
  lcd.print("~");
}
/*********** FUNCIÓN PARA LEER LAS VARIABLES ATMOSFERICAS *************
** 
***********************************************************************/
void Sensor_DHT22(void){
  t = dht.readTemperature(); // Lee sensor temperatura
  h = dht.readHumidity();  // Lee sensor humedad
  
  if (isnan(h) || isnan(t)) { // Verifica si error de lectura
              lcd.setCursor(14,1);
              lcd.print("Error");
              lcd.setCursor(14,2);
              lcd.print("Error");  
              }
            else{ // No hay error, procesa los datos
              
   dtostrf(t, 4, 1, Temperatura); // Procesa la temperatura 
   dtostrf(h, 4, 1, Humedad);     // Procesa la humedad
   lcd.setCursor(15,1);
   lcd.print(Temperatura);  // Muestra la temperatura
   lcd.print((char)223);
   lcd.setCursor(15,2);
   lcd.print(Humedad);    // Muestra la humedad
   lcd.print("%");
  
   }
 } 
 
//*************** Fin del archivo Firtec Argentina ********************

[MATERIAL EXTRAÍDO DE UNO DE NUESTROS LIBROS PARA ARDUINO]

Esta dirección de correo electrónico está siendo protegida contra los robots de spam. Necesita tener JavaScript habilitado para poder verlo.