Mostrando entradas con la etiqueta Oled. Mostrar todas las entradas
Mostrando entradas con la etiqueta Oled. Mostrar todas las entradas

domingo, 9 de agosto de 2026

Encender LED del ESP32-C3 desde página web

Muy buenas a todos y todas!!!

En este post quiero explicar como crear una pagina web dentro de nuestro ESP32C3.
La idea es un proyecto sencillo pero completo que te permita encender y apagar el LED integrado de tu ESP32-C3 desde cualquier navegador.

Como extra, en la pantalla integrada en el ESP32 también nos indicará el estado del LED On o Off

Voy a intentar explicar cada parte del programa por separado antes de ver el programa completo.


Sistema de archivos

El ESP32 dispone de varios métodos para almacenar una página web, desde una pequeña, como en este ejemplo, donde usaremos PROGMEM o usar la memoria Flash interna (unos 4MB) para almacenar el HTML, CSS o registros.

PROGMEM, LittleFS, SPIFFS o incluso las tarjetas SD son las opciones de almacenamiento más comunes:


Sistema de archivos Descripción Cuándo usarlo
PROGMEM Los archivos se incluyen como cadenas de texto en el código y se compilan junto con el programa. Para páginas pequeñas y estáticas que no van a cambiar. Es la opción más simple si solo tienes un archivo HTML pequeño.
LittleFS Un sistema de archivos en la flash, diseñado para ser ligero y resistente a cortes de energía. Es la opción más equilibrada para la mayoría de los proyectos. Soporta archivos, carpetas y es fácil de usar con un plugin en el IDE de Arduino.
Puedes ver un ejemplo de como usar LittleFS aquí.
SPIFFS El predecesor de LittleFS. También funciona en la flash, pero es menos eficiente y ya no se recomienda para nuevos proyectos. Para mantener compatibilidad con código antiguo. Se recomienda migrar a LittleFS.
Tarjeta SD Usa una tarjeta microSD externa conectada al ESP32 por SPI o SDIO. Para proyectos que necesitan almacenar muchos archivos (imágenes, vídeos, logs) o cuando el espacio en la flash es insuficiente.


🛠️ Componentes necesarios
ESP32-C3 con OLED de 0.42, Antena Cerámica, Wifi, Bluetooth
ESP32-C3OLED de 0.42" Placa de Desarrollo ESP32-C3 con OLED de 0.42", Antena Cerámica, Wifi, Bluetooth.

¿Qué necesitamos saber primero?

El LED integrado en placa o LED_BUILTIN

En la mayoría de las placas basadas en el ESP32-C3, el LED integrado está conectado al GPIO 8.

En algunas placas como la XIAO ESP32-C3, puede estar en el GPIO 21, consulta la documentación de tu placa para confirmar.

Nota: Este pin esta invertido, es decir que para apagar hay que ponerlo en estado HIGH y para encender el LED hay que ponerlo en LOW.


Librerías para el proyecto

Una librería Arduino es un paquete de código que simplifica la programación.
Además nos proporciona funciones y ejemplos para controlar hardware complejo como sensores, pantallas o motores sin necesidad de conocer los detalles técnicos internos.


Librería ¿Para qué sirve?
WiFi.h Permite que el ESP32-C3 se conecte a tu red o cree su propio punto de acceso
WebServer.h Crea un servidor HTTP en el ESP32-C3 para servir páginas web y recibir peticiones

Explicación del código

Paso 1: Incluir las librerías y definir credenciales


#include <WiFi.h>
#include <WebServer.h>
#include <U8g2lib.h>


// Credenciales de tu red Wi-Fi
const char* ssid = "TU_SSID";
const char* password = "TU_CONTRASEÑA";

Librerías:

#include <WiFi.h> nos da acceso a las funciones de conectividad inalámbrica.
#include <WebServer.h> nos permite crear un servidor web que escuche peticiones HTTP en el puerto 80 que es el estándar para páginas web.
Gestiona peticiones GET y POST, y se configura fácilmente asignando funciones a diferentes rutas URL


Credenciales:

const char* ssid = "TU_SSID"; El nombre de tu red domestica.
const char* password = "TU_CONTRASEÑA"; La contraseña de la red.


Pantalla:

#include <U8g2lib.h> Puedes revisar la información sobre como usar la pantalla 0.42" aquí

Paso 2: Configurar el LED y el servidor


// El LED integrado en la mayoría de placas ESP32-C3 está en el GPIO 8
const int LED_PIN = 8;

// Creamos el objeto del servidor web en el puerto 80
WebServer server(80);

// Variable para guardar el estado del LED
bool ledState = false;

Definir el LED:

const int LED_PIN = 8; El pin GPIO8 sera el LED.


Crear el servidor:

WebServer server(80); crea un servidor que escuchará peticiones HTTP en el puerto 80. Cuando un navegador se conecte a la IP del ESP32, el servidor procesará la petición


Paso 3: La página HTML (el "frontend")

El código de la página web se guarda como una cadena de texto en el programa del ESP32. Cuando alguien visita la IP del ESP32, el servidor envía este HTML al navegador




