C++ Arduino · IoT · 2º Bachillerato

PRYC.2.D.2 · IoT · Microcontroladores · 2º Bachillerato

C++ Arduino:
Condicionales & Bucles
nivel avanzado

Asignatura
Programación y Computación

Bloque D
Computación física y robótica

Subapartado
PRYC.2.D.1.2
Microcontroladores, E/S,
sensores y actuadores

FILTRAR:

Todos (10)

Condicionales (3)

Bucle for (3)

Bucle while (2)

Mixtos (2)

Condicionales

3 ejercicios

C-01 Condicional Sistema de control de temperatura con modos

★★☆☆ ▼

🌡️ Un termostato inteligente decide qué actuador activar según la temperatura. Simula la lógica de control antes de conectar el sensor DHT11.

Declara una variable float temp con un valor entre -10 y 50. Según el valor, imprime la acción del sistema:

— temp < 0 → “ALERTA: Riesgo de congelación. Calefacción máxima.”
— 0 ≤ temp < 18 → “Calefacción activada.”
— 18 ≤ temp ≤ 24 → “Temperatura confortable. Sistemas en reposo.”
— 24 < temp ≤ 35 → “Ventilación activada.”
— temp > 35 → “ALERTA: Sobrecalentamiento. Aire acondicionado máximo + alarma.”

Imprime también la temperatura con una decimal.

Variable	Tipo	Descripción
temp	float	Temperatura simulada en °C
—	—	No se necesitan más variables

Usa if / else if / else if / else if / else con 5 ramas.
El orden importa: comprueba primero los extremos.
Para imprimir con una decimal: Serial.println(temp, 1);
Las condiciones intermedias no necesitan doble comparación si están en cadena else if.

Reto ampliación: Añade una segunda variable int humedad (0–100%). Si temp > 24 y humedad > 70, añade al mensaje: “Índice de calor elevado — ventilación prioritaria.”

// C-01: Termostato inteligente con 5 modos

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

  float temp = 28.5;  // Cambia este valor para probar

  Serial.print("Temperatura: ");
  Serial.print(temp, 1);
  Serial.println(" °C  →  ");

  if (temp < 0) {
    Serial.println("ALERTA: Riesgo de congelacion. Calefaccion maxima.");
  } else if (temp < 18) {
    Serial.println("Calefaccion activada.");
  } else if (temp <= 24) {
    Serial.println("Temperatura confortable. Sistemas en reposo.");
  } else if (temp <= 35) {
    Serial.println("Ventilacion activada.");
  } else {
    Serial.println("ALERTA: Sobrecalentamiento. AC maximo + alarma.");
  }
}

void loop() { }

C-02 Condicional Semáforo inteligente con sensor de tráfico

★★★☆ ▼

🚦 Un semáforo IoT adapta su modo según la densidad de tráfico y la hora del día. Lógica real usada en ciudades inteligentes.

Declara int vehiculosPorMinuto (0–200) y bool esNoche. Aplica esta lógica con operadores && y ||:

— Si es de noche (esNoche == true) → imprime “Modo nocturno: luz ámbar intermitente.” (independientemente del tráfico)
— Si es de día y hay más de 100 veh/min → “Tráfico denso: ciclo corto (20s verde / 5s ámbar / 15s rojo).”
— Si es de día y hay entre 40 y 100 veh/min → “Tráfico moderado: ciclo normal (30/5/25).”
— Si es de día y hay menos de 40 veh/min → “Tráfico fluido: ciclo largo (45/5/20).”

Imprime también el número de vehículos por minuto detectados.

Comprueba esNoche primero con un if simple.
El resto de condiciones van en else if anidados bajo el caso de día.
No necesitas escribir vehiculos >= 40 && vehiculos <= 100 si ya descartaste el caso >100 en el else if anterior.
Prueba con: vehiculos = 75, esNoche = false.

Reto ampliación: Añade una tercera variable bool hayEmergencia. Si es true, independientemente de todo lo demás, imprime “EMERGENCIA: todos los semáforos en rojo.” Coloca esta comprobación antes de cualquier otra.

