1. ¡Hello World!

#define LED_PIN 2

const int tiempoEncendido = 1000;

const int tiempoApagado = 1000;

void setup() {
pinMode(LED_PIN, OUTPUT);
Serial.begin(115200);
Serial.println("ESP32 LED Blink Iniciado");
}

void loop() {
digitalWrite(LED_PIN, HIGH);
Serial.println("LED encendido");
delay(tiempoEncendido);

digitalWrite(LED_PIN, LOW);
Serial.println("LED apagado");
delay(tiempoApagado);
}

2. Dimming LED
// Definición de pines
const int potPin = 34; // Pin del potenciómetro (GPIO34 - ADC1_6)
const int ledPin = 2; // Pin del LED (GPIO2 - LED integrado en la placa)

// Variables para almacenar valores

int potValue = 0; // Valor leído del potenciómetro (0-4095)
int ledValue = 0; // Valor para el LED (0-255)
void setup() {
// Inicializar comunicación serial para monitoreo
Serial.begin(115200);

// Configurar el pin del LED como salida

pinMode(ledPin, OUTPUT);
}

void loop() {
// Leer el valor del potenciómetro (0-4095)
potValue = analogRead(potPin);

// Convertir el valor del potenciómetro (0-4095) a un valor PWM (0-255)

ledValue = map(potValue, 0, 4095, 0, 255);

// Aplicar el valor al LED usando analogWrite

analogWrite(ledPin, ledValue);

// Imprimir valores para monitoreo

Serial.print("Valor Potenciómetro: ");
Serial.print(potValue);
Serial.print(" | Valor LED: ");
Serial.println(ledValue);

// Pequeña pausa para estabilidad

delay(100);
}

3. Speed Led
// Definición de pines
const int LED_PIN = 2; // Pin del LED
const int POT_PIN = 34; // Pin del potenciómetro

// Configuración de canales PWM

const int FREQ = 5000; // Frecuencia PWM en Hz
const int LED_CHANNEL = 0; // Canal PWM para el LED
const int RESOLUTION = 8; // Resolución de 8 bits (0-255)

void setup() {
// Configurar el canal PWM
ledcSetup(LED_CHANNEL, FREQ, RESOLUTION);

// Asociar el pin del LED al canal PWM

ledcAttachPin(LED_PIN, LED_CHANNEL);

// Iniciar comunicación serial para debugging

Serial.begin(115200);
}

void loop() {
// Leer el valor del potenciómetro (0-4095)
int potValue = analogRead(POT_PIN);

// Mapear el valor del potenciómetro (0-4095) al rango del LED (0-255)

int brightness = map(potValue, 0, 4095, 0, 255);

// Aplicar el brillo al LED

ledcWrite(LED_CHANNEL, brightness);

// Imprimir valores para debugging

Serial.print("Valor Potenciómetro: ");
Serial.print(potValue);
Serial.print(" | Brillo LED: ");
 Serial.println(brightness);

// Pequeña pausa para estabilidad

delay(50);
}

4. Timing LEDS
// Definición de pines
const int led1 = 2; // Primer LED (GPIO2 - LED integrado)
const int led2 = 4; // Segundo LED (GPIO4)

// Tiempos para el LED 1 (en milisegundos)

const int tiempoEncendido1 = 800; // Tiempo encendido largo
const int tiempoApagado1 = 200; // Tiempo apagado corto
const int pausaPatron1 = 1500; // Pausa entre repeticiones

// Tiempos para el LED 2 (en milisegundos)

const int tiempoEncendido2 = 200; // Tiempo encendido corto
const int tiempoApagado2 = 400; // Tiempo apagado medio
const int pausaPatron2 = 1000; // Pausa entre repeticiones

void setup() {
// Configurar pines como salidas
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);

// Inicializar LEDs apagados

digitalWrite(led1, LOW);
digitalWrite(led2, LOW);
}
// Patrón para el LED 1 (patrón lento)
void patronLed1() {
// Encendido largo, apagado corto (3 veces)
for(int i = 0; i < 3; i++) {
digitalWrite(led1, HIGH);
delay(tiempoEncendido1);
digitalWrite(led1, LOW);
delay(tiempoApagado1);
}
delay(pausaPatron1);
}