const char HTML_PAGE[] PROGMEM = R"HTML(
<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Control LED ESP32-C3</title>
  <style>
    body {
      font-family: Arial, sans-serif;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: center;
      height: 100vh;
      margin: 0;
      background: #1a1a2e;
      color: #eee;
    }
    button {
      padding: 20px 50px;
      font-size: 1.5rem;
      border: none;
      border-radius: 10px;
      cursor: pointer;
      margin: 10px;
    }
    .btn-on {
      background: #4CAF50;
      color: white;
    }
    .btn-off {
      background: #f44336;
      color: white;
    }
    .btn-on:hover { background: #45a049; }
    .btn-off:hover { background: #d32f2f; }
    .estado {
      font-size: 1.2rem;
      margin: 20px;
      padding: 10px 30px;
      border-radius: 20px;
      background: #16213e;
    }
  </style>
</head>
<body>
  <h1>⚡ Control LED</h1>
  <div class="estado" id="estadoLED">
    LED: <span id="estadoTexto">Desconocido</span>
  </div>
  <div>
    <button class="btn-on" onclick="controlarLED('on')">🔆 ENCENDER</button>
    <button class="btn-off" onclick="controlarLED('off')">🔅 APAGAR</button>
  </div>

  <script>
    // Función que se ejecuta al hacer clic en un botón
    function controlarLED(accion) {
      // Envía una petición GET al ESP32: /led?accion=on o /led?accion=off
      fetch('/led?accion=' + accion)
        .then(response => response.text())
        .then(data => {
          // Actualiza el texto del estado con la respuesta del ESP32
          document.getElementById('estadoTexto').textContent = data;
        });
    }

    // Al cargar la página, consulta el estado actual del LED
    window.onload = function() {
      fetch('/estado')
        .then(response => response.text())
        .then(data => {
          document.getElementById('estadoTexto').textContent = data;
        });
    };
  </script>
</body>
</html>
)HTML";


Explicación del código HTML/JavaScript:

  1. La página tiene dos botones: "ENCENDER" y "APAGAR".

  2. Al hacer clic, la función JavaScript controlarLED() envía una petición fetch() a la URL /led?accion=on o /led?accion=off.

  3. El ESP32 recibe esta petición, cambia el estado del LED y responde con el nuevo estado.

  4. También hay una función que consulta el estado actual al cargar la página (window.onload).


Paso 4: Los "handlers" (el "backend")

Los Handlers o controladores son funciones que se ejecutan en respuesta a un evento específico.
En el contexto de un servidor web en un ESP32, un handler es una función que se asigna a una ruta URL por ejemplo, /led y se ejecuta automáticamente cuando el servidor recibe una petición HTTP a esa dirección, procesando la solicitud y generando una respuesta.


// Maneja la petición a la raíz "/" enviando la página HTML
void handleRoot() {
  server.send(200, "text/html", HTML_PAGE);
}

// Maneja la petición para cambiar el estado del LED
void handleLED() {
  String accion = server.arg("accion"); // Obtiene el valor del parámetro "accion"

  if (accion == "on") {
    digitalWrite(LED_PIN, LOW);  // Enciende el LED (recordemos que el pin esta invertido)
    ledState = true;
    printScreen = true;
    server.send(200, "text/plain", "ENCENDIDO");
  } else if (accion == "off") {
    digitalWrite(LED_PIN, HIGH);   // Apaga el LED
    ledState = false;
    printScreen = true;
    server.send(200, "text/plain", "APAGADO");
  } else {
    server.send(400, "text/plain", "Acción no válida");
  }
}

// Maneja la petición para consultar el estado actual
void handleEstado() {
  if (ledState) {
    server.send(200, "text/plain", "ENCENDIDO");
  } else {
    server.send(200, "text/plain", "APAGADO");
  }
}

Explicación de los handlers:

handleRoot(): Cuando alguien visita la URL raíz (/), el servidor envía el código HTML que hemos guardado.

handleLED(): Cuando se visita /led?accion=on, el servidor extrae el valor del parámetro accion, enciende o apaga el LED físicamente con digitalWrite(), y responde con el nuevo estado.

handleEstado(): Cuando se visita /estado, el servidor responde con el estado actual del LED sin modificarlo.



Paso 5: Configuración inicial (setup)

El setup() de nuestro programa es el "director de orquesta" que prepara todo el escenario: configura el LED, conecta el ESP32-C3 a la red Wi-Fi, asigna las rutas del servidor web y lo pone en marcha.
Sin esta configuración inicial, el servidor no sabría qué hacer cuando reciba una petición HTTP, ni el LED estaría listo para ser controlado.


void setup() {
  Serial.begin(115200);

  // Configurar el pin del LED como salida
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW); // Inicia apagado

  // Conectar a la red Wi-Fi
  WiFi.begin(ssid, password);
  Serial.print("Conectando a Wi-Fi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nConectado!");
  Serial.print("Dirección IP: ");
  Serial.println(WiFi.localIP());

  // Asignar funciones a las rutas del servidor
  server.on("/", handleRoot);
  server.on("/led", handleLED);
  server.on("/estado", handleEstado);

  // Iniciar el servidor
  server.begin();
  Serial.println("Servidor web iniciado.");
}


Paso 6: El bucle principal (loop)

El loop() en nuestro programa del LED es el "guardia de la puerta" que está siempre atento.
Se ejecuta sin parar, y su única misión es llamar a server.handleClient() para asegurarse de que cualquier petición web que llegue sea atendida al instante.
Sin él, el ESP32-C3 no podría responder a los clics en los botones de la página web, y el proyecto dejaría de funcionar.


void loop() {
  server.handleClient(); // Atiende las peticiones HTTP entrantes
}

Explicación:

El método server.handleClient() es el que escucha y procesa las peticiones HTTP.
Si no se llama continuamente, el servidor no responderá a las peticiones del navegador


Programa completo

Aquí tienes el código completo listo para copiar y pegar en la Arduino IDE:


/*
  Control del LED integrado del ESP32-C3 desde página web
  Basado en los ejemplos de Fab Academy y proyectos de la comunidad
  Fuente: Fab Academy 2026, Week 15 [citation:12]
*/

#include <WiFi.h>
#include <WebServer.h>
#include <U8g2lib.h>


// ===== CONFIGURACIÓN =====
// Reemplaza con las credenciales de tu red Wi-Fi
const char* ssid = "TU_SSID";
const char* password = "TU_CONTRASEÑA";

// ========== PANTALLA ==========
U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE, 6, 5);
const int X_OFFSET = 28;
const int Y_OFFSET = 24;
bool printScreen = true;

// En la mayoría de placas ESP32-C3, el LED integrado está en GPIO 8
// Si usas XIAO ESP32-C3, usa GPIO 21
const int LED_PIN = 8;

// ===== VARIABLES GLOBALES =====
WebServer server(80);
bool ledState = false;

// ===== PÁGINA HTML =====
const char HTML_PAGE[] PROGMEM = R"HTML(
<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Control LED ESP32-C3</title>
  <style>
    body {
      font-family: Arial, sans-serif;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: center;
      height: 100vh;
      margin: 0;
      background: #1a1a2e;
      color: #eee;
    }
    h1 {
      font-weight: 300;
      letter-spacing: 0.1em;
    }
    .estado {
      font-size: 1.2rem;
      margin: 20px;
      padding: 10px 30px;
      border-radius: 20px;
      background: #16213e;
    }
    .botones {
      display: flex;
      gap: 20px;
      flex-wrap: wrap;
      justify-content: center;
    }
    button {
      padding: 20px 50px;
      font-size: 1.5rem;
      border: none;
      border-radius: 12px;
      cursor: pointer;
      transition: transform 0.2s, box-shadow 0.2s;
      min-width: 150px;
    }
    button:active {
      transform: scale(0.95);
    }
    .btn-on {
      background: #4CAF50;
      color: white;
      box-shadow: 0 4px 15px rgba(76, 175, 80, 0.3);
    }
    .btn-on:hover {
      background: #45a049;
      box-shadow: 0 6px 20px rgba(76, 175, 80, 0.5);
    }
    .btn-off {
      background: #f44336;
      color: white;
      box-shadow: 0 4px 15px rgba(244, 67, 54, 0.3);
    }
    .btn-off:hover {
      background: #d32f2f;
      box-shadow: 0 6px 20px rgba(244, 67, 54, 0.5);
    }
    .footer {
      margin-top: 30px;
      font-size: 0.8rem;
      color: #666;
    }
  </style>
