Las placas de microcontroladores requieren comunicación de datos con muchos otros dispositivos que incluyen sensores, actuadores, otros microcontroladores y microcomputadoras. Esta transferencia o intercambio de datos se realiza a través de interfaces serie utilizando protocolos estándar como UART, I2C, SPI, 1-wire, etc. UART es uno de los protocolos de comunicación de datos en serie comunes disponibles en casi todos los microcontroladores. UART es un protocolo de comunicación de datos serie bidireccional punto a punto. Los sensores generalmente comunican datos con microcontroladores y microcomputadoras mediante protocolos I2C o SPI, ya que los sensores siempre se comportan como dispositivos esclavos que generalmente solo requieren transmisión de datos a los microcontroladores/microcomputadoras. Prácticamente no es necesaria la comunicación de datos bidireccional a través de sensores.
Sin embargo, cualquier comunicación de datos con otros microcontroladores o microcomputadoras debe ser estrictamente punto a punto y bidireccional. UART es el protocolo de comunicación serie más útil en este escenario. El protocolo UART es útil cuando una microcomputadora u otro microcontrolador maestro controla sistemas de microcontroladores en red como ESP8266 o ESP32. Este artículo analizará la clase UART del módulo de máquina MicroPython y explorará cómo se puede utilizar para la comunicación de datos en serie en ESP8266 y ESP32.
Módulo de máquina MicroPython
Además de los módulos Python3 reimplementados, MicroPython tiene varios módulos nativos para manejar funciones y dispositivos de hardware. Uno de estos módulos es una máquina responsable de manejar muchas funciones vitales del microcontrolador. El módulo incluye clases para controlar entrada/salida digital, controlar señales de salida de dispositivos externos, modulación de ancho de pulso, conversión analógica a digital, control de periféricos ADC, UART, SPI, I2C, I2S, temporizador, RTC, temporizador Watchdog y gestión de tarjetas SD.
Clase UART
La clase UART es parte del módulo de la máquina. Implementa el protocolo estándar UART/USART. UART requiere dos líneas: Rx y Tx para comunicación full-duplex. El Rx y Tx de un microcontrolador están conectados al Tx y Rx del otro respectivamente. Esta clase se importa a un script MicroPython siguiendo las siguientes instrucciones.
desde la importación de la máquina UART
La creación de instancias de un objeto UART debe seguir esto. La función constructora del objeto UART es la siguiente.
máquina de clase.UART(id,…)
El método constructor esencialmente requiere especificar el ID de UART como argumento. Se pueden pasar muchos otros argumentos dentro del método constructor. Estos argumentos son los mismos que los definidos para el método UART.init. Los discutiremos pronto. Algunos de los ejemplos válidos de creación de instancias de un objeto UART son los siguientes.
uarte = UART(0)
uart = UART(0, velocidad en baudios=9600)
uart1 = UART(1, velocidad en baudios=9600, tx=33, rx=32)
Los otros métodos disponibles en la clase UART son los siguientes.
UART.init : este método se utiliza para inicializar el objeto UART. Tiene el siguiente prototipo.
UART.init(tasa de baudios=9600, bits=8, paridad=Ninguna, parada=1, *,…)
Los siguientes parámetros se pasan a la llamada al método.
Velocidad en baudios: Esta es la velocidad en baudios en bps. Debe pasarse como argumento.
bits: Es el número de bits por carácter. Puede ser 7, 8 o 9. El valor predeterminado es 8.
paridad: especifica el bit de paridad. Puede ser par (0) o impar (1).
parada: especifica el número de bits de parada. Puede ser 1 o 2.
tx: especifica el pin de transmisión en el puerto que se utilizará.
rx: Especifica el pin del receptor en el puerto que se utilizará.
rtc: especifica el pin rtc en el puerto que se utilizará. El RTC es el pin de salida utilizado para el control del flujo de recepción del hardware.
cts: especifica el pin cts en el puerto que se utilizará. El CTS es el pin de entrada utilizado para el control de flujo de transmisión de hardware.
txbuf: especifica el tamaño del búfer del transmisor en varios caracteres.
rxbuf: especifica el tamaño del búfer del receptor en varios caracteres.
timeout: especifica el tiempo en milisegundos que se debe esperar para recibir el primer carácter.
timeout_char: especifica el tiempo en milisegundos de espera entre caracteres.
invertir: especifica la línea que se invertirá. Se puede configurar en 0, UART.INV_TX, UART.INV_RX y UART.INV_TX UART.INV_RX. Si se establece en 0, no se invertirán líneas. Si se establece en UART.INV_TX, la línea de transmisión se invertirá. Si se establece en UART.INV_RX, la línea del receptor se invertirá. Si se configura en UART.INV_TX UART.INV_RX, las líneas del transmisor y del receptor se invierten. La inversión invierte los niveles lógicos TTL, es decir, de lógica positiva a lógica negativa o de lógica negativa a lógica positiva.
flujo: especifica el control de flujo del hardware. Se puede configurar en 0, UART.RTS, UART.CTS y UART.RTS UART.CTS. Si se establece en 0, las señales de control de flujo de hardware se ignorarán. Si se configura en UART.RTS, habilita la señal RTS siempre que el FIFO del receptor tenga suficiente espacio para acomodar más datos. Si se establece en UART.CTS, se habilitará la señal CTS. Cuando la señal CTS, la transmisión se pausa si el receptor tiene poco espacio en el buffer. Si se configura en UART.RTS UART.CTS, las señales RTS y CTS están habilitadas.
Claramente, MicroPython permite un control preciso de la comunicación UART. Esto es evidente por la cantidad de parámetros de configuración permitidos en el método UART.init.
UART.deinit : Al llamar a este método, el bus UART se desactiva.
UART.read((nbytes)) : este método lee el número de caracteres especificados como argumento del búfer del receptor. Si no se pasan argumentos, lee todos los caracteres en el búfer del receptor. Es posible que no devuelva nada o que regrese antes si se alcanza el tiempo de espera.
UART.readinto(buf(,nbytes)) : este método lee el número de caracteres especificados como argumento en el búfer del receptor. Si no se pasan argumentos, lee todos los caracteres disponibles en el búfer del receptor. Es posible que no lea nada o que regrese antes de tiempo si se alcanza el tiempo de espera.
UART.readline : este método lee una línea de caracteres. Un carácter de nueva línea finaliza una línea. Es posible que no se devuelva ninguno si se alcanza el tiempo de espera.
UART.write(buf) : este método escribe caracteres específicos en la línea de transmisión.
UART.sendbreak : este método envía una condición de interrupción en el bus. Reduce las líneas por un período más largo.
UART.irq(trigger, prioridad=1, handler=None, wake=machine.IDLE) : este método invoca una devolución de llamada (función) cuando se reciben datos en el UART. Acepta cuatro parámetros. El disparador sólo puede ser UART.RX_ANY. Prioridad define el nivel de prioridad que puede estar entre 1 y 7. Un número más alto indica una prioridad más alta. El controlador es la función de devolución de llamada. Es opcional. Wake puede ser la única máquina.IDLE.
UART.any : este método devuelve la cantidad de caracteres disponibles para lectura. Devuelve 0 si no hay caracteres disponibles para leer. Puede devolver 1 o el número exacto de caracteres disponibles para lectura si hay uno o más caracteres disponibles. Esto depende del puerto específico.
UART en ESP8266
En ESP8266, hay dos periféricos UART disponibles: UART0 y UART1. UART0 tiene líneas en los pines GPIO1 (UART0 TX) y GPIO3 (UART0 RX). UART1 tiene líneas en los pines GPIO2 (UART1 TX) y GPIO8 (UART1 RX).
Puertos UART en el módulo ESP8266.
GPIO8 está conectado internamente al chip flash; Sólo UART1 es el transmisor. UART0 está adjunto de forma predeterminada a Web REPL. El uso de UART0 para la comunicación de datos en serie primero debe desconectarse del REPL. UART0 se puede desconectar del REPL usando el siguiente fragmento de código.
importar sistema operativo
os.dupterm(Ninguno, 1)
Después de desconectar UART0 del REPL, se puede utilizar para la comunicación de datos en serie. El método constructor de la clase UART se puede utilizar para crear una instancia de un objeto UART. El método init se puede utilizar en el objeto para configurar la UART. Los métodos de lectura y línea de lectura se pueden usar para leer desde UART, y el método de escritura se puede usar para transmitir datos en serie a través de UART.
desde la importación de la máquina UART
uart = UART(0, velocidad en baudios=9600)
uart.write('Hola')
uart.leer
Una vez que se completa el requisito de comunicación en serie, se debe volver a conectar UART0 al REPL. UART0 se puede volver a conectar al REPL usando el siguiente fragmento de código.
importar sistema operativo, máquina
uart = máquina.UART(0, 115200)
os.duterm(uart, 1)
UART en ESP32
Hay tres periféricos UART en el ESP32: UART0, UART1 y UART2. Cada UART está conectado a pines estándar como se indica en la siguiente tabla.
Al igual que con ESP32-DevKit-V1, solo están expuestos UART0 y UART2. Dependiendo de la variante ESP32, algunos de estos pines pueden compartirse o reservarse para flash, PSRAM u otros periféricos. Esto se muestra en la imagen de abajo.
Puertos UART en el módulo ESP32
MicroPython le permite multiplexar cualquier GPIO con los UART de hardware del ESP32. Entonces, independientemente de qué pines estándar estén expuestos o no, los tres UART se pueden usar en un script MicroPython. Al crear una instancia de un objeto UART para ESP32, los pines Rx y Tx también deben pasarse como argumentos.
Usando UART en ESP8266 y ESP32
ESP8266 y ESP32 se utilizan principalmente en aplicaciones de red con soporte Wi-Fi. En muchas de estas aplicaciones, el microcontrolador maestro que administra las funciones integradas es otro microcontrolador, mientras que el ESP8266 o ESP32 desempeñan un papel secundario en el manejo solo de la comunicación y la red. control. En estas aplicaciones, UART es la única opción para la comunicación de datos entre ESP8266/ESP32 y el controlador principal del dispositivo. Algunos sensores y módulos también pueden proporcionar una interfaz UART junto con I2C o SPI para comunicar datos de sensores o señales de control. Aquí nuevamente, se puede usar UART en ESP8266/ESP32.
Comunicación de datos serie UART con MicroPython
A continuación se muestra un ejemplo de script MicroPython para probar la comunicación UART en ESP8266.
importar sistema operativo, máquina
desde la importación de la máquina UART
os.dupterm(Ninguno, 1)
uart = UART(0, velocidad en baudios=9600)
uart.write('Hola')
uart.leer(5)
os.duterm(uart, 1)
A continuación se muestra un ejemplo de script MicroPython para probar la comunicación UART en ESP32.
desde la importación de la máquina UART
uart = UART(1, velocidad en baudios=9600, tx=33, rx=32)
uart.write('hola')
uart.leer(5)