// Patrón para el LED 2 (patrón rápido)

void patronLed2() {
// Encendido corto, apagado medio (5 veces)
for(int i = 0; i < 5; i++) {
digitalWrite(led2, HIGH);
delay(tiempoEncendido2);
digitalWrite(led2, LOW);
delay(tiempoApagado2);
}
delay(pausaPatron2);
}

// Patrón alternado entre LEDs

void patronAlternado() {
// Alternar entre LED 1 y LED 2 (4 veces)
for(int i = 0; i < 4; i++) {
// LED 1 encendido, LED 2 apagado
digitalWrite(led1, HIGH);
digitalWrite(led2, LOW);
delay(500);
 // LED 1 apagado, LED 2 encendido
digitalWrite(led1, LOW);
digitalWrite(led2, HIGH);
delay(300);
}
delay(1000);
}

// Patrón sincronizado
void patronSincronizado() {
// Ambos LEDs parpadean juntos pero con diferentes duraciones
for(int i = 0; i < 3; i++) {
// Encender ambos
digitalWrite(led1, HIGH);
digitalWrite(led2, HIGH);
delay(400);

// Apagar LED 2 primero

digitalWrite(led2, LOW);
delay(300);

// Apagar LED 1 después

digitalWrite(led1, LOW);
delay(200);
}
delay(1000);
}

void loop() {
patronLed1(); // Patrón individual del LED 1
patronLed2(); // Patrón individual del LED 2
 patronAlternado(); // Patrón alternado entre ambos LEDs
patronSincronizado(); // Patrón sincronizado
}

5. Button LED
// Definición de pines
const int LED_PIN = 2; // LED integrado en la placa
const int BUTTON_PIN = 4; // Pin para el pulsador

// Variables
int buttonState = 0;
int ledState = LOW;

void setup() {
// Configurar pines
pinMode(LED_PIN, OUTPUT);
pinMode(BUTTON_PIN, INPUT_PULLUP);
}

void loop() {
// Leer estado del pulsador
buttonState = digitalRead(BUTTON_PIN);

// Si el pulsador está presionado (LOW debido al PULLUP)

if (buttonState == LOW) {
// Cambiar estado del LED
ledState = !ledState;
digitalWrite(LED_PIN, ledState);

// Pequeño delay para evitar rebotes

delay(200);
 }
}

6. Touch LED
// Define los pines que vamos a usar
const int LED_PIN = 2; // Pin para el LED
const int TOUCH_PIN = 4; // Pin táctil T0 (GPIO4)

// Ajustamos el umbral según los valores que observamos

const int THRESHOLD = 20; // Valor entre 30 (sin tocar) y 6-7 (tocando)

void setup() {
// Inicializa el monitor serial
Serial.begin(115200);

// Configura el pin del LED como salida y lo forzamos a modo OUTPUT

pinMode(LED_PIN, OUTPUT);

// Forzamos el LED a apagado inicial

digitalWrite(LED_PIN, LOW);

// Mensaje inicial
Serial.println("Iniciando sensor touch...");
Serial.println("Valor del THRESHOLD: " + String(THRESHOLD));
}

void loop() {
// Lee el valor del sensor táctil
int touchValue = touchRead(TOUCH_PIN);

// Imprime el valor y estado actual

Serial.print("Valor del sensor: ");
 Serial.print(touchValue);

// Lógica invertida: si el valor es MENOR al umbral, está siendo tocado

if (touchValue < THRESHOLD) {
digitalWrite(LED_PIN, HIGH); // Enciende el LED
Serial.println(" -> TOCANDO - LED ENCENDIDO");
} else {
digitalWrite(LED_PIN, LOW); // Apaga el LED
Serial.println(" -> NO TOCANDO - LED APAGADO");
}

// Verificación adicional del estado del LED

Serial.print("Estado actual del LED (PIN ");
Serial.print(LED_PIN);
Serial.print("): ");
Serial.println(digitalRead(LED_PIN) == HIGH ? "ENCENDIDO" : "APAGADO");

// Línea separadora para mejor lectura

Serial.println("------------------------");

delay(100);
}