</head>
<body>
  <h1>⚡ Control LED</h1>
  <div class="estado" id="estadoLED">
    LED: <span id="estadoTexto">Desconocido</span>
  </div>
  <div class="botones">
    <button class="btn-on" onclick="controlarLED('on')">🔆 ENCENDER</button>
    <button class="btn-off" onclick="controlarLED('off')">🔅 APAGAR</button>
  </div>
  <div class="footer">ESP32-C3 - Servidor Web</div>

  <script>
    function controlarLED(accion) {
      fetch('/led?accion=' + accion)
        .then(response => response.text())
        .then(data => {
          document.getElementById('estadoTexto').textContent = data;
        })
        .catch(error => {
          console.error('Error:', error);
          document.getElementById('estadoTexto').textContent = 'Error';
        });
    }

    window.onload = function() {
      fetch('/estado')
        .then(response => response.text())
        .then(data => {
          document.getElementById('estadoTexto').textContent = data;
        })
        .catch(error => {
          console.error('Error:', error);
          document.getElementById('estadoTexto').textContent = 'Error de conexión';
        });
    };
  </script>
</body>
</html>
)HTML";

// ===== HANDLERS DEL SERVIDOR =====

void handleRoot() {
  server.send(200, "text/html", HTML_PAGE);
}

void handleLED() {
  String accion = server.arg("accion");

  if (accion == "on") {
    digitalWrite(LED_PIN, LOW);
    ledState = true;
    printScreen = true;
    server.send(200, "text/plain", "ENCENDIDO");
  } else if (accion == "off") {
    digitalWrite(LED_PIN, HIGH);
    ledState = false;
    printScreen = true;
    server.send(200, "text/plain", "APAGADO");
  } else {
    server.send(400, "text/plain", "Acción no válida");
  }
}

void handleEstado() {
  if (ledState) {
    server.send(200, "text/plain", "ENCENDIDO");
  } else {
    server.send(200, "text/plain", "APAGADO");
  }
}

void handleNotFound() {
  server.send(404, "text/plain", "Página no encontrada");
}

// ===== SETUP =====
void setup() {
  delay(200);
  Serial.begin(115200);
  delay(200);
  
  // Configurar pantalla
  u8g2.begin();
  u8g2.setContrast(200);

  // Configurar LED
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, HIGH);

  // Conectar a Wi-Fi
  WiFi.begin(ssid, password);
  Serial.print("Conectando a Wi-Fi");
  
  int intentos = 0;
  while (WiFi.status() != WL_CONNECTED && intentos < 30) {
    delay(500);
    Serial.print(".");
    intentos++;
  }

  if (WiFi.status() == WL_CONNECTED) {
    Serial.println("\n✅ Conectado!");
    Serial.print("📡 Dirección IP: ");
    Serial.println(WiFi.localIP());
  } else {
    Serial.println("\n❌ No se pudo conectar a Wi-Fi");
    Serial.println("Verifica las credenciales en el código");
  }

  // Configurar rutas del servidor
  server.on("/", handleRoot);
  server.on("/led", handleLED);
  server.on("/estado", handleEstado);
  server.onNotFound(handleNotFound);

  // Iniciar servidor
  server.begin();
  Serial.println("🌐 Servidor web iniciado en el puerto 80");
  Serial.println("Abre un navegador y visita la IP indicada");
}

// ===== LOOP =====
void loop() {
  server.handleClient();
  if (printScreen)
  {
    u8g2.clearBuffer();
    u8g2.setFont(u8g2_font_6x10_tf);
    if (ledState)
      u8g2.drawStr(X_OFFSET + 10, Y_OFFSET + 20, "ON");
  	else
      u8g2.drawStr(X_OFFSET + 10, Y_OFFSET + 20, "OFF");
    u8g2.sendBuffer();
    printScreen = false;
  }
}

Cómo usar el programa

  1. Configura las credenciales Wi-Fi: Reemplaza "TU_SSID" y "TU_CONTRASEÑA" con los datos de tu red.

  2. Verifica el pin del LED: Si tu placa no usa el GPIO 8 (como la XIAO ESP32-C3 que usa GPIO 21), cambia la línea const int LED_PIN = 8; al pin correcto.

  3. Carga el programa a tu ESP32-C3 desde la Arduino IDE.

  4. Abre el Monitor Serie para ver la IP que obtiene el ESP32.

  5. Desde cualquier navegador en la misma red, visita http://[IP_del_ESP32]/.

  6. Haz clic en los botones para encender o apagar el LED.


ESP32C3 Interfaz web led

Resumen de conceptos clave y conclusión

Concepto Explicación
Servidor web El ESP32-C3 actúa como un pequeño servidor que aloja una página web en su memoria.
Peticiones HTTP El navegador envía peticiones GET al ESP32 (ej: /led?accion=on) para controlar el LED.
fetch() Función JavaScript que permite hacer peticiones HTTP sin recargar la página (AJAX).
server.on() Asigna una función a una ruta URL. Cuando alguien visita esa URL, se ejecuta la función correspondiente.
server.handleClient() Escucha y procesa las peticiones HTTP entrantes. Debe llamarse constantemente en el loop().

Ya tenemos todo lo necesario para controlar el LED integrado en el ESP32-C3 funcional desde cualquier navegador.


Saludos a todos y todas!!!


viernes, 31 de julio de 2026

Ejemplos Arduino: LEDC (LED Control) en el ESP32

Muy buenas a todos y todas a la vuelta al canal!!

El periférico LEDC está diseñado principalmente para controlar la intensidad de LEDs, aunque también pero también es muy útil para generar señales PWM para otros propósitos tales como controlar motores DC.

El ESP32-C3 cuenta con 6 canales que pueden generar formas de onda independientes, ideales para controlar LEDs o dispositivos que necesiten PWM tan solo cambiando algunos parámetros de la configuración como el temporizador,la confirmación del canal y el cambio de la señal PWM.


¿Cuando se implementó ledc?

La API de LEDC para Arduino-ESP32 está documentada y disponible como parte del núcleo (core) de ESP32 en Arduino.
La versión actual (a partir de la 3.0.0) incluye cambios importantes en la sintaxis, como la sustitución de:


ledcAttachPin() // V < 3.0.0

por


ledcAttach() // Versión > 3.0.0

Para la versión 3.0.0 del core de ESP32 para Arduino, ya no se usa la función ledcSetup() ni la función ledcAttachPin(), sino que se recomienda utilizar la función ledcAttach(pin, freq, resolution)
ESP32 C3 Mini 0.42 Pinout
ESP32 C3 mini 0.42" pinout

Funciones y definiciones relacionadas

1. ledcAttach()

Función:


bool ledcAttach(uint8_t pin, uint32_t freq, uint8_t resolution);

La función ledcAttach configura un pin para PWM con la frecuencia (uint32_t freq) y resolución (uint8_t resolution)indicadas.
El canal LEDC se selecciona automáticamente.

Devuelve true si la configuración es exitosa.


2. ledcAttachChannel()

Función:


bool ledcAttachChannel(uint8_t pin, uint32_t freq, uint8_t resolution, uint8_t channel);

Con ledcAttachChannel configuramos un pin para PWM con la frecuencia, resolución y canal específicos.

Devuelve true si la configuración es exitosa.


3. ledcWrite()

Función:


void ledcWrite(uint8_t pin, uint32_t duty);

Establece el ciclo de trabajo (duty cycle) para el pin LEDC.

El valor de duty depende de la resolución: para 10 bits, el rango es de 0 a 1023.


4. ledcRead()

Función:


uint32_t ledcRead(uint8_t pin);

Lee el ciclo de trabajo configurado para el pin.


5. ledcReadFreq()

Función:


uint32_t ledcReadFreq(uint8_t pin);

Con ledcReadFreq lee la frecuencia configurada para el pin que hemos seleccionado.


Relación entre frecuencia y resolución


6. ledcDetach()

Función:


bool ledcDetach(uint8_t pin);

Desvincula el pin del periférico LEDC para usarlo como GPIO digital.


7. ledcChangeFrequency()

Función:


uint32_t ledcChangeFrequency(uint8_t pin, uint32_t freq, uint8_t resolution);

Cambia la frecuencia y resolución de un pin LEDC ya configurado.


8. ledcFade()

Función:


bool ledcFade(uint8_t pin, uint32_t start_duty, uint32_t target_duty, int max_fade_time_ms);

Configura e inicia un desvanecimiento (fade) automático por hardware desde un valor inicial hasta un valor objetivo.

Devuelve true si se inicia correctamente.


9. ledcWriteTone()

Función:


uint32_t ledcWriteTone(uint8_t pin, uint32_t freq);

Genera un tono PWM al 50% en la frecuencia especificada.

10. ledcWriteNote()

Función:


uint32_t ledcWriteNote(uint8_t pin, note_t note, uint8_t octave);

Por último tenemos ledcWriteNote que genera un tono a partir de una nota musical y una octava.


LEDC ¿es mejor o peor que analogWrite?

En ESP32, analogWrite() es una capa de abstracción sobre LEDC.
La principal diferencia es que analogWrite() simplifica el uso, pero limita el control.


Característica analogWrite() LEDC nativo
Resolución Fija a 8 bits (0-255) Configurable (1-14 bits en ESP32-C3)
Frecuencia Fija (~5 kHz) Totalmente configurable
Gestión de canales Automática, puede causar conflictos Manual, 6 canales independientes
Funciones avanzadas No disponible Fade por hardware, interrupciones
Complejidad de código Muy baja Media

Conclusión: analogWrite() es perfecto para prototipos rápidos y proyectos simples.
LEDC es necesario cuando se necesita precisión, frecuencias personalizadas o múltiples canales PWM sin interferencias .


🛠️ Componentes necesarios
ESP32-C3 con OLED de 0.42, Antena Cerámica, Wifi, Bluetooth
ESP32-C3OLED de 0.42" Placa de Desarrollo ESP32-C3 con OLED de 0.42", Antena Cerámica, Wifi, Bluetooth.

Relación entre frecuencia y resolución

En el ESP32-C3, la frecuencia y la resolución están interrelacionadas. A mayor frecuencia, menor resolución máxima disponible, y viceversa.

Ejemplos prácticos:

  • 5 kHz con 13 bits: 8192 niveles de intensidad.
  • 40 MHz con 1 bit: Solo 50% fijo.

Si se intenta configurar una combinación no soportada, la API mostrará un error:


E (196) ledc: requested frequency and duty resolution cannot be achieved, try reducing freq_hz or duty_resolution. div_param=128 


Ejemplos para ESP32-C3 con pantalla OLED 0.42"

La placa "ESP32-C3 OLED 0.42" tiene la pantalla conectada por I2C: en el pin GPIO5 corresponde a SDA y el pin GPIO6 para SCL.


Ejemplo 1: Uso de analogWrite (simplificado)

Primero veamos un ejemplo clásico programa con analogWrite()



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

#define OLED_SDA 5
#define OLED_SCL 6
#define OLED_RESET -1
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

#define LED_PIN 8

void setup() {
  Wire.begin(OLED_SDA, OLED_SCL);
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);

  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  for (int brightness = 0; brightness <= 255; brightness += 5) {
    analogWrite(LED_PIN, brightness);

    display.clearDisplay();
    display.setCursor(30, 30);
    display.print("AnalogWrite: ");
    display.println(brightness);

    int porcentaje = map(brightness, 0, 255, 0, 100);
    display.setCursor(30, 40);
    display.print("Inten.: ");
    display.print(porcentaje);
    display.println("%");

    display.display();
    delay(30);
  }
  for (int brightness = 255; brightness >= 0; brightness -= 5) {
    analogWrite(LED_PIN, brightness);

    display.clearDisplay();
    display.setCursor(30, 30);
    display.print("AnalogWrite: ");
    display.println(brightness);

    int porcentaje = map(brightness, 0, 255, 0, 100);
    display.setCursor(30, 40);
	display.print("Inten.: ");
    display.print(porcentaje);
    display.println("%");

    display.display();
    delay(30);
  }
}


Ejemplo 2: Ledc PWM en LED y mostrar valor en OLED (I2C)

En este ejemplo tendremos la salida del valor Ledc en la pantalla OLED 0.42". El pin 8 del LED builtin el estado de Ledc.

NOTA: el encendido del LED builtin esta invertido, es decir cuando la señal Ledc esta en 0 el LED builtin estará a su máxima intensidad y apagado en su valor más alto.



 

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

#define OLED_SDA 5
#define OLED_SCL 6
#define OLED_RESET -1
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

#define LED_PIN 8
#define PWM_FREQ 5000
#define PWM_RES 10
#define MAX_DUTY ((1 << PWM_RES) - 1) // 1023 para 10 bits

int duty = 0;
int step = 5;

void setup() {
  Wire.begin(OLED_SDA, OLED_SCL);
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);

  ledcAttach(LED_PIN, PWM_FREQ, PWM_RES);
  ledcWrite(LED_PIN, 0);
}

void loop() {
  duty += step;
  if (duty >= MAX_DUTY || duty <= 0) step = -step;

  ledcWrite(LED_PIN, duty);

  display.clearDisplay();
  display.setCursor(30, 30);
  display.print("Duty: ");
  display.setCursor(30, 40);
  display.print(duty);
  display.print(" / ");
  display.println(MAX_DUTY);

  int porcentaje = map(duty, 0, MAX_DUTY, 0, 100);
  display.setCursor(30, 50);
  display.print("Intensidad: ");
  display.print(porcentaje);
  display.println("%");

  display.display();
  delay(20);
}


Ejemplo 3: Ledc fade automático por hardware y mostrar estado


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

#define OLED_SDA 5
#define OLED_SCL 6
#define OLED_RESET -1
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