// C-02: Semáforo inteligente IoT

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

  int  vehiculosPorMinuto = 75;
  bool esNoche            = false;

  Serial.print("Vehiculos/min: ");
  Serial.println(vehiculosPorMinuto);

  if (esNoche) {
    Serial.println("Modo nocturno: luz ambar intermitente.");
  } else if (vehiculosPorMinuto > 100) {
    Serial.println("Trafico denso: ciclo corto (20s/5s/15s).");
  } else if (vehiculosPorMinuto >= 40) {
    Serial.println("Trafico moderado: ciclo normal (30s/5s/25s).");
  } else {
    Serial.println("Trafico fluido: ciclo largo (45s/5s/20s).");
  }
}

void loop() { }

C-03 Condicional Control de acceso por nivel de batería y señal

★★★☆ ▼

🔋 Un dispositivo IoT decide si puede transmitir datos según su batería y la calidad de la señal WiFi. Patrón muy común en sensores de campo.

Declara int bateria (0–100) y int rssi (intensidad WiFi, valores entre -100 y 0 dBm; cuanto más cercano a 0, mejor señal). Implementa:

— bateria < 10 → “ERROR CRÍTICO: batería insuficiente. Apagado de emergencia.” (sin importar señal)
— bateria entre 10 y 20 → “Batería baja. Modo ahorro: solo datos críticos.”
— bateria > 20 y rssi < -80 → “Señal débil. Reintentando conexión… datos en cola.”
— bateria > 20 y rssi entre -80 y -50 → “Conexión aceptable. Transmisión normal.”
— bateria > 20 y rssi > -50 → “Señal excelente. Transmisión de alta frecuencia activada.”

Imprime los valores de batería y RSSI al inicio.

La batería crítica (<10) se comprueba primero con un if independiente.
Para la batería baja (10–20), un else if (bateria <= 20) es suficiente (ya sabemos que ≥10).
El tercer else cubre batería >20. Dentro, anida nuevos if/else if/else con el RSSI.
Prueba con: bateria = 45, rssi = -65

Reto ampliación: Añade una variable bool modoAvion. Si es true, el primer mensaje siempre debe ser “MODO AVIÓN: WiFi desactivado.” y no se evalúa ninguna otra condición. Implementa esto con un if al principio y un else que contenga toda la lógica anterior.

// C-03: Control de acceso por batería y señal WiFi

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

  int bateria = 45;   // %  (0-100)
  int rssi    = -65;  // dBm (−100 a 0)

  Serial.print("Bateria: "); Serial.print(bateria); Serial.println("%");
  Serial.print("RSSI:    "); Serial.print(rssi);    Serial.println(" dBm");
  Serial.println("---");

  if (bateria < 10) {
    Serial.println("ERROR CRITICO: bateria insuficiente. Apagado.");
  } else if (bateria <= 20) {
    Serial.println("Bateria baja. Modo ahorro: solo datos criticos.");
  } else {
    // Bateria > 20: evaluamos señal
    if (rssi < -80) {
      Serial.println("Senal debil. Reintentando... datos en cola.");
    } else if (rssi <= -50) {
      Serial.println("Conexion aceptable. Transmision normal.");
    } else {
      Serial.println("Senal excelente. Transmision alta frecuencia.");
    }
  }
}

void loop() { }

Bucle for

3 ejercicios

F-01 Bucle for Calibración de sensor: media de N lecturas

★★☆☆ ▼

📡 Al arrancar un sistema IoT real, los sensores analógicos se calibran promediando varias lecturas para eliminar el ruido. Este es el patrón exacto.

Simula un array de 8 lecturas de un sensor de luz (valores enteros entre 0 y 1023, como los que daría analogRead()). Usa un bucle for para:

1. Imprimir cada lectura numerada (Lectura 1, Lectura 2…)
2. Acumular la suma total
3. Al finalizar el bucle, calcular e imprimir la media con dos decimales.
4. Si la media supera 800, imprime “Luz intensa: ajustando exposición.”
5. Si la media es menor de 200, imprime “Luz escasa: activando sensor IR.”

Variable	Tipo	Descripción
lecturas[8]	int[]	Array con 8 valores simulados
suma	long	Acumulador de la suma
media	float	Resultado de suma / 8