7. Aline Counter
#define LED0 13 // LSB
#define LED1 12
#define LED2 14
#define LED3 27
#define LED4 26
#define LED5 25
#define LED6 33
#define LED7 32 // MSB

const int leds[] = {LED0, LED1, LED2, LED3, LED4, LED5, LED6, LED7};
const int NUM_LEDS = 8;
const int DELAY_TIME = 1000;
int contador = 0;

void setup() {
for(int i = 0; i < NUM_LEDS; i++) {
pinMode(leds[i], OUTPUT);
digitalWrite(leds[i], LOW);
}

Serial.begin(115200);
Serial.println("Alien Counter Iniciado");
}

void loop() {
mostrarNumero(contador);
contador++;

if(contador > 255) {

contador = 0;
efectoReinicio();
}

delay(DELAY_TIME);
}

void mostrarNumero(int numero) {

Serial.print("Contador: ");
Serial.println(numero);
 for(int i = 0; i < NUM_LEDS; i++) {
if(numero & (1 << i)) {
digitalWrite(leds[i], HIGH);
} else {
digitalWrite(leds[i], LOW);
}
}
}

void efectoReinicio() {
for(int i = 0; i < 3; i++) {
for(int j = 0; j < NUM_LEDS; j++) {
digitalWrite(leds[j], HIGH);
}
delay(200);

for(int j = 0; j < NUM_LEDS; j++) {

digitalWrite(leds[j], LOW);
}
delay(200);
}
}

8. Street Lights
#define LED_ROJO 13
#define LED_AMARILLO 12
#define LED_VERDE 14

const int TIEMPO_VERDE = 5000; // 5 segundos

const int TIEMPO_AMARILLO = 2000; // 2 segundos
const int TIEMPO_ROJO = 5000; // 5 segundos
void setup() {
pinMode(LED_ROJO, OUTPUT);
pinMode(LED_AMARILLO, OUTPUT);
pinMode(LED_VERDE, OUTPUT);

Serial.begin(115200);
Serial.println("Semaforo Iniciado");

apagarTodos();
}

void loop() {
luzVerde();
delay(TIEMPO_VERDE);

luzAmarilla();
delay(TIEMPO_AMARILLO);

luzRoja();
delay(TIEMPO_ROJO);
}

void luzRoja() {
digitalWrite(LED_ROJO, HIGH);
digitalWrite(LED_AMARILLO, LOW);
digitalWrite(LED_VERDE, LOW);
Serial.println("Luz Roja");
}

void luzAmarilla() {
digitalWrite(LED_ROJO, LOW);
 digitalWrite(LED_AMARILLO, HIGH);
digitalWrite(LED_VERDE, LOW);
Serial.println("Luz Amarilla");
}

void luzVerde() {
digitalWrite(LED_ROJO, LOW);
digitalWrite(LED_AMARILLO, LOW);
digitalWrite(LED_VERDE, HIGH);
Serial.println("Luz Verde");
}

void apagarTodos() {
digitalWrite(LED_ROJO, LOW);
digitalWrite(LED_AMARILLO, LOW);
digitalWrite(LED_VERDE, LOW);
}

9. Motor Speed Control

// Definición de pines
const int motorPin1 = 27; // IN1
const int motorPin2 = 26; // IN2
const int enablePin = 14; // ENA - Control de velocidad
const int potPin = 34; // Pin del potenciómetro

void setup() {
// Configurar pines del motor como salidas
pinMode(motorPin1, OUTPUT);
pinMode(motorPin2, OUTPUT);
pinMode(enablePin, OUTPUT);

// Iniciar comunicación serial para debug

 Serial.begin(115200);
}

