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 1 comentario

Funciones y métodos integrados en Arduino IDE

Cuando se trata de desarrollar proyectos electrónicos, Arduino IDE se ha convertido en una plataforma popular gracias a sus características únicas y su versatilidad. Además de su similitud con la sintaxis de C y C++, Arduino ofrece una serie de funciones y métodos específicos que permiten interactuar de manera eficiente con los componentes electrónicos. En este artículo, destacaremos algunas de las particularidades de Arduino y cómo aprovechar al máximo su potencial en tus proyectos.

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

Publicado el 2 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. Recuerda que necesitarás abrir el Monitor Serie en el IDE de Arduino 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 1 comentario

Diferenciación entre Arduino y Arduino IDE

En el emocionante mundo de la electrónica y la programación, Arduino y Arduino IDE son términos que suelen estar interconectados. Sin embargo, es importante comprender que Arduino y Arduino IDE son entidades diferentes, cada una con su propio propósito y función. En este artículo, exploraremos en detalle las diferencias entre Arduino y Arduino IDE, así como algunas alternativas más económicas y populares, como el ESP32 y el ESP8266.

Arduino y Arduino IDE Son elementos clave y parte de la historia reciente del desarrollo con microcontroladores, y más específicamente de Placas de Desarrollo.

Arduino es una plataforma de hardware de código abierto que permite la interacción con componentes electrónicos, mientras que Arduino IDE es el software utilizado para programar las placas Arduino.

Ambos desempeñaron un papel fundamental en la creación de proyectos electrónicos de manera accesible y versátil.

Arduino: Una plataforma de hardware de código abierto que ha ganado una enorme popularidad en la comunidad de proyectos electrónicos. Consiste en una placa programable que permite la interacción con una amplia gama de componentes electrónicos. La flexibilidad y la simplicidad de Arduino hacen que sea una opción accesible tanto para principiantes como para expertos en electrónica. Su comunidad activa y el soporte de una amplia variedad de bibliotecas hacen de Arduino una opción versátil para desarrollar proyectos electrónicos.

Arduino IDE o (Integrated Development Environment) es un entorno de desarrollo integrado diseñado específicamente para programar y cargar código en las placas Arduino. Es una herramienta de software que proporciona una interfaz amigable para escribir, compilar y cargar programas en las placas Arduino. El IDE simplifica el proceso de desarrollo al ofrecer funciones de gestión de bibliotecas, depuración y comunicación con la placa. Aunque Arduino IDE es la opción más comúnmente utilizada, existen alternativas populares como PlatformIO y Visual Studio Code con extensiones específicas para Arduino.

Diferencias clave:

La principal diferencia entre Arduino y Arduino IDE radica en su función y propósito. Mientras que Arduino es la plataforma de hardware en sí misma, Arduino IDE es el software utilizado para programarla. Arduino IDE es solo una de las opciones disponibles para programar las placas Arduino (o de otros fabricantes), y su popularidad se debe en parte a su facilidad de uso y a la comunidad de usuarios activa que proporciona soporte y recursos.

Alternativas económicas: ESP32 y ESP8266

Además de Arduino, existen alternativas más económicas y poderosas que ofrecen funcionalidades similares, como el ESP32 y el ESP8266. Estos microcontroladores Wi-Fi y Bluetooth de bajo costo son ampliamente utilizados en proyectos de IoT (Internet de las cosas) y tienen una gran base de usuarios y una comunidad activa.

El ESP32, por ejemplo, ofrece una mayor potencia de procesamiento y más opciones de conectividad que Arduino, con soporte incorporado para Wi-Fi y Bluetooth. Además, tiene una amplia variedad de pines de entrada/salida (GPIO) que permiten la conexión y el control de una amplia gama de sensores y actuadores.

Por su parte, el ESP8266 es una opción más económica y también cuenta con soporte para Wi-Fi, lo que lo convierte en una opción popular para proyectos que requieren conectividad inalámbrica.

Publicado el 1 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.