Declara el array: int lecturas[8] = {530, 545, 512, 558, 527, 540, 521, 535};
El bucle va de i = 0 a i < 8 (los arrays en C++ empiezan en índice 0).
Dentro: suma += lecturas[i];
Después del bucle: float media = (float)suma / 8; — el cast (float) es necesario.
Para dos decimales: Serial.println(media, 2);

Reto ampliación: Dentro del mismo bucle, busca también el valor máximo y el mínimo del array e imprímelos al final. Necesitarás dos variables extra (int maxVal, int minVal) inicializadas antes del bucle.

// F-01: Calibración de sensor – media de 8 lecturas

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

  int lecturas[8] = {530, 545, 512, 558, 527, 540, 521, 535};
  long suma = 0;

  for (int i = 0; i < 8; i++) {
    Serial.print("Lectura ");
    Serial.print(i + 1);
    Serial.print(": ");
    Serial.println(lecturas[i]);
    suma += lecturas[i];
  }

  float media = (float)suma / 8;
  Serial.print("Media: ");
  Serial.println(media, 2);

  if (media > 800) {
    Serial.println("Luz intensa: ajustando exposicion.");
  } else if (media < 200) {
    Serial.println("Luz escasa: activando sensor IR.");
  }
}

void loop() { }

F-02 Bucle for Secuencia de arranque progresivo (PWM simulado)

★★★☆ ▼

💡 El PWM (modulación por ancho de pulso) controla la potencia de un actuador (LED, motor, ventilador) variando el ciclo de trabajo. Aquí se simula su rampa de subida y bajada.

Simula el encendido y apagado progresivo de un LED (0–255 en PWM) usando dos bucles for:

— El primero sube de 0 a 255 en pasos de 5: imprime “PWM subiendo: X”
— El segundo baja de 255 a 0 en pasos de 5: imprime “PWM bajando: X”

Añade un condicional dentro de cada bucle: si el valor PWM es mayor de 200, añade al final de la línea ” ← ¡BRILLO MÁXIMO!”. Si es menor de 30, añade ” ← casi apagado.”

Al terminar los dos bucles imprime “Secuencia PWM completada.”

Bucle subida: for (int pwm = 0; pwm <= 255; pwm += 5)
Bucle bajada: for (int pwm = 255; pwm >= 0; pwm -= 5)
Dentro de cada bucle, usa Serial.print() para el texto base y luego un if/else if para el texto adicional con Serial.println().
Si no se cumple ninguna condición, imprime solo un salto de línea: Serial.println();

Reto ampliación: Añade un tercer bucle que realice el mismo efecto pero con pasos de 15 (más rápido). Compara visualmente la salida del Serial Monitor con los otros dos bucles. ¿Qué ventajas tendría cada velocidad en un LED de señalización real?

// F-02: Rampa PWM simulada con condicional interno

void imprimirPWM(int pwm, bool subiendo) {
  if (subiendo) Serial.print("PWM subiendo: ");
  else          Serial.print("PWM bajando: ");
  Serial.print(pwm);

  if      (pwm > 200) Serial.println(" <- BRILLO MAXIMO!");
  else if (pwm < 30)  Serial.println(" <- casi apagado.");
  else                  Serial.println();
}

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

  // Rampa de subida
  for (int pwm = 0; pwm <= 255; pwm += 5) {
    imprimirPWM(pwm, true);
  }

  // Rampa de bajada
  for (int pwm = 255; pwm >= 0; pwm -= 5) {
    imprimirPWM(pwm, false);
  }

  Serial.println("Secuencia PWM completada.");
}

void loop() { }

F-03 Bucle for Mapa de pines: diagnóstico de puertos digitales

★★★★ ▼

🔌 Antes de conectar componentes, los técnicos verifican el estado de los pines con un diagnóstico. Este ejercicio simula ese proceso con arrays paralelos.

Tienes dos arrays del mismo tamaño (6 elementos): int pines[6] con los números de pin (2, 3, 4, 5, 6, 7) y int estados[6] con sus estados simulados (usa 0 y 1).

Usa un bucle for para recorrer ambos arrays simultáneamente e imprimir para cada pin:

— “Pin X → ALTO” si el estado es 1
— “Pin X → BAJO” si el estado es 0

Además, lleva dos contadores (contAlto y contBajo) y al finalizar imprime un resumen: “Pines en ALTO: N | Pines en BAJO: M”. Si todos los pines están en BAJO imprime “ALERTA: ningún pin activo.”

