// Firmware Control Buck PID - v1.0 Release
#include <pwm.h>

const int PIN_SENSOR = A0;  // Entrada Divisor (Vout/2)
const int PIN_PWM = 9;      // Salida Gate Driver

// Constantes PID (L=100uH, C=33uF)
float Kp = 0.272253;
float Ti = 0.0015285;
float Ts = 20e-6;           // 50kHz Loop

// Variables PID
float u = 0.0, u_1 = 0.0;
float e = 0.0, e_1 = 0.0;
float q0, q1;
float Vref = 2.5;           // Target (2.5V leídos = 5.0V reales)

void setup() {
    // Coeficientes Tustin
    q0 = Kp * (1 + (Ts / (2 * Ti)));
    q1 = -Kp * (1 - (Ts / (2 * Ti)));
    
    // Configurar PWM Asíncrono
    InitTimersSafe();
    SetPinFrequencySafe(PIN_PWM, 50000); 
    pinMode(PIN_PWM, OUTPUT);
}

void loop() {
    // 1. Lectura ADC y Normalización
    float y_medida = analogRead(PIN_SENSOR) * (5.0 / 1023.0);
    
    // 2. PID Discreto
    e = Vref - y_medida;
    u = u_1 + q0 * e + q1 * e_1;
    
    // 3. Saturación y Anti-Windup (Crítico)
    if (u > 0.95) u = 0.95; 
    if (u < 0.00) u = 0.00;
    
    // 4. Actualización Estados
    u_1 = u;
    e_1 = e;
    
    // 5. Actuación
    pwmWrite(PIN_PWM, (int)(u * 255));
    
    // Estabilización de Ciclo
    delayMicroseconds(10);
}

The post Manual de Ingeniería: Buck Converter PID appeared first on HUE CAT INGENIERÍA ESPAÑA.

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.

1. 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.
2. Manejar la Conexión y Desconexión:
   • Implementar lógica para gestionar la conexión y desconexión con el dispositivo Bluetooth.
3. 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):

1. Preparar todo para poder configurar el ESP32 con Arduino IDE.
   • Si aún no has configurado el Arduino IDE para tu ESP32, puedes seguir estos pasos: Configurar el ESP32 con Arduino IDE
2. Programar la Lógica del Arduino Controlar 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).

The post Controlar un ESP32 (o esp8266) con Android utilizando AppInventor2 appeared first on HUE CAT INGENIERÍA ESPAÑA.

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

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 (CO₂) 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

Prueba con ESP32 + OLED

Para una cómoda representación del pulso

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

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.

The post Medición de pulso cardíaco con Sensor AD8232 y Arduino IDE appeared first on HUE CAT INGENIERÍA ESPAÑA.

Una de las grandes ventajas de Arduino IDE es la amplia variedad de bibliotecas predefinidas disponibles. Estas bibliotecas contienen funciones listas para usar que simplifican la interacción con dispositivos y módulos comunes. Al importar una biblioteca específica, se obtiene acceso instantáneo a métodos que facilitan tareas como leer sensores, controlar motores, comunicarse con pantallas y mucho más. La biblioteca estándar de Arduino es solo el comienzo; existen innumerables bibliotecas de terceros creadas por la comunidad Arduino que ofrecen aún más funcionalidades especializadas.

Además de las bibliotecas, Arduino también ofrece una serie de funciones y métodos integrados que son fundamentales para el desarrollo de proyectos electrónicos. Algunos ejemplos destacados son:

1. digitalRead() y digitalWrite(): Estas funciones permiten leer y escribir valores digitales en los pines de Arduino. Son esenciales para interactuar con botones, interruptores y otros dispositivos que funcionan con señales digitales.
2. analogRead() y analogWrite(): Arduino también cuenta con pines analógicos, y estas funciones permiten leer y escribir valores analógicos. Son especialmente útiles para trabajar con sensores de luz, temperatura y otros dispositivos que generan señales analógicas.
3. Serial: Arduino tiene soporte para la comunicación serial, lo que permite establecer una conexión con otros dispositivos, como una computadora. La clase Serial ofrece métodos para enviar y recibir datos a través del puerto serie, lo que es esencial para la depuración y la interacción con otros sistemas.
4. Wire: Esta biblioteca permite la comunicación I2C, un protocolo ampliamente utilizado para conectar múltiples dispositivos en un bus de dos hilos. Con los métodos proporcionados por la biblioteca Wire, es posible enviar y recibir datos entre Arduino y otros dispositivos compatibles con I2C.

Estas son solo algunas de las particularidades de Arduino que te permitirán aprovechar al máximo su potencial en tus proyectos. Explorar las bibliotecas, funciones y métodos específicos de Arduino te brindará un mayor control sobre tus componentes electrónicos y te permitirá crear proyectos más sofisticados. Además, no olvides que la comunidad Arduino es muy activa, por lo que siempre puedes buscar ejemplos, tutoriales y proyectos similares para inspirarte y aprender nuevas formas de utilizar Arduino en tus creaciones.

En conclusión, al destacar las particularidades de Arduino, como sus funciones y métodos específicos, los lectores podrán comprender mejor cómo aprovechar al máximo el potencial de Arduino en sus proyectos electrónicos. Explorar las bibliotecas predefinidas, aprender sobre las funciones integradas y estar al tanto de la comunidad Arduino te abrir

The post Funciones y métodos integrados en Arduino IDE appeared first on HUE CAT INGENIERÍA ESPAÑA.

En el procedimiento, cada ciclo fue programado como una «Máquina de Estados Finitos»

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

The post Circuito, Programación, Fabricación de PCB de Máquina Contadora de Tarjetas. appeared first on HUE CAT INGENIERÍA ESPAÑA.