#define LED_PIN 8
#define PWM_CHANNEL 0
#define PWM_FREQ 5000
#define PWM_RES 10
#define MAX_DUTY ((1 << PWM_RES) - 1)

void setup() {
  Wire.begin(OLED_SDA, OLED_SCL);
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);

  ledcAttachChannel(LED_PIN, PWM_FREQ, PWM_RES, PWM_CHANNEL);
 ledcWrite(LED_PIN, 0);

  display.display();
  delay(1000);
}

void loop() {
  display.clearDisplay();
  display.setCursor(30, 30);
  display.println("Fade IN");
  display.display();

  ledcFade(LED_PIN, 0, MAX_DUTY, 2000);
  delay(2500);

  display.clearDisplay();
  display.setCursor(30, 30);
  display.println("Fade OUT");
  display.display();

  ledcFade(LED_PIN, MAX_DUTY, 0, 2000);
  delay(2500);
}


Ejemplo 4: Ledc PWM para ESC de motor brushed

Para controlar un ESC, se necesita una señal PWM de 50 Hz con pulsos entre 1000 µs y 2000 µs.



#define ESC_PIN 8 
#define PWM_FREQ 50 
#define PWM_RES 14 
#define MAX_DUTY ((1 << PWM_RES) - 1)

// Para 14 bits: 16384 = 100% (20 ms)
// 1000 µs = 1 ms → (1/20)16384 = 819
// 2000 µs = 2 ms → (2/20)16384 = 1638

void setup() {
  ledcAttach(ESC_PIN, PWM_FREQ, PWM_RES);
  ledcWrite(ESC_PIN, 819); // Neutro
  delay(3000);
}

void loop() {
  ledcWrite(ESC_PIN, 819); // Neutro
  delay(2000);
  ledcWrite(ESC_PIN, 1638); // Máximo
  delay(2000);
}


También puedes revisar el repositorio supermini_esp32c3_sketches para ejemplos muy variados y completos.


Conclusión sobre LEDC en el ESP32-C3

El periférico LEDC del ESP32-C3 es una herramienta extremadamente versátil y potente para generar señales PWM, muy superior a la función analogWrite() que muchos conocen de Arduino.

Mientras que analogWrite() está limitada a 8 bits de resolución y frecuencias fijas, LEDC ofrece un control total con resoluciones de hasta 14 bits y frecuencias completamente configurables.
Esto hace que Ledc sea ideal para aplicaciones que requieren precisión, como el control de motores DC, servomotores, atenuación de LEDs profesionales o incluso generación de tonos y notas musicales.

Lo bueno:

El ESP32-C3 dispone de 6 canales independientes, lo que permite manejar múltiples dispositivos PWM simultáneamente sin interferencias.
Una de sus características más destacadas es la capacidad de realizar desvanecimientos (fade) automáticos por hardware, lo que descarga al procesador de esta tarea y permite transiciones suaves sin necesidad de interrupciones constantes.


Lo malo:

Sin embargo, hay que tener en cuenta algunas limitaciones importantes. El ESP32-C3 solo funciona en modo "low speed", a diferencia de otros ESP32 que también tienen modo "high speed".
Además, existe una relación de compromiso entre frecuencia y resolución: a mayor frecuencia, menor resolución disponible, y viceversa. Por ejemplo, a 5 kHz se puede alcanzar 13 bits de resolución, pero a 40 MHz apenas se obtiene 1 bit.

Aquí tienes otros enlaces de este blog relacionados con el microcontrolador ESP32 y Arduino:


martes, 12 de mayo de 2026

ESP32-C3 con pantalla Oled 0.42" con ejemplos

ESP32 C3 Oled 0.42 logo

Muy buenas a todas y todos!!!

Después de la buena experiencia programando el ESP32-C3 mini junto con el módulo de la pantalla SH1106 y el encoder, y otro proyecto que aún estoy probando.

Este pequeño no comparte los mismos pines que el ESP32C3 mini así que si ya tienes un montaje realizado para el mini no te servirá, pero eso no quita que sus pines GPIO sean igual de versátiles, veamos las características y los pines de esta pequeña placa de desarrollo:


Antes de empezar veamos que componentes nos hacen falta para el proyecto:


🛠️ Componentes necesarios
ESP32-C3 con OLED de 0.42, Antena Cerámica, Wifi, Bluetooth
ESP32-C3 con OLED de 0.42" Placa de Desarrollo ESP32-C3 con OLED de 0.42", Antena Cerámica, Wifi, Bluetooth.


Hardware e interfaces

  • 22 pines GPIO programables.
  • Comunicación vía UART, SPI, I2C, I2S y USB Serie/JTAG.
  • Funciones analógicas: dos SAR de 12 bits Convertidores analógico-digitales (ADC), sensor de temperatura integrado.

Procesador y memoria

ESP32 C3 Oled 0.42 chip
  • Procesador: ESP32-C3FN4/FH4, RISC-V de 32 bits de un solo núcleo, hasta 160 MHz.
  • Memoria flash: 4 MB.
  • Pantalla: OLED de 0,42 pulgadas para información visual directa.
  • Conectividad: Wi-Fi de modo dual (802.11b/g/n) y Bluetooth 5 (LE, malla).
  • Programación: Fácil vía USB, en este caso USB-C.
  • Antena: Antena cerámica integrada.


Funciones de Wi-Fi y Bluetooth

El ESP32 integra conectividad dual Wi-Fi y Bluetooth 5 LE, optimizada para aplicaciones que requieren velocidad y eficiencia. Estas son sus capacidades más relevantes:

  • Wi-Fi con velocidades de datos de hasta 150 Mbps, compatible con ancho de banda de 20/40 MHz.
  • Bluetooth 5 LE con alta potencia de transmisión de hasta 20 dBm y red mallada.
  • Coexistencia interna entre Wi-Fi y Bluetooth para el uso de antena compartida.
  • Compatible con múltiples modos Wi-Fi: Estación, SoftAP y modo promiscuo.

Bajo consumo de energía y seguridad

El ESP32 ha sido diseñado para ofrecer un rendimiento óptimo en aplicaciones IoT sin sacrificar la eficiencia energética ni la protección de los datos.
A continuación, se detallan sus características más destacadas en este ámbito:

  • Cuatro modos de ahorro de energía, incluyendo un modo de suspensión profunda con un consumo de corriente de tan solo 5 µA.
  • Funciones de seguridad como arranque seguro y cifrado de memoria flash.
  • Aceleración criptográfica por hardware: AES, SHA, RSA y más.

Aplicaciones

Gracias a su bajo consumo de energía y su versátil conectividad, esta placa es perfecta para numerosas aplicaciones como:

  • Dispositivos para el hogar inteligente
  • Automatización industrial
  • Atención médica
  • Electrónica de consumo
  • Agricultura inteligente
  • Robots de servicio
  • Sensores IoT de bajo consumo y registradores de datos


La placa ESP32-C3 con pantalla OLED de 0,42".