Declara: int pines[6] = {2,3,4,5,6,7}; y int estados[6] = {1,0,1,1,0,0};
El bucle usa el mismo índice i para acceder a ambos arrays: pines[i] y estados[i].
Inicializa los contadores a 0 antes del bucle y usa contAlto++ dentro del if.
La alerta de “ningún pin activo” se comprueba comparando contAlto == 0 después del bucle.

Reto ampliación: Añade un tercer array String nombres[6] = {"boton1","led1","rele","servo","buzzer","sensor"}; e incluye el nombre del componente en el mensaje: “Pin 2 (boton1) → ALTO”.

// F-03: Diagnóstico de pines con arrays paralelos

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

  int pines[6]  = {2, 3, 4, 5, 6, 7};
  int estados[6] = {1, 0, 1, 1, 0, 0};

  int contAlto = 0;
  int contBajo = 0;

  for (int i = 0; i < 6; i++) {
    Serial.print("Pin ");
    Serial.print(pines[i]);
    Serial.print(" -> ");

    if (estados[i] == 1) {
      Serial.println("ALTO");
      contAlto++;
    } else {
      Serial.println("BAJO");
      contBajo++;
    }
  }

  Serial.println("---");
  Serial.print("Pines en ALTO: "); Serial.print(contAlto);
  Serial.print("  |  Pines en BAJO: "); Serial.println(contBajo);

  if (contAlto == 0) {
    Serial.println("ALERTA: ningun pin activo.");
  }
}

void loop() { }

Bucle while

2 ejercicios

W-01 Bucle while Espera activa: conectando al servidor MQTT

★★★☆ ▼

🌐 MQTT es el protocolo más usado en IoT. Los dispositivos esperan conexión con reintentos y timeout. Este es el patrón de reconexión estándar.

Simula el proceso de conexión a un broker MQTT. Declara bool conectado = false, int intentos = 0 y int maxIntentos = 5.

Usa un bucle while que se repita mientras !conectado && intentos < maxIntentos. En cada iteración:

1. Incrementa el contador de intentos.
2. Imprime “Intento X de 5: conectando a broker MQTT…”
3. Si intentos == 3, cambia conectado = true (simulamos que conecta en el 3er intento).

Tras el bucle, evalúa con un if: si conectado imprime “✓ Conexion establecida en el intento X.”, si no imprime “✗ Fallo de conexion. Dispositivo en modo offline.”

La condición del while usa el operador ! (NOT): while (!conectado && intentos < maxIntentos)
Incrementa antes de imprimir: así el mensaje dice “Intento 1” desde el inicio.
La comprobación if (intentos == 3) va al final del cuerpo del bucle.
Para el mensaje final, intentos conserva su valor al salir del bucle.
Prueba cambiando intentos == 3 por intentos == 7 para simular fallo total.

Reto ampliación: Añade un contador de “tiempo simulado”: cada intento cuesta 2000 ms (representa delay(2000) real). Calcula e imprime el tiempo total empleado en la conexión: int tiempoMs = intentos * 2000;

// W-01: Reintentos de conexión MQTT con timeout

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

  bool conectado  = false;
  int  intentos   = 0;
  int  maxIntentos = 5;

  while (!conectado && intentos < maxIntentos) {
    intentos++;
    Serial.print("Intento ");
    Serial.print(intentos);
    Serial.print(" de ");
    Serial.print(maxIntentos);
    Serial.println(": conectando a broker MQTT...");

    if (intentos == 3) {
      conectado = true;  // Simulamos éxito en el intento 3
    }
  }

  if (conectado) {
    Serial.print("[OK] Conexion establecida en el intento ");
    Serial.println(intentos);
  } else {
    Serial.println("[FALLO] Timeout. Dispositivo en modo offline.");
  }
}

void loop() { }

W-02 Bucle while Vaciado de depósito: control de nivel con histéresis

★★★★ ▼

💧 La histéresis evita que un actuador se encienda/apague continuamente en el umbral. Es un concepto clave en control industrial y automatización del hogar.

Un depósito empieza con float nivel = 100.0 litros. Una bomba extrae 7.5 litros por ciclo, pero solo si el nivel supera 15 litros (umbral de seguridad).

