En entornos de producción, la precisión en el conteo de insumos es crítica para evitar fugas financieras y errores logísticos. Este proyecto surge como una solución robusta para automatizar el conteo de tarjetas plásticas y hojas mediante un sistema embebido basado en el ESP32. El objetivo principal fue desarrollar un dispositivo que no solo fuera preciso, sino también capaz de operar en condiciones industriales, integrando sensores ópticos de alta velocidad y una lógica de control avanzada para garantizar la integridad de los datos en tiempo real.
El proyecto consta de un ESP32 con un sistema contador de hojas y 2 foto-células/sensores para el procedimiento de trabajo.
El núcleo del sistema reside en una Máquina de Estados Finitos (FSM) programada en el ESP32, la cual gestiona el ciclo de trabajo evitando falsos positivos mediante el filtrado de señales de dos fotocélulas dispuestas en configuración diferencial. La arquitectura de hardware se centraliza en una PCB diseñada específicamente para este propósito, que integra una interfaz I2C para la visualización en LCD, una botonera industrial de cuatro comandos y salidas optoacopladas mediante relays para el control de actuadores externos. Este enfoque modular permite una alta mantenibilidad y una inmunidad superior al ruido electromagnético, factor común en plantas de fabricación.
La lista de Hardware de este proyecto es:
-ESP32
-Sensores digitales/fotocélulas
-LCD 1602 con módulo I2C
-Botonera de 4 salidas simple
-Salidas con relay
SUMINISTRO CONTROLADO
Fabricado en España
El resultado es un equipo compacto, escalable y de alta fiabilidad, Fabricado que transforma un proceso manual propenso a errores en una operación automatizada y auditable. La implementación de este sistema demuestra cómo la integración de microcontroladores modernos y un diseño de hardware dedicado puede optimizar costos en la pequeña y mediana industria. Actualmente, el diseño se encuentra optimizado para su integración en líneas de producción existentes, reafirmando el compromiso con la ingeniería de precisión y la eficiencia operativa.
App Inventor 2 es una plataforma en línea de código abierto que permite crear aplicaciones para dispositivos Android sin necesidad de conocimientos avanzados de programación. F
App Inventor 2 fue desarrollado por Google y posteriormente transferido al MIT (Instituto Tecnológico de Massachusetts).
Para este proyecto se creará una aplicación en App Inventor que se conecte a un slider a través de Bluetooth y lo controle desde un dispositivo programado con Arduino IDE
Aplicación en App Inventor que se conecte a un slider a través de Bluetooth y se controle desde un dispositivo Arduino con un ESP32, puedes seguir estos pasos generales:
Lado de la Aplicación en App Inventor:
1. Crear la Interfaz Gráfica:
2. Comienza un nuevo proyecto
3. Componentes Bluetooth: Añadir el componente Bluetooth al diseño.
4. Configurar Bluetooth:
Configurar el componente Bluetooth para buscar dispositivos y establecer la conexión.
Programar la Interacción con el Slider:
Programar la lógica que enviará los datos del slider a través de Bluetooth al dispositivo Arduino cuando se modifique su valor.
Manejar la Conexión y Desconexión:
Implementar lógica para gestionar la conexión y desconexión con el dispositivo Bluetooth.
Diseñar la Interfaz de Usuario:
Diseñar la interfaz de usuario para mostrar el estado de la conexión y otra información relevante.
En la pantalla de diseño, agrega un componente Slider desde la paleta de componentes.
Manejo del Slider y envío de datos:
En el bloque "BluetoothClient1.SendText", el valor del slider se convierte a una cadena (Text), ya que el módulo Bluetooth envía datos como texto.
Asegúrate de configurar correctamente el BluetoothClient1.Address con la dirección Bluetooth de tu dispositivo.
Conecta tu dispositivo Android a tu Arduino mediante Bluetooth.
Lado del Dispositivo Arduino (ESP32):
Preparar todo para poder configurar el ESP32 con Arduino IDE.
Programar la Lógica del ArduinoControlar el Slider (recibir datos)
Escribe un programa para el ESP32 que escuche los datos enviados por la aplicación a través de Bluetooth.
Implementa la lógica que ajustará el valor del slider según los datos recibidos a través de Bluetooth.
Controlar un slider en App Inventor 2 y enviar los datos al ESP32 a través de Bluetooth
Asegurarse tener un módulo Bluetooth conectado al microcontrolador.
// Importar la librería para el módulo Bluetooth
#include <SoftwareSerial.h>
SoftwareSerial BTSerial(10, 11); // RX, TX
void setup() {
Serial.begin(9600);
BTSerial.begin(9600);
}
void loop() {
if (BTSerial.available()) {
int valor = BTSerial.parseInt();
if (valor >= 0 && valor <= 255) {
// Aquí puedes utilizar el valor recibido como desees
analogWrite(9, valor); // Por ejemplo, controlar un LED con el valor del slider
}
}
}
Este código utiliza la librería SoftwareSerial para comunicarse con el módulo Bluetooth en los pines 10 y 11. Luego, lee el valor entero enviado desde la aplicación y lo utiliza para controlar un LED conectado al pin 9 (se puede ajustar esto según tu configuración).
Esta es la experiencia de ayudar a montar un sistema básico de monitorización cardíaca usando el sensor AD8232 y un entorno Arduino IDE. Veremos desde la configuración del hardware y la lectura de la señal ECG hasta los pasos para filtrar y visualizar el pulso en tiempo real. El objetivo es ofrecer una guía práctica, apta tanto para quien se inicia en electrónica biomédica como para quienes buscan incorporar un pequeño proyecto de pulso a sus aplicaciones IoT.
El AD8232 es un pequeño chip que se utiliza para medir la actividad eléctrica del corazón. Se buscará registrar la actividad eléctrica como un ECG o electrocardiograma. La electrocardiografía se utiliza para ayudar a diagnosticar diversas afecciones cardíacas, así como aprender más del corazón y hasta para armar detectores de mentiras.
Según su datasheet, “La potencia, el tamaño y el nivel de integración resultantes permiten a los diseñadores desarrollar dispositivos de monitorización cardíaca y de frecuencia cardíaca para su uso fuera de entornos de cuidados intensivos en áreas como la gestión de la salud personal y la monitorización remota de la salud.”
NOTA: Este dispositivo no está diseñado para diagnosticar o tratar ninguna condición.
Entendiendo el ECG
En términos generales, veamos qué representa un ECG y cómo podemos detectarlo. El ECG se divide en dos intervalos básicos, el intervalo PR y el intervalo QT, que se describen a continuación.
Sistema de conducción eléctrica del corazón: 1. Nodo SA; 2. Nódulo AV.
El corazón tiene cuatro cámaras: dos aurículas y dos ventrículos, izquierdos y derechos. La aurícula derecha recibe la sangre venosa del cuerpo y la envía al ventrículo derecho el cual la bombea a los pulmones, lugar en el que la sangre se oxigena y libera dióxido de carbono (CO2) y del que pasa a la aurícula izquierda. De aquí la sangre se deriva al ventrículo izquierdo, de donde se distribuye, al contraerse éste, a todo el cuerpo y regresa a la aurícula derecha cerrando el ciclo cardíaco.
Fuente de todo el contenido sobre el corazón: Wikipedia
Antes de sumergirnos en los detalles de la señal ECG, conviene recordar que la calidad de la medición depende en gran medida de una correcta colocación de los electrodos y de un adecuado filtrado del ruido. Asegúrate de mantener los cables lo más cortos posible y de trabajar en un entorno con mínimas interferencias eléctricas. Además, el sensor AD8232 incorpora detectores de “leads-off” (LO+ y LO–) que nos ayudarán a verificar si la piel y los electrodos están en buen contacto antes de empezar la lectura.
Actividad eléctrica del corazón
Intervalo PR
El intervalo PR es la onda inicial generada por un impulso eléctrico que viaja desde la aurícula derecha hacia la izquierda. La aurícula derecha es la primera cámara en ver un impulso eléctrico. Este impulso eléctrico hace que las cámaras se “despolaricen”. Esto lo obliga a contraerse y drenar la sangre desoxigenada de la vena cava superior e inferior hacia el ventrículo derecho. A medida que el impulso eléctrico viaja a través de la parte superior del corazón, hace que la aurícula izquierda se contraiga. La aurícula izquierda es responsable de recibir sangre recién oxigenada desde los pulmones hacia el ventrículo izquierdo a través de las venas pulmonares izquierda y derecha. Las venas pulmonares están rojas en el diagrama porque transportan sangre oxigenada. Todavía se les llama venas porque las venas llevan la sangre hacia el corazón. ¡Ciencia!
Intervalo QT El Intervalo QT
El QRS es un proceso complejo que genera el “bip” característico en los monitores cardíacos. Durante QRS ambos ventrículos comienzan a bombear. El ventrículo derecho comienza a bombear sangre desoxigenada hacia los pulmones a través de las arterias pulmonares izquierda y derecha. Las arterias pulmonares son azules en el diagrama porque transportan sangre desoxigenada. Todavía se les llama arterias porque las arterias llevan la sangre fuera del corazón. ¡Ciencia, otra vez! El ventrículo izquierdo también comienza a bombear sangre recién oxigenada a través de la aorta y hacia el resto del cuerpo. Después de la contracción inicial viene el segmento ST. El segmento ST es bastante silencioso eléctricamente, ya que es el momento en que los ventrículos esperan ser “repolarizados”. Finalmente, la onda T se hace presente para “re-ploarizar” activamente o relajar los ventrículos. Esta fase de relajación reinicia los ventrículos para ser llenados nuevamente por las aurículas.
Conexión de AD8232 con Microcontrolador:
Prueba con Arduino IDE
Conexión del hardware
En este texto, se conectará el AD8232 a un microcontrolador Arduino Uno y a un módulo ESP32 con pantalla OLED. ¡Construiremos un monitor cardíaco simple que le permitirá medir la actividad eléctrica del corazón en tiempo real!
Prueba con Arduino Uno
Arduino Uno original (usado para este proyecto)
Prueba con ESP32 + OLED
Para una cómoda representación del pulso
También probaré el ECG con un ESP32 que cuenta con una pantalla integrada.
Conexión de pines
El monitor de frecuencia cardíaca AD8232 cuenta con nueve conexiones desde el IC. Estos pines provienen de los pines en el IC, pero en realidad son agujeros a los que puede soldar cables o pines de cabecera.
Conectaremos cinco de los nueve pines de la placa Arduino y al ESP32 respectivamente. Los cinco pines que necesita están etiquetados GND, 3.3v, OUTPUT, LO- y LO+.
Board Label
Función
Conexión Uno/ESP32
GND
Ground
GND
3.3v
3.3v Power Supply
3.3v
OUTPUT
Output Signal
A0
LO-
Leads-off Detect –
11
LO+
Leads-off Detect +
10
SDN
Shutdown
No usado
Conexión del Sensor AD8232 con Arduino Uno (Atmega328P), ESP8266 y ESP32
AD8232
Atmega328P
ESP8266
ESP32
OUTPUT
A5
A0
23
LO+
2
1
LO-
3
2
3.3V
3.3
3.3
3.3
GND
GND
GND
GND
Código Para compilar Atmega 328P – Medición de pulso cardíaco:
// Previous values
int val;
float lowPass1;
float highPass1;
float rawSignal, rawSignal1, rawSignal2, rawSignal3;
int threshold1;
long bpm;
unsigned long t1, t2;
unsigned long milliseconds;
// -------- Functions --------- //
static inline void initTimer(void) {
/*Write code to initialize Timer 1*/
TCNT1 = 65223; // preload timer 65536-16MHz/256/200Hz (sampling frequency of the ECG)
TCCR1B |= (1 << CS12); // prescaler value of 256
TIMSK1 |= (1 << TOIE1); // enable timer overflow interrupt
}
static inline void initIOPorts(void) {
/*Write code to initialize the GPIO ports (pins) that you need*/
DDRB = 0b00100000;
}
static inline void initADC(void) {
/*Write code to initialize the ADC*/
ADMUX |= (1 << REFS0); // reference voltage on ADC as AVcc
ADCSRA |= (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); // ADC clock prescaler of 128
ADCSRA |= (1 << ADATE); // Enables ADC auto trigger
ADCSRB |= (1 << ADTS2) | (1 << ADTS1); // ADC triggers when Counter1 overflows
ADCSRA |= (1 << ADIE); // ADC interrupts enabled
ADCSRA |= (1 << ADEN); // enable ADC
ADCSRA |= (1 << ADSC); // start ADC conversion
}
void tiempo(void);
// ------ Interrupt Service Routine ------ //
ISR(TIMER1_OVF_vect) {
/*This is the interrupt service routine for Timer 1 Overflow*/
PORTB ^= 0b00100000;
TCNT1 = 65223; // preload timer
rawSignal = analogRead(A0);
tiempo();
val = 1;
}
ISR(ADC_vect) {
/*This is the interrupt service routine for the ADC
It is executed when the ADC completes a conversion.
*/
if (ADC > 512) // turn LED on or off
{
PORTB = 0b00100000;
// measure();
}
else
PORTB = 0b00000000;
rawSignal = ADC; //Store the ADC value in the variable ECG_rawsignal
val = 1;
}
void tiempo(void) {
static int counter;
static int counter2;
static long segundos;
counter++;
//Contador de segundos /////////////////////////////////////////////////////
if (counter > 200) {
counter = 0;
segundos++;
// Serial.print("***************************** Segundos de ejecición: ");
// Serial.print(segundos);
// Serial.println(" segundos *****************************");
}
/////////////////////////////////// Contador de milliseconds ///////////////
milliseconds = milliseconds + 5;
}
boolean serialMonitor = 0;
unsigned long lastMillisBpm[] = {0, 0, 0, 0, 0}; //A cuántos millis se detectó beat
unsigned long lastTimeBeat[] = {0, 0, 0, 0, 0}; //Tiempo entre pulso y pulso
int main(void) {
Serial.begin(115200); //Sets the data rate bits/s for serial data submission
pinMode(LED_BUILTIN, OUTPUT);
noInterrupts(); //Disable interrupts
initIOPorts(); //Initiate GPIO module
initTimer(); // Initiate timer module
initADC(); //Initiate ADC module
interrupts(); //Enable interrupts
while (1) {
Serial.flush(); //Waits for the transmission of outgoing serial data to complete
if (val == 1) { //Tests if val is equal to 1
// Filtered signal calculation
float highPass = -0.5096 * rawSignal - 0.6456 * rawSignal1 + 0.6456 * rawSignal2 + 0.5096 * rawSignal3;
float lowPass = 0.91 * lowPass1 + 0.045 * highPass + 0.045 * highPass1;
// Comparison with threshold
int threshold;
if (lowPass < 0) lowPass = -lowPass; // Calculates the module
if (lowPass > 10) threshold = 400;
else threshold = 0;
// Print the values on serial plotter/
if (serialMonitor) {
Serial.print(rawSignal);
Serial.print(",");
Serial.print(highPass);
Serial.print(",");
Serial.print(lowPass);
Serial.print(",");
Serial.print(threshold);
Serial.print(",");
Serial.println(bpm);
// Serial.print(",");
// Serial.println(milliseconds);
}
// if ()
rawSignal1 = rawSignal;
rawSignal2 = rawSignal1;
rawSignal3 = rawSignal2;
highPass1 = highPass;
lowPass1 = lowPass;
static int QRS = 0;
static int j = 0;
if (threshold == 400) {
if (!QRS) {
int k = j - 1;
if (k < 0) k = 4;
if ( milliseconds > lastMillisBpm[k] + 300 ) {
//Rutina de detección
QRS = 1;
if (!serialMonitor)Serial.print("QRS complex detected");
lastMillisBpm[j] = milliseconds;
//Compara los ultimos 2
long lastTime = lastMillisBpm[k] - lastMillisBpm[j] ;
if (lastTime > 300 && lastTime < 1200) {
lastTimeBeat[k] = lastTime;
}
int nuevosBpm=600000/lastTime;
j++;
}
else
{
if (!serialMonitor)Serial.println("Discard the pulse");
}
if (j > 5) j = 0;
}
else {
//There was a pulse
}
digitalWrite(LED_BUILTIN, HIGH);
}
else
QRS = 0;
digitalWrite(LED_BUILTIN, LOW);
long testPulse = lastMillisBpm[2] - lastMillisBpm[1];
bpm = 60000 / (testPulse);
if (!serialMonitor) Serial.print(testPulse);
if (!serialMonitor) Serial.print(",");
if (!serialMonitor) Serial.println(bpm);
///////////////////////////////////////////Serial.println("bpm" + bpm);
threshold1 = threshold;
val = 0;
}
}
return 0; /* This line is never reached */
}
Ahora la detección de pulsaciones:
Con este montaje y el código de ejemplo ya puedes capturar y procesar tu pulso cardíaco en tiempo real. Como siguiente paso, podrías mejorar la visualización integrando una pantalla OLED o enviando los datos a una plataforma web (por ejemplo, usando MQTT o HTTP). Asimismo, explorar ajustes de filtro más avanzados o implementar detección automática de arritmias te permitirá convertir este prototipo en una herramienta aún más potente para proyectos de salud conectada.
Como técnico, programar dispositivos electrónicos es una habilidad crucial para trabajar con dispositivos inteligentes. Ya sea un microcontrolador como el ESP8266 o un dispositivo como la Raspberry Pi, la programación es esencial para crear dispositivos funcionales y eficientes.
En este artículo, exploraremos los pasos necesarios para programar dispositivos electrónicos y conectarlos a otros sistemas. También hablaremos de cómo programar utilizando el lenguaje de programación C, así como del software recomendado para las tareas de programación. Sumerjámonos en el mundo de la programación y descubramos cómo crear asombrosos dispositivos inteligentes.
Conexiones electrónicas
La ingeniería electrónica es una habilidad esencial para un técnico, y las conexiones adecuadas son la columna vertebral del éxito de los sistemas. El kit Elegoo proporciona un completo conjunto de herramientas y componentes para construir y programar aparatos electrónicos, incluidos cables y conectores, que deben ser de alta calidad y compatibles con el aparato. Con las conexiones adecuadas, el programa puede cargarse y ejecutarse correctamente, lo que permite controlar el aparato.
Programar aparatos electrónicos requiere saber cómo conectarlos al microcontrolador. ESP8266, Raspberry Pi y Arduino son candidatos potenciales para esta tarea. Para programar el comportamiento del dispositivo, se suele emplear software y lenguaje de programación C. Además, es esencial depurar el código para asegurarse de que el dispositivo funciona correctamente. Se recomiendan KiCAD, ProfiCAD, AutoCAD Electrical 2020 y NI Multisim para la programación, incluida la depuración.
Programar dispositivos electrónicos es un esfuerzo de colaboración que implica múltiples recursos. En el proceso intervienen doce recursos, una presentación, cinco valoraciones y diez asistentes. Trabajar con otros es necesario para garantizar que el dispositivo funciona como se espera y cumple sus especificaciones. Además, con las conexiones adecuadas, es posible integrar aparatos electrónicos con otras tecnologías, como Google Home, para conseguir una experiencia de usuario intuitiva.
Programación en C
Como técnico interesado en codificar componentes electrónicos, es esencial tener un conocimiento profundo de la programación en C. Este lenguaje de programación se utiliza habitualmente para crear firmware para microcontroladores y otro hardware. Una de sus principales ventajas es que otorga a los usuarios un acceso de bajo nivel al hardware, lo que permite un mayor control sobre los dispositivos. Dominando el lenguaje C, puedes programar dispositivos electrónicos con mayor precisión y eficacia.
Si piensas programar dispositivos electrónicos en C, debes obtener un programador compatible con el dispositivo. Un programador es un dispositivo que te permite transferir código a un microcontrolador o a otro hardware. Existe una amplia gama de programadores, cada uno con sus propias ventajas e inconvenientes. Elegir el mejor programador para tu proyecto es esencial para que sea un éxito.
Para iniciarse en la programación en C, es importante dedicar tiempo a aprender los fundamentos del lenguaje. Hay varios recursos disponibles en Internet, como tutoriales, vídeos y foros, que pueden ayudarte con esto. Además, tener acceso a herramientas de software como compiladores y depuradores puede ayudarte a escribir y probar tu código. Con los recursos y herramientas adecuados, puedes convertirte en un experto en codificación de dispositivos electrónicos utilizando el lenguaje C.
Mecatrónica y diseño industrial
La mecatrónica y el diseño industrial han revolucionado la forma en que interactuamos con los aparatos electrónicos. Para tener éxito en este campo, los técnicos deben ser expertos en lenguajes de codificación, ingeniería electrónica e ingeniería mecánica. Con la ayuda de microcontroladores como Arduino y Raspberry Pi, pueden crear dispositivos electrónicos únicos que cumplan las especificaciones deseadas. Es esencial que estos artilugios electrónicos estén correctamente programados para realizar las tareas previstas, lo que requiere comprender su comportamiento y programarlos en consecuencia.
Para destacar en mecatrónica y diseño industrial, es esencial dominar el lenguaje de programación. El lenguaje de programación C es uno de los lenguajes de codificación más utilizados en este campo. Es un lenguaje de alto nivel sencillo de aprender y aplicar. Los programadores lo utilizan para desarrollar programas complejos que se comunican con aparatos electrónicos y sensores.
El diseño de aparatos electrónicos también requiere un gran conocimiento del aspecto mecánico del aparato. Los técnicos tienen que asegurarse de que el aparato sea estéticamente agradable y eficiente. Para conseguirlo, tienen que conocer los principios del diseño mecánico y las prácticas de producción. Se utiliza software como KiCAD, ProfiCAD, AutoCAD Electrical 2020 y NI Multisim para generar modelos 3D del aparato. Además, se emplea software CAD para construir los componentes electrónicos y los circuitos del dispositivo.
A medida que avanza la tecnología, los diseñadores mecatrónicos e industriales deben mantenerse al día de las nuevas tendencias y tecnologías. Se les anima a asistir a conferencias y talleres para conocer los últimos lenguajes y técnicas de codificación. Es aconsejable establecer contactos con otros profesionales del sector para intercambiar información y experiencias. A medida que siga aumentando la demanda de aparatos electrónicos personalizados, los técnicos en mecatrónica y diseño industrial tendrán un papel más importante en la industria electrónica.
La librería WiFiManager simplifica el proceso de configuración y gestión de conexiones WiFi en los módulos ESP32 y ESP8266. Proporciona una forma fácil de configurar y almacenar las credenciales de red WiFi, permitiendo que los dispositivos se conecten a las redes de manera autónoma y se recuperen de forma automática en caso de desconexiones.
El “WiFiManager” es una biblioteca diseñada para facilitar la configuración y administración del Wi-Fi en dispositivos IoT basados en los microcontroladores ESP32 y ESP8266. Esta biblioteca ofrece una forma conveniente de crear un portal de configuración basado en la web, lo que permite a los usuarios ingresar las credenciales de Wi-Fi sin necesidad de cargar un nuevo código en el dispositivo.
El proceso de funcionamiento del WiFiManager se puede describir en los siguientes pasos:
Inclusión de la biblioteca: En primer lugar, es necesario incluir la biblioteca WiFiManager en el proyecto. Esto se puede realizar descargando e instalando la biblioteca desde el administrador de bibliotecas de Arduino IDE o mediante el uso de un gestor de paquetes como PlatformIO.
Creación de una instancia del WiFiManager: Se crea una instancia del objeto WiFiManager en el código del proyecto.
#include <WiFiManager.h>
WiFiManager wifiManager;
Inicialización y conexión:
Antes de utilizar el WiFiManager, es necesario inicializarlo y conectarlo al punto de acceso Wi-Fi existente. Si se encuentran credenciales de Wi-Fi almacenadas previamente, el dispositivo se conectará automáticamente. En caso contrario, se iniciará el portal de configuración.
void setup() {
// Inicializar el WiFiManager
wifiManager.autoConnect("MiDispositivo");
// Resto del código de configuración o funcionalidad
}
En el ejemplo anterior, “MiDispositivo” es el nombre del punto de acceso que se creará si no se encuentran credenciales de Wi-Fi almacenadas. Este nombre puede modificarse según las preferencias del usuario.
Portal de configuración:
Si no se encuentran credenciales de Wi-Fi almacenadas, el WiFiManager iniciará un portal de configuración. Esto implica que el ESP32/ESP8266 actuará como un punto de acceso Wi-Fi al cual es posible conectarse desde un dispositivo móvil o una computadora.
Al conectarse a este punto de acceso, se abrirá automáticamente una página de configuración basada en la web, donde los usuarios pueden ingresar las credenciales de su red Wi-Fi. Una vez que las credenciales se ingresen y envíen, el ESP32/ESP8266 se conectará a la red Wi-Fi especificada y recordará estas credenciales para futuros usos.
Almacenamiento de la configuración:
Después de que el WiFiManager se conecte exitosamente a la red Wi-Fi especificada, almacenará las credenciales en la memoria no volátil del dispositivo (por ejemplo, en el ESP32/ESP8266). Esto permite que las credenciales se utilicen en las próximas ejecuciones, sin necesidad de ingresarlas nuevamente cada vez que se reinicie el dispositivo.
LoRa es una tecnología inalámbrica versátil y eficiente en energía que se utiliza comúnmente en aplicaciones de IoT, seguimiento remoto y comunicaciones de larga distancia. Su capacidad para alcanzar distancias significativas con bajo consumo de energía la hace adecuada para una variedad de casos de uso en los que se requiere una conectividad inalámbrica confiable y de bajo costo.
TTGO LoRa32 SX1276 OLED es una placa de desarrollo ESP32 con un chip LoRa integrado y una pantalla OLED SSD1306 de 0,96 pulgadas. En esta guía, le mostraremos cómo: enviar y recibir paquetes LoRa (comunicación punto a punto) y usar la pantalla OLED con Arduino IDE.
Utilizando Arduino IDE para la comunicación LoRa y la pantalla OLED SSD1306 de 0,96 pulgadas. Asegúrate de que ya tengas Arduino IDE instalado en tu computadora antes de empezar.
Paso 1: Preparación del Hardware
Asegurarse de que la placa TTGO LoRa32 SX1276 OLED esté correctamente conectada al ordenador a través de un cable USB.
Paso 2: Instalación del Soporte de ESP32 en Arduino IDE
Abrir Arduino IDE.
“Archivo” -> “Preferencias”.
En la sección “URLs adicionales de tarjetas de gestor de tarjetas”, agregar la siguiente URL, clic en
