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.  

Libro en formato PDF.

 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.