void loop() {
// Leer el valor del potenciómetro (0-4095)
int potValue = analogRead(potPin);

// Convertir la lectura del potenciómetro (0-4095) a valores PWM (0-255)

int pwmValue = map(potValue, 0, 4095, 0, 255);

// Determinar la dirección basada en la posición del potenciómetro

if (potValue < 2048) { // Primera mitad del rango - dirección adelante
digitalWrite(motorPin1, HIGH);
digitalWrite(motorPin2, LOW);
// Mapear la velocidad para esta dirección
pwmValue = map(potValue, 0, 2047, 255, 0);
} else { // Segunda mitad del rango - dirección atrás
digitalWrite(motorPin1, LOW);
digitalWrite(motorPin2, HIGH);
// Mapear la velocidad para esta dirección
pwmValue = map(potValue, 2048, 4095, 0, 255);
}

// Aplicar la velocidad al motor

analogWrite(enablePin, pwmValue);

// Debug por serial

Serial.print("Potenciómetro: ");
Serial.print(potValue);
Serial.print(" PWM: ");
Serial.println(pwmValue);
 delay(100); // Pequeña pausa para estabilidad
}

10. Robot
// Definición de pines para LEDs
const int ENA = 2; // LED a
const int IN1 = 4; // LED b
const int IN2 = 5; // LED c
const int ENB = 12; // LED d
const int IN3 = 13; // LED e
const int IN4 = 14; // LED f
const int RED = 15; // LED g
const int GREEN = 23; // LED h (cambiado de 16 a 23)

// Definición de pines para pulsadores e interruptor

const int L = 18; // Pulsador L
const int F = 19; // Pulsador F
const int R = 21; // Pulsador R
const int SW = 22; // Interruptor general

// Función de configuración
void setup() {
// Configurar pines de LEDs como salidas
pinMode(ENA, OUTPUT);
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
pinMode(ENB, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
pinMode(RED, OUTPUT);
pinMode(GREEN, OUTPUT);
 // Configurar pines de entrada con resistencias pull-up
pinMode(L, INPUT_PULLUP);
pinMode(F, INPUT_PULLUP);
pinMode(R, INPUT_PULLUP);
pinMode(SW, INPUT_PULLUP);
}

// Función Adelante
void Adelante() {
digitalWrite(ENA, HIGH);
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
digitalWrite(ENB, HIGH);
digitalWrite(IN3, HIGH);
digitalWrite(IN4, LOW);
}

// Función Giro_Der
void Giro_Der() {
digitalWrite(ENA, HIGH);
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
digitalWrite(ENB, HIGH);
digitalWrite(IN3, LOW);
digitalWrite(IN4, HIGH);
}

// Función Giro_Izq
void Giro_Izq() {
digitalWrite(ENA, HIGH);
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
 digitalWrite(ENB, HIGH);
digitalWrite(IN3, HIGH);
digitalWrite(IN4, LOW);
}

// Función Reversa
void Reversa() {
digitalWrite(ENA, HIGH);
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
digitalWrite(ENB, HIGH);
digitalWrite(IN3, LOW);
digitalWrite(IN4, HIGH);
}

// Función Detener
void Detener() {
digitalWrite(ENA, LOW);
digitalWrite(IN1, LOW);
digitalWrite(IN2, LOW);
digitalWrite(ENB, LOW);
digitalWrite(IN3, LOW);
digitalWrite(IN4, LOW);
}

void loop() {
// Verificar estado del interruptor SW
if (digitalRead(SW) == HIGH) { // SW abierto
digitalWrite(RED, HIGH);
digitalWrite(GREEN, LOW);
Detener();
} else { // SW cerrado
 digitalWrite(RED, LOW);
digitalWrite(GREEN, HIGH);

// Verificar pulsadores
if (digitalRead(L) == LOW) { // Pulsador L presionado
Detener();
delay(2000);
Giro_Der();
delay(5000);
Adelante();
}
else if (digitalRead(F) == LOW) { // Pulsador F presionado
Detener();
delay(2000);
Giro_Der();
delay(5000);
Adelante();
}
else if (digitalRead(R) == LOW) { // Pulsador R presionado
Detener();
delay(2000);
Giro_Izq();
delay(5000);
Adelante();
}
else { // Ningún pulsador presionado
Adelante();
}
}
}