Usa un while que siga mientras nivel > 15. En cada iteración:

1. Resta 7.5 al nivel.
2. Si el nuevo nivel queda por debajo de 0, corrígelo a 0.
3. Imprime el ciclo número N y el nivel actual con 1 decimal.
4. Si el nivel cae entre 15 y 30 (zona de aviso), añade ” ⚠ Nivel bajo.”

Al salir del bucle imprime “Bomba detenida. Nivel residual: X L”

Necesitas un contador de ciclos: int ciclo = 0; que incrementas al inicio de cada iteración.
Resta primero: nivel -= 7.5; y luego comprueba si quedó por debajo de 0.
La condición del aviso: if (nivel > 15 && nivel <= 30) — solo si aún no ha parado.
Recuerda que el nivel nunca llegará exactamente a 15 con pasos de 7.5 — la condición del while lo detiene en la primera vez que es ≤ 15.

Reto ampliación: Añade una segunda bomba que solo entra en funcionamiento si el nivel supera 80 litros, extrayendo 15 L/ciclo (bomba rápida). Por debajo de 80, solo trabaja la bomba lenta (7.5 L/ciclo). Usa un condicional dentro del while para elegir cuánto restar.

// W-02: Control de nivel de depósito con histéresis

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

  float nivel = 100.0;
  int   ciclo = 0;

  while (nivel > 15.0) {
    ciclo++;
    nivel -= 7.5;

    if (nivel < 0) nivel = 0;  // Protección

    Serial.print("Ciclo "); Serial.print(ciclo);
    Serial.print(": Nivel = ");
    Serial.print(nivel, 1);
    Serial.print(" L");

    if (nivel > 15.0 && nivel <= 30.0) {
      Serial.print("  [!] Nivel bajo.");
    }
    Serial.println();
  }

  Serial.print("Bomba detenida. Nivel residual: ");
  Serial.print(nivel, 1);
  Serial.println(" L");
}

void loop() { }

Mixtos · for + while + condicionales

2 ejercicios

M-01 Mixto Monitor de calidad del aire: clasificación AQI

★★★★ ▼

🏭 Los sensores MQ-135 y similares miden partículas en ppm. El índice AQI clasifica la calidad del aire. Este ejercicio combina arrays, bucle for y condicionales multi-nivel.

Tienes un array de 6 mediciones del sensor de CO₂ en ppm: {412, 850, 1200, 390, 2100, 680}.

Usa un bucle for para procesar cada lectura e imprime su clasificación AQI:

— ppm < 500 → “BUENA (verde)”
— 500–999 → “MODERADA (amarillo)”
— 1000–1499 → “MALA PARA GRUPOS SENSIBLES (naranja)”
— ≥ 1500 → “PELIGROSA (rojo) — activar ventilación”

Lleva un contador por categoría. Al finalizar, usa un bucle while para imprimir una línea de asteriscos (uno por cada lectura peligrosa, si hay). Si no hay ninguna peligrosa, imprime “Sin alertas críticas.”

Declara 4 contadores: int cBuena=0, cModerada=0, cMala=0, cPeligrosa=0;
El bucle for recorre el array de 0 a 5 y usa if/else if/else para clasificar.
El bucle while al final: int i = 0; while (i < cPeligrosa) { Serial.print("*"); i++; }
Recuerda imprimir un Serial.println() tras el while para terminar la línea de asteriscos.

Reto ampliación: Calcula también el promedio de ppm de las lecturas peligrosas (≥1500). Necesitarás una variable long sumaPeligrosas que acumules dentro del if correspondiente, y divides al final entre cPeligrosa (con comprobación de que no sea 0 antes de dividir).

