Clase 2 — Sensores analógicos
Sensores a cubrir: LM35, LDR, Potenciómetro, (entrada analógica general)
FALTA
Qué se hizo (objetivo de la práctica).
Explicación breve del sensor / puntos a enseñar (con errores típicos a evitar).
Diagrama de conexión (texto).
Código Arduino que imprime por Serial y además muestra en LCD
Notas de calibración, filtro y cómo repartir entre equipos.
1. Lectura LM35: medir T ambiente y mostrar en Serial + LCD.
2. LDR: formar divisor resistivo con 10k → leer luz, mostrar lectura analógica y
mapear a % luz.
3. Potenciómetro: usar como entrada para controlar brillo (PWM) de un LED.
4. Módulo micrófono – Algunos módulos KY-038 tienen salida analógica además
de digital (A0).
5. Joystick – Tiene dos ejes con potenciómetros internos (X, Y) → dos señales
analógicas, más un botón digital.
6. Sensor de nivel –
EJERCICIOS
1) Lectura LM35 — medir temperatura ambiente y mostrar en
Serial
Qué se hace: leer la salida del LM35, promediar para reducir ruido, convertir el
valor ADC a °C y mostrar en Serial.
Conceptos a explicar: LM35: salida lineal 10 mV/°C. ADC de Arduino retorna
0..1023 para 0..Vref (por defecto ~5.0 V en UNO). Fórmula: V = ADC *
(Vref/1023) → T(°C) = V * 100.
Conexión (pines):
FALTA
Código (LM35):
int sensorPin = A0; // Pin analógico conectado al LM35
float temperatura = 0; // Variable para almacenar la temperatura
void setup() {
Serial.begin(9600); // Inicializa la comunicación serial
void loop() {
// Lee el valor analógico del sensor
int lectura = analogRead(sensorPin);
// Convierte la lectura a voltaje (0-1023 a 0-5V)
float voltaje = lectura * 5.0 / 1024.0; // Convierte el voltaje a grados Celsius (10mV
por grado)
temperatura = voltaje * 100; // Muestra la temperatura en el monitor serial
Serial.print("Temperatura: ");
Serial.print(temperatura);
Serial.println(" °C");
delay(1000); // Espera 1 segundo
Notas / enseñanza:
Enseñar error por la referencia de 5V: si funciona con USB la referencia puede
variar → para alta precisión usar referencia externa o
analogReference(INTERNAL) y adaptar cálculo.
Promediado reduce ruido. Mostrar tabla ADC → °C para calibración.
2) LDR — divisor resistivo con 10k → leer luz, mostrar lectura
analógica y mapear a % luz
Qué se hace: montar LDR + resistor 10k en divisor, leer A1 Y según la lectura
prender o apagar el led
Conexión divisor (forma recomendada):
5V → LDR → punto A → resistor 10k → GND
→ punto A → A1 del Arduino
(En este montaje: en más luz LDR disminuye R, por lo tanto Vout baja. Por eso
la lectura se invierte para % luz).
Código (LDR ):
int valorldr=0;
int pinled=13;
int pinldr=A1;
void setup() {
pinMode(pinled, OUTPUT);
Serial.begin(9600);
// put your setup code here, to run once:
void loop() {
valorldr=analogRead(pinldr);
Serial.println(valorldr);
delay(100);
if (valorldr<500){
digitalWrite(pinled,1);
}
else if ((valorldr>=600) & (valorldr<=1017)){
digitalWrite(pinled,0);
// put your main code here, to run repeatedly:
}
}
Notas / enseñanza:
Mostrar cómo cambiar la resistencia fija (10k) afecta sensibilidad del divisor.
Explicar punto de operación.
Opcional: medir R_LDR usando fórmula del divisor y tabla de lux si se desea
calibrar.
3) Potenciómetro → controlar brillo (PWM) de un LED
Qué se hace: leer potenciómetro (A2), mapear 0..1023 a 0..255 y usar
analogWrite() en un pin PWM (ej. pin 9) para cambiar brillo.
Conexión:
Código (potenciómetro → PWM LED):
const int pinPotenciometro = A2; // Pin analógico para el potenciómetro
const int pinPWM = 9; // Pin PWM para el control de brillo
void setup() {
pinMode(pinPWM, OUTPUT); // Se configura el pin PWM como salida
void loop() {
int valorPotenciometro = analogRead(pinPotenciometro); // Se lee el valor del
potenciómetro (0-1023)
int valorPWM = map(valorPotenciometro, 0, 1023, 0, 255); // Se mapea el
valor a un rango de 0 a 255
analogWrite(pinPWM, valorPWM); // Se escribe el valor PWM en el pin para
controlar el brillo
Notas / enseñanza:
Explicar que analogWrite() genera PWM y no voltaje analógico real; mostrar
concepto de ciclo de trabajo.
Mencionar frecuencia PWM por defecto y que algunos pines (5 y 6) tienen
distinta frecuencia.
Usar resistencia en serie para el LED (220Ω–330Ω).
Calculo de resistencia
4) Módulo micrófono (KY-038 u otro) — lectura analógica y
digital
Qué se hace: leer salida analógica (A3) para medir amplitud y digital (D2) para
detección por comparador. Mostrar valor RMS aproximado / pico y activar
LED/buzzer cuando hay un pico de ruido.
Conexión:
Módulo micrófono: Vcc→5V, GND→GND, A0 → A3, D0 → D2
LED indicador → pin 13 (o cualquier) con resistor
Buzzer → pin 10 (opcional)
Código (microphone analog + digital):
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,16,2);
const int MIC_A = A3;
const int MIC_D = 2;
const int LED_PIN = 13;
const int BUZZ_PIN = 10;
const int SAMPLE_MS = 50; // ventana de muestreo
void setup(){
Serial.begin(115200);
lcd.init(); lcd.backlight();
pinMode(MIC_D, INPUT);
pinMode(LED_PIN, OUTPUT);
pinMode(BUZZ_PIN, OUTPUT);
lcd.setCursor(0,0); lcd.print("Microfono");
}
int readAnalogPeak() {
unsigned long start = millis();
int maxv = 0;
while (millis() - start < SAMPLE_MS) {
int v = analogRead(MIC_A);
if (v > maxv) maxv = v;
return maxv; // pico en ventana
void loop() {
int peak = readAnalogPeak(); // 0..1023
int dig = digitalRead(MIC_D); // 0/1 (segun umbral)
Serial.print("AN pico: "); Serial.print(peak);
Serial.print(" D: "); Serial.println(dig);
// Mostrar en LCD
lcd.setCursor(0,0);
lcd.print("Pico: ");
lcd.print(peak);
lcd.print(" ");
lcd.setCursor(0,1);
lcd.print("Trig: ");
lcd.print(dig);
lcd.print(" ");
// Accion: si comparador digital se activa o pico grande -> LED y beep
if (dig == HIGH || peak > 600) {
digitalWrite(LED_PIN, HIGH);
tone(BUZZ_PIN, 2000, 150);
} else {
digitalWrite(LED_PIN, LOW);
noTone(BUZZ_PIN);
delay(150);
Notas / enseñanza:
Diferencia entre salida analógica (útil para ver intensidad) y digital (comparator
con potenciómetro onboard).
Para detectar voz usar RMS o filtrado; ejemplo simple usa pico en ventana.
Explicar ruido ambiente, calibración del umbral digital con el potenciómetro en
el módulo.
5) Joystick — ejes X/Y (analógicos) y botón (digital)
Qué se hace: leer X e Y (A4, A5 por ejemplo) y el botón (D3). Mostrar valores y
usar X para controlar PWM LED y Y para controlar servo (ejemplo de uso
práctico).
Conexión:
Código (joystick lectura + control LED PWM):
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <Servo.h>
Servo myservo;
const int JOY_X = A4;
const int JOY_Y = A5;
const int JOY_SW = 3;
const int LED_PWM = 6;
const int SERVO_PIN = 9;
void setup(){
Serial.begin(9600);
lcd.init(); lcd.backlight();
pinMode(JOY_SW, INPUT_PULLUP); // boton conectado a GND cuando
presionado
pinMode(LED_PWM, OUTPUT);
myservo.attach(SERVO_PIN);
lcd.setCursor(0,0); lcd.print("Joystick");
int readAvg(int pin, int n=4){
long s=0;
for(int i=0;i<n;i++){ s += analogRead(pin); delay(2); }
return s/n;
void loop(){
int x = readAvg(JOY_X);
int y = readAvg(JOY_Y);
bool btn = digitalRead(JOY_SW) == LOW; // LOW = presionado
// map X to PWM 0..255
int pwm = map(x, 0, 1023, 0, 255);
analogWrite(LED_PWM, pwm);
// map Y to servo angle 0..180
int angle = map(y, 0, 1023, 0, 180);
myservo.write(angle);
Serial.print("X:"); Serial.print(x);
Serial.print(" Y:"); Serial.print(y);
Serial.print(" Btn:"); Serial.println(btn);
lcd.setCursor(0,0);
lcd.print("X:");
lcd.print(map(x,0,1023,0,100));
lcd.print("% ");
lcd.setCursor(0,1);
lcd.print("Btn:");
lcd.print(btn ? "P" : " - ");
lcd.print(" Y:");
lcd.print(map(y,0,1023,0,100));
lcd.print("% ");
delay(100);
Notas / enseñanza:
Explicar que joystick suele usar INPUT_PULLUP para el botón porque el switch
conecta a GND cuando presionado.
Mostrar uso práctico: joystick para controlar robot o UI para menú en LCD.
6) Sensor de nivel — dos variantes: float switch (digital) y sonda
resistiva (analógica)
Qué se hace: mostrar ambas aproximaciones y código para cada una. Elegir
según el sensor físico que tengas.
A) Float switch (interruptor de nivel) — digital simple
Conexión:
Float switch: un terminal → GND, otro terminal → D4 (digital)
D4 configurado con INPUT_PULLUP en Arduino (float cerrado a GND cuando
activado)
Código (float switch digital):
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,16,2);
const int FLOAT_PIN = 4;
void setup(){
Serial.begin(9600);
lcd.init(); lcd.backlight();
pinMode(FLOAT_PIN, INPUT_PULLUP);
lcd.setCursor(0,0); lcd.print("Sensor Nivel");
void loop(){
bool estado = digitalRead(FLOAT_PIN) == LOW; // LOW = contacto (nivel
alcanzado)
Serial.print("Nivel: ");
Serial.println(estado ? "ALTO" : "BAJO");
lcd.setCursor(0,0);
lcd.print("Nivel: ");
lcd.print(estado ? "ALTO " : "BAJO ");
delay(500);
Notas / enseñanza:
INPUT_PULLUP evita necesidad de resistor externo.
Explicar bouncing mecánico y cómo filtrar si es necesario (simple debounce).
B) Sonda resistiva / sensor de nivel analógico — lectura proporcional
Conexión (ejemplo):
Sonda entre 5V y A6? (No todas las placas tienen A6). Mejor: usar divisor: 5V →
sonda → punto A → resistor fijo 10k → GND; punto A → A6 (o A0 si no usás
otra entrada).
Si la sonda cambia resistencia según nivel, la lectura será proporcional.
Código (nivel analógico):
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,16,2);
const int LEVEL_A = A0; // ajustar pin
const int NUM_READS = 8;
int readLevelRaw() {
long s = 0;
for (int i=0;i<NUM_READS;i++){
s += analogRead(LEVEL_A);
delay(3);
}
return s / NUM_READS;
void setup(){
Serial.begin(9600);
lcd.init(); lcd.backlight();
lcd.setCursor(0,0); lcd.print("Nivel analogico");
void loop(){
int raw = readLevelRaw(); // 0..1023
int percent = map(raw, 0, 1023, 0, 100);
Serial.print("Nivel raw: "); Serial.print(raw);
Serial.print(" %: "); Serial.println(percent);
lcd.setCursor(0,0);
lcd.print("Nivel: ");
lcd.print(percent);
lcd.print("% ");
delay(500);
Notas / enseñanza:
Calibrar con agua a 0% y 100% para línea base.
Asegurarse de que la sonda y la placa no produzcan corrientes peligrosas (aislar
y manejar alimentación de forma segura).
Clase 3 — Sensores digitales
Sensores a cubrir: Sensor de vibración, Módulo micrófono, Sensor de humedad y temp.
(p. ej. DHT), Sensor de nivel, Control remoto (IR), RFID (introducción).
Actividades prácticas:
1. micrófono → detección de evento: interrupción o lectura digital para activar
buzzer/LED.
2. DHT (si es DHT11/DHT22) → lectura por librería, mostrar temp/hum en LCD +
enviar por Serial.
3. IR control remoto → decodificar un botón y ejecutar acción (p. ej.
encender LED).
4. RFID → lectura UID y activar relé si UID coincide.
5. Sensor de vibración → salida digital ON/OFF cuando detecta vibración
fuerte. Útil para alarmas o detección de golpes.
6. Módulo micrófono (salida digital D0) Además de salida analógica,
tiene comparador que entrega digital alto/bajo según umbral. Permite hacer
alarma por sonido sin procesar amplitud.
Clase 4 — Actuadores digitales y visualizadores
(objetivo: salida digital y expansión)
Actuadores & visualizadores: LEDs, relé, buzzer, SN74HC595, Displays 7-seg y LCD,
Matriz LED.
Actividades prácticas:
Control de LED y relé con pulsador y debouncing.
Display 7-segmentos y LCD: mostrar números/strings;
multiplexado básico en 4 dígitos.
Faltan mas ejercicios
Clase 5 — Actuadores analógicos y control (objetivo:
PWM, servos, motores paso a paso)
Actuadores: Servomotor
motor paso a paso + driver
buzzer (tono)
PWM para control de brillo/velocidad.
Actividades prácticas:
Servo: ángulo controlado por potenciómetro; crear un pequeño “robot” que abra/
cierre por RFID o botón.
1. Paso a paso + driver: mover pasos, cambiar velocidad con potenciómetro, usar
driver para protección.
“Semáforo inteligente”
LEDs + PWM para transición suave + buzzer de aviso + botón de peatón.
“Luces ambientales RGB”
LED RGB con PWM → alumnos mezclan colores según sensor de luz/joystick.
“Sirena variable”
Buzzer con tone() variando frecuencia según sensor analógico (micrófono o
LDR).
“Brazo/barra automática”
Servo abre al leer tarjeta RFID → combina clases 3 y 5.
“Mini elevador”
Motor paso a paso sube/baja según pulsadores o joystick.
“Tablero digital”
Mostrar valor de un sensor en display de 7 segmentos multiplexado.