Esta placa IoT compacta se basa en el chip ESP32-C3 (RISC-V) e incorpora una pantalla OLED de 0,42 pulgadas. Como la distribución de pines y el controlador de pantalla no son iguales que la de los módulos ESP32 estándar.



A continuación os dejamos la información necesaria para el correcto funcionamiento de la placa.

Especificaciones del hardware

  • Chip: ESP32-C3FN4 con una Memoria Flash de 4 MB, Wi-Fi y Bluetooth 5.0 BLE.
  • Conexión USB: USB nativo USB-C Para Habilitar la comunicación con el monitor serial active en el IDE de Arduino "USB CDC al arrancar".
  • Pantalla OLED: 0,42 pulgadas con una resolución de 72 x 40 píxeles.
  • Dimensiones: Es muy compacta aproximadamente 20 x 25 mm.


Asignación de pines y conexiones

ESP32 C3 Oled 0.42 cubo

La documentación en línea suele ser confusa. Utilice la siguiente asignación de pines para esta placa específica:

  • I2C OLED SDA: GPIO 5 (aunque generalmente se indica el 8.
  • I2C OLED SCL: GPIO 6.
  • LED Integrado: GPIO 8.
  • Boton de reset: GPIO 9.
  • Tx; GPIO 21.
  • Rx: GPIO 20.

Configurando del IDE de Arduino

Para programar placa correctamente vamos seleccionar la siguiente configuración en el IDE de Arduino:

  • Placa: Módulo de desarrollo ESP32C3 Dev Module.
  • USB CDC al arrancar: Habilitado (Para salida de Serial.print).
  • Modo de flasheo: DIO (predeterminado).

Algunas veces podemos experimentar problemas con la carga del programa, para solucionarlo, mantenga presionado el botón BOOT, presione RESET brevemente y luego suelte BOOT. Esto fuerza a la placa al entrar modo de programación.

Códigos de ejemplo

Comprobación de pines: Parpadeo del LED integrado

Usa este sencillo bucle en el pin 8 que controla el LED integrado.

// GPIO 8 es el LED integrado (LOW = ON)
#define LED_PIN 8 

void setup() {
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_PIN, LOW);  // LED On
  delay(500);
  digitalWrite(LED_PIN, HIGH); // LED Off
  delay(500);
}

Control de la pantalla OLED

La pantalla utiliza un controlador SSD1306, pero tiene una resolución física es de solo 72x40 píxeles.
Sin embargo, el búfer interno es de 128x64.

Para solucionar este problema tenemos que aplicar un desplazamiento en los ejes X e Y para que el texto sea visible.

Proporción Oled 0.42 con Oled 0.96

Necesitamos tener instalada la biblioteca U8g2 (de olikraus) a través del Administrador de bibliotecas de Arduino o desde el Repositorio de GitHub.


#include <U8g2lib.h>
#include <Wire.h>

#define SCL 6
#define SDA 5

// Iniciando un ESP32-C3 con I2C en los pines 5 SDA y 6 SCL.
// Usaremos el driver estandar de 128x64 pero solo una parte de la pantalla.
U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE, SCL, SDA);

// Los Offsets se requieren para centrar la salida dentro del buffer 128x64.
const int VISIBLE_X0 = 28;
const int VISIBLE_Y0 = 24;

//configuramos la pantalla de 0.42 pulgadas 
const int VISIBLE_W  = 72;
const int VISIBLE_H  = 40;

void setup(void) {
  delay(1000); // Una pausa para estabilizar el ESP
  
  u8g2.begin();
  u8g2.setContrast(255);      // Máximo brillo
  u8g2.setBusClock(400000);   // 400kHz velocidad del I2C
  u8g2.setFont(u8g2_font_ncenB10_tr); // Elegimos el tipo de letra
}

void loop(void) {
  u8g2.clearBuffer(); // Limpiamos el buffer interno
  
  // Dibuja un marco para probar el área visible
  u8g2.drawFrame(VISIBLE_X0, VISIBLE_Y0, VISIBLE_W, VISIBLE_H);
  
  // Dibujar texto teniendo en cuenta el desplazamiento en x y el desplazamiento en y
  u8g2.setCursor(VISIBLE_X0 + 6, VISIBLE_Y0 + 15); 
  u8g2.print("ESP32-C3");
  u8g2.setCursor(VISIBLE_X0 + 25, VISIBLE_Y0 + 30); 
  u8g2.print("ITB");
  
  u8g2.sendBuffer(); // Enviar datos a la pantalla
  delay(1000);
}


Código: Texto con scroll lateral

El texto se mueve horizontalmente dentro de los 72 píxeles visibles y se dibuja un marco opcional para recordar los límites.
Puedes ajustar delay(30) para cambiar velocidad.

ESP32 C3 Oled 0.42 scroll lateral

#include <U8g2lib.h>

// Configuración de la pantalla (driver SSD1306, 128x64, I2C hardware)
// Pines: SDA = 6, SCL = 5 (ajusta según tu conexión)
U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE, 6, 5);

// --- Constantes de área visible real (72x40 con offset 28,24) ---
const int VISIBLE_X0 = 28;
const int VISIBLE_Y0 = 24;
const int VISIBLE_W  = 72;
const int VISIBLE_H  = 40;

// Texto a desplazar
const char* texto = "  Infotronikblog desplazamiento lateral  ";
int desplazamiento = 0;

// Función para dibujar texto teniendo en cuenta el recorte (clipping manual)
void dibujarTextoScroll(int offsetX) {
  // El área de dibujo está limitada a [VISIBLE_X0, VISIBLE_X0+VISIBLE_W]
  // Usamos setFont y drawStr con coordenadas absolutas (incluyendo offset)
  u8g2.setFont(u8g2_font_ncenB08_tr);
  int anchoTexto = u8g2.getStrWidth(texto);
  
  // Dibujamos el texto varias veces para efecto continuo
  int x = VISIBLE_X0 + offsetX;
  int y = VISIBLE_Y0 + 20;  // centrado vertical aprox.
  
  u8g2.drawStr(x, y, texto);
  // Si el texto se sale por la derecha, dibujamos continuación
  if (x + anchoTexto < VISIBLE_X0 + VISIBLE_W) {
    u8g2.drawStr(x + anchoTexto, y, texto);
  }
  // Si se sale por la izquierda, dibujamos la parte que falta
  if (x < VISIBLE_X0) {
    u8g2.drawStr(x + anchoTexto, y, texto);
  }
}

void setup() {
  u8g2.begin();
  u8g2.setFontMode(1);          // Modo transparente
  u8g2.setFontDirection(0);
}