// M-01: Clasificación AQI – for + condicionales + while

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

  int ppm[6] = {412, 850, 1200, 390, 2100, 680};
  int cBuena = 0, cModerada = 0, cMala = 0, cPeligrosa = 0;

  for (int i = 0; i < 6; i++) {
    Serial.print("Lectura "); Serial.print(i+1);
    Serial.print(": "); Serial.print(ppm[i]);
    Serial.print(" ppm → ");

    if      (ppm[i] < 500)  { Serial.println("BUENA (verde)"); cBuena++; }
    else if (ppm[i] < 1000) { Serial.println("MODERADA (amarillo)"); cModerada++; }
    else if (ppm[i] < 1500) { Serial.println("MALA SENSIBLES (naranja)"); cMala++; }
    else                    { Serial.println("PELIGROSA (rojo) - ventilacion!"); cPeligrosa++; }
  }

  Serial.println("=== RESUMEN ===");
  Serial.print("Buena:"); Serial.print(cBuena);
  Serial.print("  Moderada:"); Serial.print(cModerada);
  Serial.print("  Mala:"); Serial.print(cMala);
  Serial.print("  Peligrosa:"); Serial.println(cPeligrosa);

  if (cPeligrosa == 0) {
    Serial.println("Sin alertas criticas.");
  } else {
    Serial.print("Alertas: ");
    int j = 0;
    while (j < cPeligrosa) { Serial.print("* "); j++; }
    Serial.println();
  }
}

void loop() { }

M-02 Mixto Secuencia Fibonacci para temporización adaptativa

★★★★ ▼

⏱️ Algunos protocolos IoT usan retroceso exponencial (similar a Fibonacci) para espaciar los reintentos de conexión. Este ejercicio combina lógica de bucles con condiciones de parada.

Genera la secuencia de Fibonacci (0, 1, 1, 2, 3, 5, 8, 13…) usando un bucle while, pero con estas reglas:

— Para cuando el valor supere 500 (representa 500 ms máximo de espera).
— Para cada número generado, imprime: “Espera [N]: X ms”
— Si X está entre 50 y 150 ms, añade ” ← ventana óptima”
— Si X > 200 ms, añade ” ← demasiado lento, ajustando…”

Después, usa un bucle for para imprimir una barra de progreso ASCII proporcional al último valor generado: un carácter # por cada 50 ms (redondeado), con un máximo de 10 caracteres.

Al final imprime el número total de intervalos generados.

Fibonacci necesita tres variables: int a=0, b=1, siguiente;
En cada iteración del while: siguiente = a + b; a = b; b = siguiente;
La condición del while: while (a <= 500) — comprueba a antes de calcularlo.
Para la barra: int barras = a / 50; luego if (barras > 10) barras = 10;
El bucle for de la barra: for (int k=0; k<barras; k++) Serial.print("#");

Reto ampliación: Añade junto a la barra # los espacios vacíos hasta 10 caracteres, usando un segundo for que imprima “.” para rellenar: for (int k=barras; k<10; k++) Serial.print("."); — así obtienes una barra de ancho fijo tipo [###.......].

// M-02: Fibonacci para temporización + barra ASCII

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

  int a = 0, b = 1, siguiente;
  int contador = 0;
  int ultimo = 0;

  while (a <= 500) {
    contador++;
    Serial.print("Espera ["); Serial.print(contador);
    Serial.print("]: "); Serial.print(a); Serial.print(" ms");

    if      (a >= 50 && a <= 150) Serial.print("  <- ventana optima");
    else if (a > 200)              Serial.print("  <- demasiado lento, ajustando...");
    Serial.println();

    ultimo    = a;
    siguiente = a + b;
    a = b;
    b = siguiente;
  }

  // Barra de progreso ASCII
  int barras = ultimo / 50;
  if (barras > 10) barras = 10;

  Serial.print("[Ultimo: "); Serial.print(ultimo); Serial.print(" ms]  [");
  for (int k = 0; k < barras; k++)  Serial.print("#");
  for (int k = barras; k < 10; k++) Serial.print(".");
  Serial.println("]");

  Serial.print("Total intervalos generados: ");
  Serial.println(contador);
}

void loop() { }

C++

Ejercicios Arduino PYC 2BACH NIVEL2 IOT (Claude)

C++ Arduino:
Condicionales & Bucles
nivel avanzado

Condicionales

Bucle for

Bucle while

Mixtos · for + while + condicionales

Ejercicios C++ Arduino Tecnología 4ESO

Ejercicios Arduino PYC 2BACH NIVEL2 IOT (ChatGPT)

Deja una respuesta Cancelar la respuesta

C++

Condicionales

Bucle for

Bucle while

Mixtos · for + while + condicionales

También te puede interesar

Deja una respuesta Cancelar la respuesta