la PCB se ha optimizado para reducir el ruido electromagnético en un entorno de maquinaria compacta. Se han integrado etapas de filtrado por hardware para las señales de los sensores ópticos y se ha priorizado una topología de alimentación con conversores DC-DC de alta eficiencia, minimizando la disipación térmica dentro de la carcasa. El resultado es un sistema embebido que no solo cumple con la velocidad de la mecánica, sino que extiende la vida útil del equipo al operar con márgenes de seguridad sobredimensionados.

Lista de materiales

El objetivo aquí es demostrar que no compras «lo más barato», sino lo que garantiza calidad industrial.

1. MCU: Módulo Espressif ESP32-WROOM-32E (Versión industrial con rango de temperatura extendido -40°C a +85°C).
2. Sensores Ópticos: Barreras fotoeléctricas Omron EE-SX671 (Conmutación de alta velocidad, 1kHz min) con conectores de bloqueo para evitar desconexiones por vibración.
3. Gestión de Energía: Convertidor Buck Texas Instruments serie LM2596 (Original) o módulo Traco Power, sustituyendo reguladores lineales LDO para una eficiencia >90% y cero calentamiento.
4. Conectividad: Borneras de conexión Phoenix Contact serie MKDS (contactos de aleación de cobre, no latón) para asegurar la integridad de la señal de los sensores externos.
5. Protección: Fusible rearmable (PTC) y diodo TVS en la entrada de alimentación para protección contra transitorios y polaridad inversa.

Ejemplo de programación

/*
 * FIRMWARE: Máquina Contadora de Tarjetas
 * PLATAFORMA: ESP32
 * AUTOR: [Tu Nombre/Firma]
 * DESCRIPCION: Sistema de conteo por interrupciones con filtrado digital
 * para entornos industriales ruidosos.
 */

#include <Arduino.h>

// --- PIN DEFINITIONS & CONSTANTS ---
const uint8_t PIN_SENSOR_IRQ = 18;  // Pin compatible con interrupciones
const uint8_t PIN_STATUS_LED = 2;   // LED Integrado para heartbeat
const uint32_t DEBOUNCE_US   = 500; // Tiempo muerto en microsegundos (ajustable según velocidad máquina)

// --- VOLATILE VARIABLES (ISR Context) ---
// 'volatile' es crucial para variables modificadas dentro de una interrupción
volatile uint32_t totalCardCount = 0;
volatile uint32_t lastInterruptTime = 0;
volatile bool newCardDetected = false;

// --- INTERRUPT SERVICE ROUTINE (ISR) ---
// IRAM_ATTR coloca la función en la RAM para máxima velocidad de ejecución
void IRAM_ATTR isr_CardSensor() {
    uint32_t currentTime = micros();
    
    // Filtrado de rebotes (Debounce) simple pero efectivo basado en tiempo
    if ((currentTime - lastInterruptTime) > DEBOUNCE_US) {
        totalCardCount++;
        lastInterruptTime = currentTime;
        newCardDetected = true; // Flag para que el loop principal procese la UI/Log
    }
}

// --- SETUP ---
void setup() {
    Serial.begin(115200);
    
    // Configuración de pines
    pinMode(PIN_STATUS_LED, OUTPUT);
    // INPUT_PULLUP asegura un estado lógico estable si el sensor es Open Collector
    pinMode(PIN_SENSOR_IRQ, INPUT_PULLUP);

    // Adjuntar interrupción al flanco de caída (FALLING) o subida (RISING) según el sensor
    attachInterrupt(digitalPinToInterrupt(PIN_SENSOR_IRQ), isr_CardSensor, FALLING);

    Serial.println("--- SISTEMA INICIADO: MODO ALTA VELOCIDAD ---");
}

// --- MAIN LOOP ---
void loop() {
    // 1. GESTIÓN DE EVENTOS CRÍTICOS (Sin bloquear el procesador)
    if (newCardDetected) {
        // Sección crítica: deshabilitar interrupciones momentáneamente para leer variables compartidas
        portENTER_CRITICAL_ISR(&mux); 
        uint32_t safeCount = totalCardCount;
        newCardDetected = false;
        portEXIT_CRITICAL_ISR(&mux);

        // Procesamiento de datos (Log, Display, Serial) fuera de la ISR
        Serial.printf("TARJETA DETECTADA | Total: %u | Tiempo: %lu us\n", safeCount, micros());
    }

    // 2. TAREAS SECUNDARIAS (Heartbeat, chequeo de errores, WiFi, etc.)
    static uint32_t lastBlink = 0;
    if (millis() - lastBlink > 1000) {
        lastBlink = millis();
        digitalWrite(PIN_STATUS_LED, !digitalRead(PIN_STATUS_LED)); // Heartbeat visual
    }
}

The post Circuito: Programación de PCB de serie de máquinas Máquina Contadora de Tarjetas fabricadas en España 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.

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.

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.

The post Cómo programar dispositivos electrónicos appeared first on HUE CAT INGENIERÍA ESPAÑA.

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:

1. 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.
2. 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.

The post ¿Cómo funciona el wifiManager? para ESP32/ESP8266 appeared first on HUE CAT INGENIERÍA ESPAÑA.

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

1. Abrir Arduino IDE.
2. «Archivo» -> «Preferencias».
3. En la sección «URLs adicionales de tarjetas de gestor de tarjetas», agregar la siguiente URL, clic en

1. https://dl.espressif.com/dl/package_esp32_index.json
2. «Herramientas» -> «Placa» -> «Gestor de tarjetas…»
3. Busca «esp32» e instala el soporte para ESP32 de Espressif.

Paso 3: Instalación de las Bibliotecas Necesarias

Para utilizar LoRa y la pantalla OLED, se debe instalar las siguientes bibliotecas:

1. Biblioteca ESP32 LoRa: «Herramientas» -> «Gestor de Bibliotecas…», buscar «ESP32 LoRa». Instala la biblioteca proporcionada por Sandeep Mistry.
2. Biblioteca Adafruit SSD1306: «Herramientas» -> «Gestor de Bibliotecas…», buscar «Adafruit SSD1306». Instalar la biblioteca de Adafruit.

Paso 4: Código de Ejemplo para la Comunicación LoRa

A continuación, un ejemplo de código básico para enviar y recibir datos LoRa entre dos placas TTGO LoRa32 SX1276 OLED.

#include <Wire.h>
#include <Adafruit_SSD1306.h>
#include <SPI.h>
#include <LoRa.h>

#define OLED_RESET    -1
#define SCREEN_WIDTH  128
#define SCREEN_HEIGHT 64

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

void setup() {
  if (!LoRa.begin(433E6)) {
    Serial.println("Error initializing LoRa.");
    while (1);
  }

  display.begin(SSD1306_I2C_ADDRESS, OLED_RESET);
  display.display();
  delay(2000);
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.print("LoRa Sender");
  display.display();
  delay(2000);
}

void loop() {
  display.clearDisplay();
  display.setCursor(0, 0);
  display.print("Sending LoRa...");
  display.display();

  // Enviar un mensaje
  LoRa.beginPacket();
  LoRa.print("¡Hola, mundo!");
  LoRa.endPacket();
  delay(10000); // Esperar 10 segundos antes de enviar el siguiente mensaje
}

The post Placa OLED TTGO LoRa32 SX1276 appeared first on HUE CAT INGENIERÍA ESPAÑA.

The post Manual de configuración para Wi-Fi en microcontoladores ESP8266 y ESP32: Creación de un driver LED appeared first on HUE CAT INGENIERÍA ESPAÑA.