void loop() {
  u8g2.firstPage();
  do {
    // Limpia toda la pantalla (128x64) pero solo se verá el área activa
    u8g2.clearBuffer();
    
    // Dibujar un marco alrededor del área visible (opcional, para referencia)
    u8g2.drawFrame(VISIBLE_X0 - 1, VISIBLE_Y0 - 1, VISIBLE_W + 2, VISIBLE_H + 2);
    
    // Dibujar el texto en scroll
    dibujarTextoScroll(desplazamiento);
    
  } while (u8g2.nextPage());
  
  // Actualizar desplazamiento (velocidad ajustable)
  desplazamiento--;
  if (desplazamiento < -u8g2.getStrWidth(texto)) {
    desplazamiento = VISIBLE_W;
  }
  
  delay(30);  // 30 ms entre frames
}

Código: Cubo 3D + rebotes en los bordes

Un pequeño cubo 3D que se mueve con velocidades vx y vy iniciales semi-aleatorias.
Con rebotes realistas: al tocar cualquier borde del área visible (72×40 con offsets), invierte la componente de velocidad correspondiente, quedando siempre dentro de los límites considerando el medio lado del cubo para que no se salga.

ESP32 C3 Oled 0.42 ejemplo cubo

#include <U8g2lib.h>
#include <math.h>

U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, U8X8_PIN_NONE, 6, 5);

// Área visible real de tu pantalla (offset 28,24)
const int X0 = 28;
const int Y0 = 24;
const int W  = 72;
const int H  = 40;

// Tamaño del cubo (lado en píxeles)
const int LADO = 14;   // Ajustado a 14 como pediste

// Centro del cubo (coordenadas absolutas) - posición inicial en el centro del área visible
float cx = X0 + W/2.0;
float cy = Y0 + H/2.0;

// Velocidades de desplazamiento (píxeles por frame)
float vx = 1.2;
float vy = 0.9;

// Ángulo de rotación (radianes)
float anguloY = 0.0;

// Límites de rebote: el cubo no debe salirse del rectángulo visible
// Como el cubo se dibuja centrado en (cx,cy), el medio lado se extiende a cada lado.
float limiteIzq  = X0 + LADO/2.0;
float limiteDer  = X0 + W - LADO/2.0;
float limiteSup  = Y0 + LADO/2.0;
float limiteInf  = Y0 + H - LADO/2.0;

// Proyección isométrica con rotación alrededor del eje Y
void projectPoint(float x, float y, float z, float angY, int &sx, int &sy) {
  // Rotación en Y
  float x1 = x * cos(angY) + z * sin(angY);
  float z1 = -x * sin(angY) + z * cos(angY);
  // Proyección simple (sin perspectiva, solo desplazamiento)
  sx = (int)(cx + x1);
  sy = (int)(cy - y + z1 * 0.3);   // ligero efecto de profundidad
}

void drawCubo(float angY) {
  // Vértices relativos al centro del cubo (coordenadas modelo)
  int vertices[8][3] = {
    {-LADO/2, -LADO/2, -LADO/2}, // 0
    { LADO/2, -LADO/2, -LADO/2}, // 1
    { LADO/2, -LADO/2,  LADO/2}, // 2
    {-LADO/2, -LADO/2,  LADO/2}, // 3
    {-LADO/2,  LADO/2, -LADO/2}, // 4
    { LADO/2,  LADO/2, -LADO/2}, // 5
    { LADO/2,  LADO/2,  LADO/2}, // 6
    {-LADO/2,  LADO/2,  LADO/2}  // 7
  };
  
  int projX[8], projY[8];
  for (int i = 0; i < 8; i++) {
    projectPoint(vertices[i][0], vertices[i][1], vertices[i][2], angY, projX[i], projY[i]);
  }
  
  // Aristas (12 líneas)
  int edges[12][2] = {
    {0,1},{1,2},{2,3},{3,0}, // base inferior
    {4,5},{5,6},{6,7},{7,4}, // base superior
    {0,4},{1,5},{2,6},{3,7}  // verticales
  };
  
  for (int i = 0; i < 12; i++) {
    u8g2.drawLine(projX[edges[i][0]], projY[edges[i][0]],
                  projX[edges[i][1]], projY[edges[i][1]]);
  }
}

void setup() {
  u8g2.begin();
  randomSeed(analogRead(0));
  
  // Velocidades iniciales aleatorias (para dar variedad)
  vx = (random(80, 160) / 100.0) * 1.5;
  vy = (random(60, 140) / 100.0) * 1.5;
  if (random(2) == 0) vx = -vx;
  if (random(2) == 0) vy = -vy;
  
  // Asegurar que la posición inicial esté dentro de los límites
  if (cx < limiteIzq) cx = limiteIzq;
  if (cx > limiteDer) cx = limiteDer;
  if (cy < limiteSup) cy = limiteSup;
  if (cy > limiteInf) cy = limiteInf;
}

void loop() {
  // 1. Actualizar posición del cubo
  cx += vx;
  cy += vy;
  
  // 2. Rebotes en los bordes
  if (cx < limiteIzq) { cx = limiteIzq; vx = -vx; }
  if (cx > limiteDer) { cx = limiteDer; vx = -vx; }
  if (cy < limiteSup) { cy = limiteSup; vy = -vy; }
  if (cy > limiteInf) { cy = limiteInf; vy = -vy; }
  
  // 3. Rotación continua
  anguloY += 0.06;   // velocidad angular (ajústala a gusto)
  if (anguloY > 2 * M_PI) anguloY -= 2 * M_PI;
  
  // 4. Dibujar en la pantalla
  u8g2.firstPage();
  do {
    u8g2.clearBuffer();
    
    // (Opcional) marco del área visible - puedes comentarlo si prefieres sin marco
    u8g2.drawFrame(X0, Y0, W, H);
    
    // Dibujar el cubo rotando
    drawCubo(anguloY);
    
  } while (u8g2.nextPage());
  
  delay(30);  // controla la velocidad de animación
}

Puedes visitar los siguiente enlaces relacionados con el microcontrolador ESP32 y Arduino:

viernes, 20 de febrero de 2026

Ojos animados en OLED con Raspberry Pi: Tutorial Python con expresiones

Muy buenas a todos y todas!!!

Ya hemos visto como configurar una pantalla OLED de 128x64 en nuestra Raspberry Pi junto con la librería Adafruit.

Y como veía mi cluster Pi un poco "triste" decidí animarlo un poco con una pantalla OLED de tipo I2c y algunas animaciones programadas en Python que la hacen más "friendly".


Expresiones y dirección de la mirada

Podemos alternar entre las diferentes expresiones:

  • Normal
  • Contento
  • Triste
  • Sorpresa
  • Dormido

También podemos dirigir la mirada en las siguientes direcciones:

  • Izquierda
  • Centro
  • Derecha



Pero también podemos llamar de manera independiente a cada una de las expresiones con la función "crear_ojos" y "animar_parpadeo"

def crear_ojos(expresion="normal", direccion_mirada="centro", estado_parpadeo=1.0):
    """
    Ojos con sistema de parpadeo realista
    estado_parpadeo: 1.0 = totalmente abierto, 0.0 = totalmente cerrado
    """

