El FINGERPRINT 071405 es un sensor óptico de huella digital compacto y fácil de integrar en proyectos de seguridad y acceso biométrico. Ofrece detección rápida y un alto nivel de precisión, lo que lo convierte en una opción recomendada para cerraduras inteligentes, control de asistencia y aplicaciones IoT.
Principio de funcionamiento
Captura óptica: Una pequeña cámara CMOS interna ilumina el dedo con un LED infrarrojo y toma una imagen de la huella.
Procesado interno: El propio módulo extrae los “minucias” (optimiza las crestas y valles) y genera un template digital.
Comparación: El microcontrolador puede enviar patrones de huella almacenados para comprobación o pedir al sensor que registre un nuevo usuario.
Especificaciones técnicas
Resolución: 500 dpi
Interface: UART TTL (3,3 V lógico)
Voltaje de alimentación: 3,6 V – 6 V
Corriente en reposo: ≈ 40 mA
Corriente en captura: ≈ 60 mA
Tiempo de verificación: < 1 s
Plantillas almacenables: hasta 2 000
Dimensiones: 35 × 20 × 16 mm
Conexión al microcontrolador
Alimentación: VIN a 5 V, GND a masa.
Datos:
TX del sensor → RX del microcontrolador
RX del sensor → TX del microcontrolador
Nivel lógico: Si se trabaja a 3,3 V, asegurar que VIN sea ≥ 3,6 V y usar un conversor de nivel para la señal RX.
#include <WiFi.h>
const char* ssid = "Nombre_Red_Servidor";
const char* password = "Contraseña_Servidor";
WiFiServer server(80);
int buttonPin = 5;
int buttonState = 0;
void setup() {
Serial.begin(115200);
pinMode(buttonPin, INPUT_PULLUP);
// Configurar el ESP32 como un punto de acceso
WiFi.softAP(ssid, password);
IPAddress IP = WiFi.softAPIP();
Serial.print("AP IP address: ");
Serial.println(IP);
server.begin();
Serial.println("Server started");
}
void loop() {
WiFiClient client = server.available();
if (client) {
//Serial.println("New client connected");
while (client.connected()) {
// Leer el estado del botón
buttonState = 99;
//String response = String(buttonState) + "," + String(analogRead(A0)) + "," + String(random(100));
//client.println(response);
if (client.available()) {
String request = client.readStringUntil('\r');
Serial.print("Client says: ");
Serial.print(request);
Serial.print(", ");
int b = request.length();
//Serial.print("b=");
//Serial.println(b);
if (b > 2) {
int value1 = request.substring(0, request.indexOf(',')).toInt();
request = request.substring(request.indexOf(',') + 1);
int value2 = request.toInt();
Serial.print("Received values from client: ");
Serial.print(value1);
Serial.print(", ");
Serial.println(value2);
}
}
//////// cada 3 segundos envia
static unsigned long a;
if (millis() > a + 5000) {
a = millis();
// Enviar dos variables simuladas al servidor
int value1 = 2; // Valor simulado 1
int value2 = 4; // Valor simulado 2
int value3 = 6; // Valor simulado 2
String response = String(value1) + "," + String(value2)+ "," + String(value3);
//String response = String(buttonState) + "," + String(analogRead(A0)) + "," + String(random(100));
Serial.print("Sending response: ");
Serial.println(response);
client.println(response);
client.stop();
}
}
//Serial.println("Client disconnected");
}
}
Cliente:
#include <WiFi.h>
const char* ssid = "Nombre_Red_Servidor"; // Reemplaza con el SSID de tu red
const char* password = "Contraseña_Servidor"; // Reemplaza con la contraseña de tu red
const char* serverIP = "192.168.4.1"; // Reemplaza con la dirección IP del servidor
const int serverPort = 80;
void setup() {
Serial.begin(115200);
Serial.println("Conectándose a la red WiFi...");
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.print("Conectado a la red WiFi. Dirección IP: ");
Serial.println(WiFi.localIP());
}
void loop() {
// Simular dos valores enteros para enviar al servidor
int value1 = 1; // Valor simulado 1 (número aleatorio entre 0 y 9)
int value2 = 3; // Valor simulado 2 (número aleatorio entre 0 y 99)
// Construir la solicitud al servidor en el formato "value1,value2"
String request = String(value1) + "," + String(value2);
Serial.print("Enviando solicitud al servidor: ");
Serial.println(request);
// Establecer la conexión con el servidor
WiFiClient client;
if (client.connect(serverIP, serverPort)) {
// Enviar la solicitud al servidor
client.println(request);
// Esperar la respuesta del servidor
String response = client.readStringUntil('\r');
Serial.print("Respuesta del servidor: ");
Serial.println(response);
// Si necesitas utilizar los valores de la respuesta separados por comas, puedes hacerlo de la siguiente manera:
int serverValue1 = response.substring(0, response.indexOf(',')).toInt();
response = response.substring(response.indexOf(',') + 1);
int serverValue2 = response.substring(0, response.indexOf(',')).toInt();
//response = response.substring(response.indexOf(',') + 1);
//int serverValue3 = response.toInt();
Serial.print("Valores recibidos del servidor: ");
Serial.print(serverValue1);
Serial.print(", ");
Serial.print(serverValue2);
//Serial.print(", ");
//Serial.println(serverValue3);
}
// Esperar 5 segundos antes de enviar una nueva solicitud
delay(5000);
}
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).
Medir el ángulo de inclinación usando el giroscopio/acelerómetro MPU6050 y Arduino
Se puede medir el ángulo de inclinación usando MPU6050 simplemente conectando el sensor giroscópico/acelerómetro de 6 ejes MPU6050. El acelerómetro envía fuerzas de aceleración X, Y y Z. Necesitamos convertir las fuerzas en ángulos 3D X, Y, Z para determinar la orientación 3D del sensor.
El giroscopio mide la velocidad de rotación o la tasa de cambio de la posición angular a lo largo del tiempo, a lo largo de los ejes X, Y y Z. Utiliza tecnología MEMS y el efecto Coriolis para medir. Las salidas del giroscopio están en grados por segundo, por lo que para obtener la posición angular, sólo necesitamos integrar la velocidad angular.
El acelerómetro puede medir la aceleración gravitacional a lo largo de los 3 ejes y usando algunas matemáticas de trigonometría podemos calcular el ángulo en el que está posicionado el sensor. Entonces, si fusionamos o combinamos los datos del acelerómetro y el giroscopio del MPU6050, podemos obtener información muy precisa sobre la orientación del sensor. Por lo tanto, MPU6050 con Arduino puede medir el ángulo de inclinación.
Giroscopio/acelerómetro MPU6050
El sensor InvenSense MPU-6050 contiene un acelerómetro MEMS y un giroscopio MEMS en un solo chip. Es muy preciso, ya que contiene un hardware de conversión de analógico a digital de 16 bits para cada canal. Por lo tanto, captura los canales x, y y z al mismo tiempo. El sensor utiliza el bus I2C para interactuar con Arduino.
El MPU-6050 no es caro, especialmente teniendo en cuenta que combina un acelerómetro y un giroscopio.
Distribución de pines del MPU6050:
El módulo MPU-6050 tiene 8 pines: INT: Interrumpe el pin de salida digital. AD0: pin LSB de dirección esclava I2C. Este es el bit 0 en la dirección esclava de 7 bits del dispositivo. Si está conectado a VCC, se lee como uno lógico y la dirección del esclavo cambia. XCL: Pin de reloj serie auxiliar. Este pin se utiliza para conectar el pin SCL de otros sensores habilitados para interfaz I2C al MPU-6050. XDA: Pin de datos serie auxiliar. Este pin se utiliza para conectar el pin SDA de otros sensores habilitados para interfaz I2C al MPU-6050. SCL: pin de reloj serie. Conecte este pin al pin SCL del microcontrolador. SDA: pin de datos serie. Conecte este pin al pin SDA del microcontrolador. GND: clavija de tierra. Conecte este pin a la conexión a tierra. VCC: Pin de fuente de alimentación. Conecte este pin al suministro de +5 V CC. Giroscopio de 3 ejes:
El MPU6050 consta de un giroscopio de 3 ejes con tecnología Micro Electro Mechanical System (MEMS). Se utiliza para detectar la velocidad de rotación a lo largo de los ejes X, Y, Z como se muestra en la siguiente figura.
Oreintation y Polaridad de rotación – MPU6050
Acelerómetro de 3 ejes:
El MPU6050 consta de un acelerómetro de 3 ejes con tecnología microelectromecánica (MEM). Solía detectar el ángulo de inclinación o inclinación a lo largo de los ejes X, Y y Z como se muestra en la siguiente figura.
Ángulo de inclinación
Diagrama de circuito y conexión
MPU6050 tiene pines I2C. Por lo tanto, debe estar conectado a los pines I2C de Arduino. Conecte los pines SDA de MPU6050 a A4 de Arduino y SCL a A5. Suministre una entrada de 5 V al MPU6050 y también conecte el GND como se muestra en la siguiente figura.
Conexión del MPU6050 con el Microcontrolador
Ejemplos: Wemos D1 Mini y Arduino Uno
Conectar MPU6050 con Arduino IDE + Arduino Uno
Código fuente/programa
A continuación se muestra el código para medir el ángulo de inclinación usando MPU6050 y Arduino. Copie el código y cárguelo en la placa Arduino.
Así como las matrices permiten definir el tipo de variables que pueden contener varios elementos de datos del mismo tipo, ee manera similar, las Estructuras son otro tipo de datos definido por el usuario que permite combinar elementos de datos de diferentes tipos.
En C, las estructuras son una colección de variables agrupadas por conveniencia.
En C++ son lo mismo que una clase excepto que los miembros de la estructura son públicos por defecto.
struct pcb
{
String model ; // Nombre del modelo
int npd ; // Numero de pines digitales
int npa ; // Numero de pines analogicos
float volt ; // Tension de funcionamiento
} ;
void setup() {
Serial.begin(115200);
pcb PLACA_UNO_R3;
// Asignación de valores
PLACA_UNO_R3.model = "uno" ;
PLACA_UNO_R3.npd = 13 ;
PLACA_UNO_R3.npa = 5 ;
PLACA_UNO_R3.volt = 5.0F ;
// Lectura de valores
int numpd = PLACA_UNO_R3.npd ;
float voltage = PLACA_UNO_R3.volt ;
Serial.print("\nVoltaje: ");
Serial.println(voltage);
Serial.print("Numero de pines digitales: ");
Serial.println(numpd);
Serial.print("Numero de pines analogicos: ");
Serial.println(PLACA_UNO_R3.npa);
Serial.print("Modelo de PCB: ");
Serial.println(PLACA_UNO_R3.model);
}
void loop() {
}
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.
Node-RED es una herramienta de código abierto para la programación visual que permite crear aplicaciones de Internet de las cosas (IoT).
Node-RED se ejecuta en el navegador web y utiliza una programación visual que le permite conectar bloques de código, conocidos como nodos, para realizar una tarea. Los nodos cuando se conectan entre sí se denominan flujos.
Características:
Es accesible a una gama más amplia de usuarios.
Permite ahorrar tiempo, pues no se escribe código (… ¿Tu qué opinas?)
Es código abierto y desarrollado por IBM,
Raspberry Pi puede ejecutar Node-RED,
¿Qué se puede hacer con Node RED?
Node-RED permite:
Acceder a los GPIO;
Establecer una conexión MQTT con otros dispositivos (Usando Arduino IDE, ESP8266, ESP32, etc.);
Cree una interfaz gráfica de usuario receptiva para sus proyectos;
Comunicarse con servicios de terceros (IFTTT.com, Adafruit.io, ThingSpeak, Home Assistant, InfluxDB etc);
Recuperar datos de la web (pronóstico del clima, precios de acciones, correos electrónicos, etc.);
Preguntará si se quiere instalar Node Red, luego preguntará: “Would you like to install Pi-specific nodes?” Presionar Y, luego Enter.
Tomará unos minutos instalar Node-RED. Al final, debería recibir un mensaje similar en la ventana de Terminal:
Configurar Node-RED Settings
Después de la instalación, se recomienda configurar las opciones y configuraciones iniciales.
Ejecución del siguiente comando:
node-red admin init
Press Enter to create a Node-RED Settings file on /home/pi/.node-red/settings.js
Do you want to set up user security? Yes.
Enter a username -> Luego presionar Enter (admin).
Enter a password -> Luego presionar Enter (adminadmin).
Luego, debe definir los permisos de usuario. Configuraremos el acceso completo, nos aseguraremos de que la opción de acceso completo esté resaltada en azul y presione Enter.
Se pueden agregar otros usuarios con diferentes permisos. Solo se creará un usuario por ahora. Se puden agregar otros usuarios más luego.
Do you want to enable the Projects feature? No.
Enter a name for your flows file. (Presionar Enter para seleccionar el nombre por defecto flows.json).
Provide a passphrase to encrypt your credentials file. (huecat) Aprende más sobre qué es una passphrase.
Select a theme for the editor. Presionar Enter para seleccionar por default.
Press Enter again to select the default text editor.
Allow Function nodes to load external modules? Yes.
La configuración de Node-RED fue exitosa. Todos los ajustes se guardan en settings.js.
Iniciar Node-RED
Correr el siguiente comando para iniciar Node-RED:
node-red-start
Debería verse algo así en la Terminal:
Auto-Inicio / Autostart Node-RED
Para ejecutar Node-RED automáticamente cuando se inicia el Pi, debe ingresar el siguiente comando. Esto significa que mientras su Raspberry Pi esté encendida, Node-RED estará funcionando.
sudo systemctl enable nodered.service
Ahora, reinicie su Pi para que el inicio automático surta efecto. La próxima vez que se reinicie la Raspberry Pi, Node-RED ya se estará ejecutando.
sudo reboot
If, later on, you want to disable autostart on boot, you can run:
sudo systemctl disable nodered.service
Para obtener más información sobre el proceso de instalación, consulte la official documentation.
Access Node-RED
Node-RED se ejecuta en el puerto 1880. Para acceder a Node-RED, abra un navegador y escriba la dirección IP de Raspberry Pi seguida de: 1880. Por ejemplo:
192.168.1.102:1880
Para obtener su dirección IP de Raspberry Pi, puede ejecutar el siguiente comando:
hostname -I
Después de ingresar la dirección IP de Raspberry Pi seguida de: 1880 en el navegador web, obtendrá acceso a la página de inicio de sesión de Node-RED. Inicie sesión con el nombre de usuario y la contraseña que configuró anteriormente.
Ya se tiene el acceso a Node-RED. Ahora se puede comenzar a construir sus flujos.
Descripción General Node-RED
Echemos un vistazo a la interfaz visual de Node-RED.
Secciones principales de la interfaz Node-RED
La siguiente imagen muestra las secciones principales de Node-RED etiquetadas.
Nodes / Nodos
En la barra lateral izquierda, puede ver una lista con un montón de bloques. Estos bloques se denominan nodos y están separados por su funcionalidad. Si se selecciona un nodo, se puede ver cómo funciona en la pestaña de documentación de los nodos.
Los nodos tienen puertos de entrada y/o salida para recibir y enviar información a otros nodos. Por ejemplo, un nodo recibe una entrada de un nodo anterior, procesa esa información y envía un mensaje diferente a otro nodo que hará algo con esa información. La información que se pasa entre los nodos se denomina mensaje.
Flow
Los nodos son los componentes básicos de un flujo. Conecta los nodos para crear un flujo que realizará una determinada tarea. Un Flujo también es una pestaña en el espacio de trabajo donde coloca y organiza los nodos.
En el centro, tienes el Flujo y aquí es donde colocas los nodos.
Barra lateral derecha
La barra lateral a la derecha tiene varias herramientas.
Información: muestra información sobre los flujos;
Ayuda: muestra la documentación de los nodos;
Debug/Depurar: el icono de error abre una ventana de depuración que muestra los mensajes pasados a los nodos de depuración; es útil para fines de depuración;
Config nodes/Nodos de configuración: el icono de engranaje muestra información sobre los nodos de configuración. Los nodos de configuración no aparecen en el espacio de trabajo principal y son nodos especiales que contienen configuraciones reutilizables que pueden compartir varios nodos en un flujo.
Implementación
El botón de implementación guarda todos los cambios realizados en el flujo y comienza a ejecutar el flujo.
Creando un flujo simple
Para que se acostumbre a la interfaz de Node-RED, creemos un flujo simple. El flujo que crearemos, simplemente imprime un mensaje en la consola de depuración, cuando se activa.
Arrastre un nodo de inyección y un nodo de depuración a su flujo y conéctelos.
Ahora, editemos el nodo de inyección. Haga doble clic en el nodo. En la figura a continuación, puede ver las diferentes configuraciones que puede cambiar.
En el campo msg.payload , seleccione una cadena y escriba Hola. Luego, haz clic en Listo.
Messages (msg) in Node-RED are javascript objects that can have multiple properties. The payload is the default property most nodes work with. You can think of it as the main content of the message you want to send to the next node. In our case, we’re simply sending a text message.
We won’t edit the debug node, but you can double-click on it to check its properties.
////////////////////////////////////////////////////////// HASTA ACA
You can select the output of the debug node, which is msg.payload and where we want to send that output. In our case, we want to send it to the debug window.
To save your application, you need to click the Deploy button in the top right corner.
Your application is saved.
Testing the flow
Let’s test our simple flow. Open the debug window and click the inject node to trigger the flow.
As you can see, our message is printed in the debug window when you trigger the inject node. This is a very basic example and it doesn’t do anything useful. However, the purpose of this post is to get you familiar with the Node-RED interface. In no time, you’ll start creating your own flows.
Exporting and Importing Nodes
In this section, you’ll learn how to save your nodes. This is useful if you need to:
Backup your Node-RED flow
Move your flow to another Raspberry Pi (or machine)
Share your Node-RED project with others
Open the main menu, and select the Export option.
A new window opens. You can select if you want to save the selected nodes, the current flow, or all flows. You can also download the nodes as a JSON file or copy the JSON to the clipboard.
To show you how it works, click on Download for the selected nodes. It will download a JSON file called flows.json.
You can import those nodes later to another Raspberry Pi or another machine with Node-RED installed, by going to the main menu and selecting the Import option.
On the Import nodes window, you can upload a JSON file or paste raw JSON.
Installing Pallete Nodes
As we’ve seen previously, Node-RED comes with a bunch of pre-installed nodes on the Pallete (left sidebar). There are many more nodes available that you can install and use for your projects. You can find them in the Node-RED library. If you need some specific task for your project, there’s probably already a node for that.
For example, if you need to add the feature to send an email to your flow, you can google something like this: “send email node-red node”. One of the first search results is this page with the node-red-node-email. It comes with some nodes to send and receive emails.
If you want to install those nodes (or any other nodes) so that you can use them on your flow, go to the main menu and select the option Manage palette.
The following window will open. Select the install tab and search for the nodes you want to install, for example, node-red-node-email.
Node-RED Dashboard
Node-RED Dashboard is a module that provides a set of nodes in Node-RED to quickly create a live data dashboard. You can install those nodes using the Menu > Manage Palette. Then, search for node-red-dashboard and install it.
After installing, the dashboard nodes will show up on the palette.
Nodes from the dashboard section provide widgets that show up in your application user interface (UI). The user interface is accessible on the following URL:
Utilización de Node-RED para controlar las entradas/salidas del ESP8266/ESP32 y mostrar los datos de sensores en su interfaz.
El software Node-RED se ejecuta en una Raspberry Pi y la comunicación entre el ESP8266 y el software Node-RED se realiza a través del protocolo de comunicación MQTT.
La comunicación entre Arduino IDE y Node-RED a través del protocolo MQTT permite intercambiar datos y comandos entre un dispositivo basado en ESP8266 o ESP32 (programado con Arduino IDE) y un servidor Node-RED que se ejecuta en otra máquina, como una Raspberry Pi.
Preparación del entorno:
Asegurarse que Node-RED esté instalado y en funcionamiento en la máquina que actuará como servidor.
Configurar un servidor MQTT y verifica que esté en funcionamiento en la misma máquina que Node-RED.
Conecta tu ESP8266 o ESP32 a la red Wi-Fi para que pueda acceder al servidor MQTT.
Uso de la librería PubSubClient en Arduino IDE:
En Arduino IDE, instalar la librería PubSubClient para facilitar la comunicación MQTT.
Configura tu dispositivo ESP8266 o ESP32 para conectarse a la red Wi-Fi y establecer una conexión con el servidor MQTT utilizando la dirección IP y el puerto correspondientes.
Envío* de mensajes MQTT desde Arduino IDE:
Una vez establecida la conexión MQTT, utilizar la función client.publish() para enviar mensajes al servidor Node-RED.
Define un “topic” específico para cada tipo de mensaje que desees enviar. Esto permitirá que el servidor Node-RED identifique y procese la información adecuadamente.
Opcional: Recepción de mensajes MQTT en Arduino IDE*:
Para recibir mensajes del servidor Node-RED, puedes utilizar la función client.subscribe() para suscribirte a ciertos “topics” MQTT desde tu código de Arduino. De esta manera, tu dispositivo puede recibir comandos o información desde el servidor.
Configuración de Node-RED:
En Node-RED, configurar el nodo MQTT para que se conecte al servidor MQTT que está en funcionamiento en la Raspberry Pi u otra máquina.
Utiliza el nodo MQTT para escuchar los “topics” a los que tu ESP8266/ESP32 está publicando y/o suscrito.
Procesamiento de mensajes en Node-RED:
Una vez que Node-RED reciba los mensajes de un dispositivo ESP8266/ESP32, puedes procesarlos utilizando diferentes nodos para la lógica y la visualización. Esto te permitirá realizar acciones o presentar los datos recibidos según tus necesidades.
Desarrollo de un sistema de transmisión automatizada para bicicletas, diseñado para optimizar la experiencia de pedaleo sin necesidad de intervención manual. El núcleo de la propuesta reside en la capacidad del sistema para interpretar el ritmo del ciclista y ajustar los cambios de marcha de forma autónoma, permitiendo una conducción más fluida y eficiente, especialmente en terrenos variables donde la gestión constante de la cadencia es crucial.
A nivel técnico, la solución integra ingeniería mecatrónica avanzada utilizando una placa Arduino Uno como cerebro del sistema. La lectura del entorno se realiza mediante un sensor PAS (Pedal Assist Sensor), que monitorea la velocidad de pedaleo en tiempo real. Esta información es procesada algorítmicamente para determinar el momento exacto del cambio, mientras que un módulo de pantalla OLED proporciona al usuario una interfaz visual clara del estado del sistema y la marcha activa.
Más allá de su funcionalidad mecánica, este desarrollo destaca como una aplicación práctica de habilidades STEM (Ciencia, Tecnología, Ingeniería y Matemáticas), demostrando cómo componentes accesibles pueden modernizar mecanismos de transporte tradicionales. El resultado es un prototipo funcional que no solo resuelve el problema de la gestión de marchas para ciclistas novatos o distraídos, sino que también sirve como una base sólida para futuras implementaciones en movilidad eléctrica y sistemas de asistencia inteligente.
Arduino IDE utiliza un lenguaje de programación basado en el estándar de C++, aunque proporciona una serie de funciones y bibliotecas específicas para facilitar la interacción con los componentes electrónicos. Aunque existen algunas diferencias y limitaciones en comparación con el C++ estándar, los principios básicos de la sintaxis son los mismos.
La sintaxis general para escribir el programa Arduino es casi similar a la del C y C++ ordinario. Aquellos que estén familiarizados con el C y C++ básico podrán comenzar a utilizarlo fácilmente.
Un programa Arduino se estructura principalmente en dos funciones: setup() y loop(). La función setup() se ejecuta una sola vez al inicio del programa y se utiliza para realizar la configuración inicial, como la inicialización de pines y la configuración de la comunicación serial. La función loop() es la parte principal del programa y se ejecuta continuamente en un ciclo infinito después de que setup() ha finalizado. Aquí es donde se colocan las instrucciones que se deben repetir una y otra vez, como leer sensores, tomar decisiones y controlar los actuadores.
La mayoría de las instrucciones en Arduino IDE siguen la estructura de la programación en C y C++. Por ejemplo, para asignar un valor a una variable, se utiliza el operador de asignación (=). Los operadores aritméticos como suma (+), resta (-), multiplicación (*), división (/) y módulo (%) también se utilizan de la misma manera.
Las estructuras de control como las condicionales (if, else if, else) y los bucles (for, while, do-while) se utilizan para tomar decisiones y repetir bloques de código, al igual que en C y C++. Estas estructuras permiten controlar el flujo del programa en función de ciertas condiciones o realizar iteraciones hasta que se cumpla una condición específica.
Además de la sintaxis básica, Arduino proporciona una amplia gama de bibliotecas predefinidas que contienen funciones listas para usar. Estas bibliotecas simplifican la interacción con dispositivos y módulos comunes, como sensores, pantallas LCD, motores, comunicación inalámbrica, entre otros. Al incluir una biblioteca específica, puedes aprovechar las funciones y métodos que ofrece para facilitar el desarrollo de tu proyecto.
En resumen, la sintaxis de código Arduino se basa en el lenguaje de programación C++ estándar, pero con algunas diferencias y bibliotecas adicionales. Aquellos familiarizados con C y C++ básico encontrarán que Arduino es fácil de aprender y utilizar. Con su sintaxis intuitiva y bibliotecas convenientes, Arduino se ha convertido en una plataforma popular para el desarrollo de proyectos electrónicos, desde simples experimentos hasta complejas aplicaciones embebidas.
