Publicado el 1 comentario

Código para conectar dos ESP32 por Wi-Fi (Sin router de por medio)

Servidor:

#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);
}
Publicado el 1 comentario

La diferencia entre struct y typedef struct.

En lenguaje C y C++, una estructura (struct) es un tipo de dato que te permite combinar diferentes variables de tipos distintos en una sola entidad. Por ejemplo, puedes tener una estructura llamada «Punto» que almacene las coordenadas x e y.

Ejemplo de estructura:

struct Punto {
    int x;
    int y;
};

Luego, para usar esta estructura y declarar variables de tipo «Punto», normalmente deberías hacerlo así:

struct Punto miPunto;
miPunto.x = 10;
miPunto.y = 5;

La palabra clave struct debe ir antes del nombre de la estructura cada vez que declares una variable.

Sin embargo, si usas «typedef struct», puedes crear un nuevo nombre para esta estructura. Esto te permite omitir la palabra clave struct al declarar variables de esa estructura.

Ejemplo con «typedef struct»:

typedef struct {
    int x;
    int y;
} Punto;

Punto miPunto;
miPunto.x = 7;
miPunto.y = 3;

La diferencia entre «struct» y «typedef struct» es cómo declaras variables de ese tipo de estructura. Con «typedef struct», puedes crear un alias para la estructura y usar ese alias directamente sin necesidad de escribir la palabra struct.

Publicado el 1 comentario

Utilización de Estructuras struct{};

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() {

}
Publicado el 3 comentarios

Utilizar ambos núcleos de un ESP32

FreeRTOS (Free Real-Time Operating System) es un sistema operativo de tiempo real de código abierto diseñado para sistemas embebidos y aplicaciones en tiempo real. Un sistema operativo es un software que administra los recursos del hardware y proporciona una interfaz para que las aplicaciones se ejecuten en un dispositivo, como un microcontrolador o microprocesador.

En el contexto de los microcontroladores, como el ESP32, los sistemas operativos en tiempo real (RTOS) como FreeRTOS son útiles para administrar tareas concurrentes que deben ejecutarse de manera independiente y en un orden específico. Esto permite que las tareas se ejecuten en paralelo y que el sistema pueda responder rápidamente a eventos en tiempo real.

Las tareas son como pequeños programas que se ejecutan de forma independiente y tienen su propia parte de la memoria (pila) para almacenar datos locales y trabajar en una tarea específica. Un RTOS permite que las tareas compartan el tiempo de ejecución del procesador, lo que permite una mejor utilización de los recursos del sistema.

En FreeRTOS, xTaskCreatePinnedToCore es una función utilizada para crear tareas que se ejecutarán en un núcleo de procesador específico en sistemas multi-núcleo, como el ESP32.

Se utiliza FreeRTOS para crear dos tareas: parpadearLedNucleo0 y parpadearLedNucleo1. Cada tarea controla un LED y los hace parpadear con diferentes intervalos de tiempo. Al usar FreeRTOS, estas tareas se pueden ejecutar en núcleos diferentes del ESP32, lo que permite que las tareas de parpadeo se realicen en paralelo sin bloquear la ejecución del programa principal.

FreeRTOS también proporciona mecanismos para sincronización y comunicación entre tareas, lo que permite que las tareas se comuniquen y cooperen en la resolución de problemas complejos.

const int ledPinNucleo0 = 2;
const int ledPinNucleo1 = 4;

void parpadearLedNucleo0(void *parameter) {
  (void)parameter; // Ignorar el parámetro, ya que no lo usamos en este ejemplo

  while (true) {
    digitalWrite(ledPinNucleo0, HIGH);
    Serial.println("LED Núcleo 0 encendido");
    delay(500);
    digitalWrite(ledPinNucleo0, LOW);
    Serial.println("LED Núcleo 0 apagado");
    delay(500);
  }
}

void parpadearLedNucleo1(void *parameter) {
  (void)parameter; // Ignorar el parámetro, ya que no lo usamos en este ejemplo

  while (true) {
    digitalWrite(ledPinNucleo1, HIGH);
    Serial.println("LED Núcleo 1 encendido");
    delay(300);
    digitalWrite(ledPinNucleo1, LOW);
    Serial.println("LED Núcleo 1 apagado");
    delay(300);
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(ledPinNucleo0, OUTPUT);
  pinMode(ledPinNucleo1, OUTPUT);

  xTaskCreatePinnedToCore(parpadearLedNucleo0, "Nucleo 0 LED", 10000, NULL, 1, NULL, 0);
  xTaskCreatePinnedToCore(parpadearLedNucleo1, "Nucleo 1 LED", 10000, NULL, 1, NULL, 1);
}

void loop() {
  // Nada que hacer en loop, ya que las tareas se encargan del parpadeo de los LEDs
}

Con estos cambios, se mostrarán mensajes en el monitor serie cada vez que los LEDs cambien de estado, lo que te permitirá verificar el funcionamiento correcto del código y seguir el comportamiento de los LEDs. Recordar abrir el Monitor Serie en el IDE de Desarrollo / en un programa como PUTTY para ver los mensajes que se imprimen.

Publicado el Deja un comentario

SK6812

SK6812 es un conjunto de circuito de control inteligente y un circuito emisor de luz en una de las fuentes LED controladas. Cada elemento es un píxel, contenido dentro del circuito de amplificación de forma de señal de pestillo de datos de interfaz digital inteligente, circuito de fuente de alimentación, un circuito de corriente constante incorporado, oscilador RC de alta precisión, la salida es impulsada por tecnología PWM, garantiza efectivamente los píxeles en el color de la luz alta consistencia. Protocolo de datos usando el modo de comunicación unipolar NRZ, el píxel se restablece después del final de DIN, acepta los datos transmitidos desde el controlador a 24 bits, el primero en enviar datos por la primera extracción de píxel a píxel, pestillo de datos interno, los datos restantes después El circuito de procesamiento de plástico interno después de dar forma a la amplificación a través de la salida del puerto DO comenzó a girar a la siguiente cascada de píxeles, cada píxel a través de una señal de transmisión, reducir. El píxel que utiliza la tecnología de reenvío de forma automática hace que el número de cascadas sin límite de transmisión de señal del píxel, solo velocidad de transmisión de señal limitada. El LED tiene un bajo voltaje de conducción, protección ambiental y ahorro de energía, alto brillo, ángulo de dispersión, buena consistencia, baja potencia, larga vida útil, etc. El circuito de control está integrado en el LED anterior, circuito más simple, pequeño volumen, fácil instalación. Campo de aplicación principal: ● Guirnalda de luces LED a todo color, módulo LED a todo color, luces LED súper duras y suaves, tubo de barandilla LED, apariencia LED/iluminación de escena ● Punto de luz LED, pantalla de píxeles LED, pantalla con forma de LED, una variedad de productos electrónicos, equipos eléctricos, etc.

Publicado el Deja un comentario

El Driver Led

En la iluminación LED, al contrarío que pasa con la iluminación fluorescente o incandescente, las luminarias no se conectan directamente a la corriente eléctrica, si no que lo hacen a través de un driver que se ocupa de transformar la tensión adaptándola a las necesidades del sistema.

Transformación de tensión

La mayoría de los sistemas de iluminación LED operan con baja tensión continua, generalmente en el rango de 12-24 voltios. Los drivers convierten la corriente alterna de la red eléctrica en corriente continua y ajustan la tensión a niveles seguros para el funcionamiento de los LEDs.

Regulación de corriente

Los LEDs deben recibir una corriente eléctrica constante para emitir luz de manera eficiente y mantener su vida útil. Los drivers regulan la corriente que fluye a través de los LEDs, asegurando una operación estable y prolongando la vida útil de la fuente de luz.

Control de la intensidad lumínica

Algunos drivers permiten la regulación de la intensidad lumínica, lo que significa que se puede ajustar el brillo de la iluminación LED. Esto se logra mediante técnicas como la modulación de ancho de pulso (PWM) o mediante la variación de la corriente.

Protección contra fluctuaciones de corriente

Los drivers también suelen incluir protecciones contra sobretensiones, subidas de corriente y otros problemas eléctricos que podrían dañar los LEDs.

Publicado el Deja un comentario

Instalar Base de Datos MySQL en NodeRED + Raspberry Pi

Instalar una base de datos MySQL en Node-RED ejecutándose en una Raspberry Pi

1. Instalación MySQL Server en la Raspberry Pi:

En una terminal en Raspberry Pi y se ejecutan los siguientes comandos para instalar MySQL Server:

sudo apt update
sudo apt install mysql-server

2. Configurar MySQL:

Después de instalar MySQL, se puede ejecutar el siguiente comando para realizar la configuración inicial:

sudo mysql_secure_installation

Se siguen las instrucciones en pantalla para mejorar la seguridad de la instalación.

3. Instalación el nodo node-red-node-mysql:

cd ~/.node-red

npm install node-red-node-mysql

node-red-stop && node-red-start

Abre Node-RED en tu Raspberry Pi y dirígete a la pestaña de administración (generalmente http://tu_raspberry_pi:1880).

Haz clic en el menú en la esquina superior derecha y selecciona «Manage palette». En la pestaña «Install», busca node-red-node-mysql y haz clic en «Install».

4. Configurar el nodo MySQL en Node-RED:

Ahora, podrás utilizar el nodo MySQL en tus flujos de Node-RED. Conéctate al nodo configurándolo con los detalles de tu servidor MySQL, como la dirección IP, el puerto, el nombre de usuario y la contraseña.

5. Crear una base de datos y tablas:

Usa un cliente MySQL (como MySQL Workbench o la línea de comandos) para conectarte a tu servidor MySQL. Crea una base de datos y las tablas necesarias para tu aplicación.

Ejemplo en la línea de comandos:

Publicado el Deja un comentario

Operadores de Desplazamiento de Bits

Los símbolos «<<» y «>>» se llaman «operadores de desplazamiento de bits» en programación. Estos operadores se utilizan para mover los bits de un valor hacia la izquierda o hacia la derecha en su representación binaria. Aquí tienes una breve descripción de ambos operadores:

  1. Operador de desplazamiento hacia la izquierda (<<): Este operador desplaza los bits de un valor hacia la izquierda y completa con ceros en el lado derecho. Cada vez que se realiza un desplazamiento hacia la izquierda, el valor se multiplica por 2 elevado a la potencia del número de lugares que se desplazó.
  2. Operador de desplazamiento hacia la derecha (>>): Este operador desplaza los bits de un valor hacia la derecha y completa con ceros o con el bit de signo en el lado izquierdo, dependiendo del tipo de dato. Cada vez que se realiza un desplazamiento hacia la derecha, el valor se divide por 2 elevado a la potencia del número de lugares que se desplazó.

Estos operadores son útiles para (valga la redundancia) realizar operaciones de bajo nivel en la representación binaria de datos, como combinar o dividir bytes, multiplicar o dividir por potencias de 2, entre otros.