Para crear la animación de parpadeo:


def animar_parpadeo(expresion="normal", direccion_mirada="centro"):
    """Animación completa de parpadeo"""
    

Programa completo en python:



# Simulación de ojos con expresiones en OLED 128x64

import time
import random
import board
import adafruit_ssd1306
from PIL import Image, ImageDraw, ImageFont

# Use for I2C.
i2c = board.I2C()  # uses board.SCL and board.SDA

try:
        disp = adafruit_ssd1306.SSD1306_I2C(128, 64, i2c, addr=0x3C)
        print("\nAdafruit SSD1306 ok")

except Exception as errors:
        print("\nError Adafruit SSD1306:",str(errors), "\nPlease check Raspi-config\n")
        exit()


def crear_ojos(expresion="normal", direccion_mirada="centro", estado_parpadeo=1.0):
    """
    Ojos con sistema de parpadeo realista
    estado_parpadeo: 1.0 = totalmente abierto, 0.0 = totalmente cerrado
    """
    # Crear imagen evitando la franja amarilla superior
    img = Image.new('1', (128, 64), 0)
    draw = ImageDraw.Draw(img)
    
    # Posiciones fijas
    centro_y = 40
    ojo_izq_x = 45
    ojo_der_x = 83
    
    # Tamaño máximo reducido a 40
    max_tam = 40
    
    # Radio de redondeo
    radio = 15
    
    # Determinar tamaños según dirección de mirada
    if direccion_mirada == "izquierda":
        ancho_izq, alto_izq = max_tam, max_tam
        ancho_der, alto_der = 30, 30
    elif direccion_mirada == "derecha":
        ancho_izq, alto_izq = 30, 30
        ancho_der, alto_der = max_tam, max_tam
    else:  # centro
        ancho_izq, alto_izq = 35, 40
        ancho_der, alto_der = 35, 40
    
    def dibujar_ojo(x, y, ancho, alto, radio, apertura=1.0):
        """Dibuja un ojo con sistema de parpadeo"""
        if apertura >= 1.0:
            # Ojo totalmente abierto
            draw.rounded_rectangle([
                (x - ancho//2, y - alto//2),
                (x + ancho//2, y + alto//2)
            ], radius=radio, outline=1, fill=1)
        elif apertura <= 0.0:
            # Ojo totalmente cerrado (línea)
            draw.line([
                (x - ancho//2, y),
                (x + ancho//2, y)
            ], fill=1, width=3)
        else:
            # Ojo parcialmente cerrado - calcular altura visible
            alto_visible = int(alto * apertura)
            if alto_visible < 2:
                alto_visible = 2
            
            # Dibujar el ojo recortado según la apertura
            draw.rounded_rectangle([
                (x - ancho//2, y - alto_visible//2),
                (x + ancho//2, y + alto_visible//2)
            ], radius=min(radio, alto_visible//2), outline=1, fill=1)
    
    # Aplicar expresiones (modifican la apertura base)
    apertura_base = estado_parpadeo
    
    if expresion == "normal":
        apertura = apertura_base
    elif expresion == "contento":
        apertura = apertura_base * 0.7  # Ojos más cerrados
    elif expresion == "triste":
        apertura = apertura_base * 0.9  # Ojos casi normales pero caídos
    elif expresion == "sorpresa":
        apertura = min(apertura_base * 1.2, 1.0)  # Ojos más abiertos
    elif expresion == "dormido":
        apertura = apertura_base * 0.3  # Ojos casi cerrados
    
    # Dibujar ojos con la apertura calculada
    dibujar_ojo(ojo_izq_x, centro_y, ancho_izq, alto_izq, radio, apertura)
    dibujar_ojo(ojo_der_x, centro_y, ancho_der, alto_der, radio, apertura)
    
    return img

def animar_parpadeo(expresion="normal", direccion_mirada="centro"):
    """Animación completa de parpadeo"""
    frames = []
    
    # Fases del parpadeo (apertura de 1.0 a 0.0 y vuelta)
    fases = [1.0, 0.8, 0.5, 0.2, 0.0, 0.2, 0.5, 0.8, 1.0]
    
    for apertura in fases:
        frame = crear_ojos(expresion, direccion_mirada, apertura)
        frames.append(frame)
    
    return frames


# Bucle principal 
if __name__ == "__main__":
    expresiones = ["normal", "contento", "triste", "sorpresa", "dormido"]
    direcciones = ["izquierda", "centro", "derecha"]

    print("Mostrando expresiones sencillas...")
    print("Presiona Ctrl+C para detener")

    try:
        while True:
            for expresion in expresiones:
                for direccion in direcciones:

                    print(f"Expresión: {expresion} dirección: {direccion}")

                    img = crear_ojos(expresion, direccion)
                    disp.image(img)
                    disp.show()
                    time.sleep(5)
                                        # 30% de probabilidad de guiño entre animaciones
                    if random.random() < 0.2:
                        #lado_guiño = random.choice(["izquierdo", "derecho"])
                        print(f"¡papadeo {expresion}!")
                        frames_parpadeo = animar_parpadeo(expresion, direccion)

                        for frame in frames_parpadeo:
                            disp.image(frame)
                            disp.show()

    except KeyboardInterrupt:
        print("\nBucle detenido")

Es un programa que podemos ampliar con otras expresiones o incluso hacer llamadas desde otros programas por ejemplo conectandolo a una Raspi cam para simular que la mirada nos sigue.

Otro idea que se me ocurre es que las llamadas sean según diferentes eventos, como que despierte con el acceso por ssh o utilizar el sensor de temperatura para que nos "mire mal" si nuestra Raspberry Pi se pone lujuriosa.

Añadir programa al iniciar Raspberry PI

Lo ideal es que este programa se inicie al encender la Raspberry pi. Es un buen indicador para saber que la Raspberry Pi arranco sin problemas.

esto lo podemos hacer editando el crontab con el comando "crontab -e" (no hace falta sudo).


@reboot sleep 30 && python3 ~/Eyes_simulation/eyes_simulation.py > ~/Eyes_simulation/eyes.log 2>&1

Recuerda poner "@reboot sleep 30" para darle un tiempo prudente a la Raspberry para inicializar el puerto I2c.

Y siempre puedes ver si todo esta bien o hay algún fallo consultando el archivo que se genera en el inicio llamado "eyes.log".


Conclusión:

Es un programa sencillo que le dará a nuestra maquina un poco más de carisma (por si le faltaba un poco) y que deje de ser un puñado de lucecitas encima del escritorio.

Antes de montar el cluster con las 3 Raspberry Pi, la que máquina que usaba para estas cosas empezó a dar problemas con la tarjeta y lo pude detectar ya que no me miraba igual que siempre...

¿Le puedo poner nombre?


Aquí tienes otros enlaces de este blog relacionados con Raspberry Pi: