1

RESISTENCIA
Es un material formado por carbón y otros elementos resistivos para disminuir la corriente que pasa.
Se opone al paso de la corriente. La corriente máxima en un resistor viene condicionado por la
máxima potencia que puede disipar su cuerpo.
Esta potencia se puede identificar visualmente a partir del diámetro sin que sea necesaria otra
indicación. Los valores más comunes son 0,25 W, 0,5 W y 1 W.

POTENCIÓMETRO
Un potenciómetro es un componente electrónico similar a los resistores pero cuyo valor de
resistencia en vez de ser fijo es variable, permitiendo controlar la intensidad de corriente a lo largo
de un circuito conectándolo en paralelo ó la caida de tensión al conectarlo en serie.

PULSADOR
Un pulsador es un operador eléctrico que cuando se oprime permite el paso de la corriente eléctrica
y cuando se deja de oprimir lo interrumpe. Un interruptor es un operador eléctrico cuya función es
abrir o cerrar un circuito de forma permanente.

DIODO
Un diodo es un dispositivo semiconductor que actúa esencialmente como un interruptor
unidireccional para la corriente. Permite que la corriente fluya en una dirección, pero no permite a la
corriente fluir en la dirección opuesta.
 2

LED
Un led es un diodo semiconductor que, cuando recibe tensión, genera luz. Un diodo, a su vez, es una
válvula de dos electrodos que permite el paso de la corriente eléctrica en un único sentido.
Un LED (Diodo emisor de luz, también "diodo luminoso") es un diodo semiconductor que emite luz.
Puede decirse que un led es una fuente lumínica. Cuando se le aplica tensión a alguna de sus dos
terminales, la recombinación de sus electrones provoca la liberación de energía en forma de
fotones.

LED RGB
Un LED RGB es un LED que incorpora en su mismo encapsulado tres LEDs, es RGB porque R (red,
rojo), G (green, verde) y B (blue, azul) así se pueden formar miles de colores ajustando de manera
individual cada color.
Los tres LEDs están unidos por el negativo o cátodo.

FOTORESISTENCIA
Es un componente electrónico cuya resistencia disminuye con el aumento de luz incidente. Un
fotorresistor o fotorresistencia es un componente electrónico cuya resistencia se modifica,
(normalmente disminuye) con el aumento de intensidad de luz incidente.

CONDENSADOR
Básicamente un condensador es un dispositivo capaz de almacenar energía en forma de campo
eléctrico. Está formado por dos armaduras metálicas paralelas (generalmente de aluminio)
separadas por un material dieléctrico. con una cierta separación, en cuyo caso se dice que el
dieléctrico es el aire. El condensador está formado por dos placas metálicas separadas por un
elemento dieléctrico. Cuando el condensador se conecta a esa fuente externa de voltaje, circula la
corriente eléctrica por él y una de las placas se carga positivamente y otra negativamente.
 3

TRANSISTOR NPN
Un transistor NPN es impulsado (o activado) por corriente positiva polarizada en la base para
controlar el flujo de corriente del Colector al Emisor. Los transistores de tipo PNP están impulsados
por una corriente negativa polarizada en la base para controlar el flujo del Emisor al Colector.

Reed switch
Reed switch (interruptor de lengüeta) es un interruptor eléctrico activado por un campo magnético,
por ejemplo con un imán. Cuando los contactos están normalmente abiertos se cierran en la
presencia de un campo magnético; cuando están normalmente cerrados se abren en presencia de
un campo magnético. Un uso muy extendido se puede encontrar en los sensores de las puertas y
ventanas de las alarmas anti-robo, el imán va unido a la puerta y el reed switch al marco.

Zumbador o buzzer
El zumbador, buzzer en inglés, es un transductor electroacústico que produce un sonido o zumbido
continuo o intermitente de un mismo tono. Sirve como mecanismo de señalización o aviso, y son
utilizados en múltiples sistemas como en automóviles o en electrodomésticos. Inicialmente este
dispositivo estaba basado en un sistema electromecánico que era similar a una campana eléctrica
pero sin el badajo metálico, el cual imitaba el sonido de una campana.
Su construcción consta de dos elementos, un electroimán y una lámina metálica de acero. El
zumbador puede ser conectado a circuitos integrados especiales para así lograr distintos tonos.
Cuando se acciona, la corriente pasa por la bobina del electroimán y produce un campo magnético
variable que hace vibrar la lámina de acero sobre la armadura.
4
5
 6

CONDICIONALES

CICLOS
 7

FUNCIONES DIGITALES

FUNCIONES ANALÓGICAS
8
9
 10

Devuelve: ALTO (HIGH) o BAJO (LOW)

9. OPERACIONES DE COMPARACIÓN

Nota: Suele ser habitual al inicio confundir = (asignación) con == (comparación), hay que prestar
atención para no utilizarlas incorrectamente.
11
12
 13

El inicio se ejecuta sólo una vez al principio. En cada pasada se comprueba la condición. Si es cierta,
se ejecutan las instrucciones y la modificación. El bucle termina cuando la condición se vuelve falsa.
14
15
 16

La instrucción break se utiliza para salir de forma inmediata de la estructura en la que se encuentre.
Se utiliza habitualmente en las estructuras repetitivas for, while y do-while. También se utiliza para
salir de la estructura switch...case.
La instrucción continue salta el resto de la iteración actual de un bucle for, whileo do-while, pero no
sale de ellos, sino que vuelve a chequear la expresión condicional y procede a una nueva iteración
 17

La instrucción return termina la función en el punto en el que se encuentra (el resto no se ejecuta) y
devuelve, si se desea, un valor desde dicha función a la función que la ha llamado.
Hay dos formas válidas, sin devolver nada o devolviendo un valor.
return;
return valor;
 18

Las variables locales definidas dentro de una función no conservan sus valores entre llamadas
sucesivas a dicha función.
Si calificamos a dicha variable local como static, adquiere la propiedad de que conserva su valor
entre las sucesivas llamadas a la función.
static tipovarnombrevar=val_ini;

Las variables static sólo se crean y se inicializan la primera vez que se llama a la función en que se
han creado.
 19

Si calificamos a una variable con la palabra clave const, la hacemos de sólo lectura, o sea, no
permitimos que el programa pueda cambiar su valor.
Const tipovarnombrevar=valor;
20
 21

T1 Hola mundo—LED intermitente

Enciende un LED por un segundo y lo apaga por el mismo tiempo

void setup()
{
pinMode(13,OUTPUT);
}
void loop()
{
digitalWrite(13,HIGH);
delay(1000);
digitalWrite(13,LOW);
delay(1000);
}
 22

T2 Encender un LED con un pulsador

 23

//------------------------------------
//Declara puertos de entradas y salidas
//------------------------------------
int pulsador=2; //Pin donde se encuentra el pulsador, entrada
int led=13; //Pin donde se encuentra el LED, salida

//------------------------------------
//Funcion principal
//------------------------------------
void setup() // Se ejecuta cada vez que el Arduino se inicia
{
pinMode(pulsador, INPUT); //Configurar el pulsador como una entrada
pinMode(led,OUTPUT); //Configurar el LED como una salida
}

//------------------------------------
//Funcion ciclicla
//------------------------------------
void loop() // Esta funcion se mantiene ejecutando
{ // cuando este energizado el Arduino

//Condicional para saber estado del pulsador

if (digitalRead(pulsador)==HIGH)
{
//Pulsador oprimido
digitalWrite(led,HIGH); //Enciende el LED
}
else
{
//Pulsador NO oprimido
digitalWrite(led,LOW); //Apaga el LED
}
}
//Fin programa

T3 Lectura serial de una entrada digital

 24

Leer una entrada digital y mostrar por la pantalla del computador (consola serial) el estado
del pulsador cuando es oprimido
int boton=2; //Pin donde se encuentra el pulsador, entrada
void setup() // Se ejecuta cada vez que el Arduino se inicia
{
pinMode(boton,INPUT); //Configurar el boton como una entrada
Serial.begin(9600); //Inicia comunicación serial
}
void loop() // Esta funcion se mantiene ejecutando
{ // cuando este energizado el Arduino
int estado = digitalRead(boton);
if (estado==1)
{
Serial.println("Pulsado"); //Imprime en la consola serial
} // "Pulsado"
else
{
Serial.println("NO Pulsado"); //Imprime en la consola serial
} // "NO Pulsado"
delay(100); //Retardo para la visualización de datos en la consola
}

T4 Lectura serial de una entrada análoga

 25

Leer una entrada análoga y mostrar por la pantalla del computador (consola serial) el valor
luego de girar el potenciómetro

void setup() // Se ejecuta cada vez que el Arduino se inicia

{
Serial.begin(9600); //Inicia comunicación serial
}
void loop() // Esta funcion se mantiene ejecutando
{ // cuando este energizado el Arduino
//Guardar en una variable entera el valor del potenciómetro 0 a 1024
int valor= analogRead(A0);
Serial.println(valor);
//Retardo para la visualización de datos en la consola
delay(100);
}
T5 Escritura serial
 26

Escritura serial

Consiste en escribir por la pantalla del computador (consola serial)

una letra predeterminada, la primera vez que se escriba está
un LED se enciende, si se vuelve a escribir por segunda vez
el LED se apaga.
 27

int led = 13;

char leer;
boolean prendido=false;
void setup()
{
Serial.begin(9600);
pinMode(led, OUTPUT);
}
void loop()
{
leer=Serial.read();
if ( (leer=='a') && (prendido==false) )
{
digitalWrite(led,HIGH);
prendido=true;
}
else if ( (leer=='a') && (prendido==true) )
{
digitalWrite(led,LOW);
prendido=false;
}
}
 28

T6 Encender un LED por PWM

 29

Enciende/Apaga un LED de forma proporcional

Programa que enciende proporcionalmente un LED cuando llega a su máximo punto de brillo
comienza a apagarse proporcionalmente.

int brillo = 0;
int variacion = 5;
int led = 9;
void setup ()
{
pinMode(led, OUTPUT);
}
void loop ()
{
analogWrite(led, brillo);
brillo = brillo + variacion;
if (brillo == 0 || brillo == 255)
variacion = -variacion;
delay (30);
}
 30

T7 Control ON/OFF con potenciómetro

Programa que enciende un LED cuando el valor de la entrada análoga comandada por el
potenciómetro esta en cierto valor, cuando este valor cambia el LED se apaga, es un sistema
con control ON/OFF

void setup() // Se ejecuta cada vez que el Arduino se inicia

{
Serial.begin(9600); //Inicia comunicación serial
pinMode(13,OUTPUT); //Configurar el pin 13 como una salida
}
void loop() // Esta funcion se mantiene ejecutando
{ // cuando este energizado el Arduino
int valor = analogRead(A0);
Serial.println(valor); //Imprime el valor por la consola
if (valor >= 500)
{
digitalWrite(13,HIGH); //Enciende el LED en el pin 13
}
else
{
digitalWrite(13,LOW); //Apaga el LED en el pin 13
}
delay(100); //Retardo de 100ms para ver los datos de la consola
}
 31

T8 Control de un LED con una fotocelda

 32

Control de intensidad de un LED

---------------------------------------------
Programa que enciende un LED de manera proporcional de acuerdo a la cantidad de luz que
incida en una fotocelda.
//------------------------------------
//Funcion principal

void setup() // Se ejecuta cada vez que el Arduino se inicia{

Serial.begin(9600); //Inicia comunicación serial
pinMode(9,OUTPUT); //Configurar el pin 9 como una salida de PWM}

//------------------------------------
//Funcion ciclicla
//------------------------------------
void loop() // Esta funcion se mantiene ejecutando
{ // cuando este energizado el Arduino
//Guardar en una variable el valor de la lectura análoga de la fotocelda
int foto = analogRead(A0);
//Verifica el valor máximo y realizar una conversión int conversion = 780 - foto;
//Condicional para establecer un valor absoluto
if ( conversion < 0)
conversion = conversion * -1; //Multiplicar por -1 porque es negativo

//Imprimir datos del valor de la lectura análoga de la fotocelda Serial.print("Foto : ");

Serial.print(foto);
Serial.println("");
//Imprimir datos del valor de la conversión
Serial.print("Conv : ");
Serial.print(conversion);
Serial.println("");
//Escritura análoga de PWM en el LED de acuerdo a la conversión analogWrite(9, conversion);
delay(100); //Retardo para datos en la consola
}
//Fin programa
 33

T9 Contador de pulsos
 34

Contador de pulsos
---------------------------------------------
Programa que muestra por pantalla (consola serial) el número de veces que el pulsador ha
sido presionado, se realiza un proceso que de acuerdo al número de pulsaciones se
enciende
un LED,
//Declara puertos de entradas y salidas y variables
int conta = 0; //Variable para guardar el conteo de los pulsos
//------------------------------------
//Funcion principal
//------------------------------------
void setup() // Se ejecuta cada vez que el Arduino se inicia
{
Serial.begin(9600); //Inicia comunicación serial
pinMode(2,INPUT);
//Configura el pin 2 como una entrada, pulsador
pinMode(13,OUTPUT); //Configura el pin 13 como una salida, LED
}
//------------------------------------
//Funcion ciclicla
//------------------------------------
void loop() // Esta funcion se mantiene ejecutando
{ // cuando este energizado el Arduino
// Si el pulsador esta oprimido
if ( digitalRead(2) == HIGH )
{
// Si el pulsador no esta oprimido, flanco de bajada
if ( digitalRead(2) == LOW )
{
conta++; //Incrementa el contador
Serial.println(conta); //Imprime el valor por consola
delay (100); // Retardo
}
}
// Si el valor del contador es 5
if (conta==5)
{
digitalWrite(13,HIGH); //Enciende el LED
}
// Si el valor del contador es 8
if (conta==8)
{
digitalWrite(13,LOW); // Apaga el LED
}
}
 35

//Fin programa
T10 Interruptor magnético para una alarma visual
 36

---------------------------------------------
Interruptor magnético - Ladrón en casa
---------------------------------------------
Programa que genera una alarma visual con un LED a partir de un campo magnético
generado a un reed switch.

//--------------------------------------------------
//Declara puertos de entradas y salidas y variables
//--------------------------------------------------

int contacto = 2; //Pin asignado al reed switch

int led= 13;
//Pin asignado al LED

//------------------------------------
//Funcion principal
//------------------------------------
void setup() // Se ejecuta cada vez que el Arduino se inicia
{
pinMode(contacto,INPUT); //El reed switch como una entrada
pinMode(led, OUTPUT); //El LED como una salida
}
//------------------------------------
//Funcion ciclicla
//------------------------------------
void loop() // Esta funcion se mantiene ejecutando
{ // cuando este energizado el Arduino
 37

// Si el iman se acerca al reed switch

if (digitalRead(contacto)==LOW){
//Ciclo for que va de 0 a 50, el contador esta
// en la variable a, se repite mientras a sea
// menor a 50
for(int a=0; a<50; a++){
digitalWrite(led,HIGH); //Prende el LED
delay(50); //Tiempo
digitalWrite(led,LOW); //Apaga el LED
delay(50); //Tiempo
}
// Si el iman esta lejos del reed switch
}else{
digitalWrite(led,LOW); //Mantiene apagado el LED
} //Fin del if
}
//Fin del programa

T11 LED RGB apoyado de tabla de colores

 38

Programa que hace uso de una función llamada color para generar diversas tonalidades en
un LED RGB
//Declara puertos de entradas y salidas y variables
int ledRojo = 9; //Declara Pin LED Rojo
int ledVerde=10; //Declara Pin LED Verde
int ledAzul=11; //Declara Pin LED Azul
//Funcion principal
void setup() // Se ejecuta cada vez que el Arduino se inicia
{
pinMode(ledRojo,OUTPUT); //El LED Rojo como una salida
pinMode(ledVerde,OUTPUT); //El LED Verde como una salida
pinMode(ledAzul,OUTPUT); //El LED Azul como una salida
}
//Funcion ciclicla
void loop() // Esta funcion se mantiene ejecutando
{ // cuando este energizado el Arduino
// Llamado a la función Color que recibe
// 1er posicion: Intensidad Rojo
// 2da posición: Intensidad Verde
// 3ra posición: Intensidad Azul
color(255,0,0);
//Rojo
delay(1000);
color(0,255,0);
//Verde
delay(1000);
 39

color(0,0,255);
//Azul
delay(1000);
color(255,255,255); //Blanco
delay(1000);
color(255,0,255); //Magenta
delay(1000);
color(255,128,0); //Naranja
delay(1000);
}
//Funcion color
void color(int rojo, int verde, int azul){
//Escritura de PWM del color Rojo
analogWrite(ledRojo, 255-rojo);
//Escritura de PWM del color Verde
analogWrite(ledVerde, 255-verde);
//Escritura de PWM del color Azul
analogWrite(ledAzul, 255-azul);
}
T12 Control ON/OFF de un motor
 40

/*
---------------------------------------------
Control ON/OFF de un motor
---------------------------------------------
Programa que hace uso de un motor y un pulsador, mientras se mantenga pulsado, el
motor debe estar encendido (ON) de lo contrario debe estar apagado (OFF)
//--------------------------------------------------
//Declara puertos de entradas y salidas y variables
//--------------------------------------------------
int pulsador =7; //Declara Pin del pusaldor
int motor=3; //Declara Pin del motor
//------------------------------------
//Funcion principal
//------------------------------------
void setup() // Se ejecuta cada vez que el Arduino se inicia
 41

{
pinMode(pulsador,INPUT); //El pulsador como una entrada
pinMode(motor,OUTPUT); //El motor como una salida
}
//------------------------------------
//Funcion ciclicla
//------------------------------------
void loop() // Esta funcion se mantiene ejecutando
{ // cuando este energizado el Arduino
// Si el pulsador se encuentra oprimido
if(digitalRead(pulsador) == HIGH){
digitalWrite(motor,HIGH); //Enciende el motor
}else{ //si el pulsador no esta oprimido
digitalWrite(motor,LOW); //Apaga el motor
}
}
// Fin programa

T13 Control por PWM de un motor

 42

Control por PWM de un motor

---------------------------------------------
Programa que hace uso de un motor y la Consola serial de Arduino, tiene la posiblidad de
configurar al motor 5 velocidades distintas, desde el teclado del PC puedes enviarle la
velocidad deseada. Las 5 velocidades se configuran con 5 PWM distintos.
//--------------------------------------------------
//Declara puertos de entradas y salidas y variables

int motor=3; //Declara Pin del motor

//Funcion principal
//------------------------------------
void setup() // Se ejecuta cada vez que el Arduino se inicia
{
 43

Serial.begin(9600); //Inicia la comunicacion serial Arduino-PC

}

//Funcion ciclicla
//------------------------------------
void loop() // Esta funcion se mantiene ejecutando
{ // cuando este energizado el Arduino
// Si hay algun valor en la Consola Serial
if (Serial.available()){
//Variable donde se guarda el caracter enviado desde teclado
char a = Serial.read();
// Si el caracter ingresado esta entre 0 y 5
if (a>='0' && a<='5'){
//Variable para escalar el valor ingresado a rango de PWM
int velocidad = map(a,'0','5',0,255);
//Escritura de PWM al motor
analogWrite(motor,velocidad);
//Mensaje para el usuario
Serial.print("El motor esta girando a la velocidad ");
Serial.println(a);
}else{ // Si el caracter ingresado NO esta entre 0 y 5
//Mensaje para el usuario
Serial.print("Velocidad invalida");
Serial.println(a);
}
}
}
//Fin programa
T14 Generar tonos con un buzzer
 44

---------------------------------------------
Generar tonos con un buzzer
---------------------------------------------
Programa que hace uso de un buzzer (chicharra) y un potenciómetro, la idea es generar
diversos tonos en el buzzer a partir del estado análogo del potenciómetro. Además se hace
uso de la función tone que es muy útil para generar diversas melodías

int buzzer = 9; //Declara Pin del buzzer

int tono = 0; //Declara Pin del potenciómetro

//------------------------------------
//Funcion principal
 45

//------------------------------------

void setup() // Se ejecuta cada vez que el Arduino se inicia

{
// No se configuran parámetros inciales, pero se debe
// colocar el encabezado de la función setup()
}

//Funcion ciclicla
//------------------------------------
void loop() // Esta funcion se mantiene ejecutando
{ // cuando este energizado el Arduino
//Variable entera donde se almacena el valor del potenciómetro
int sensor = analogRead(tono);
//Variable donde se escala la frecuencia de 100 a 5000Hz
int frecuencia = map(sensor,0,1023,100,5000);
//Variable entera para guardar el tiempo deseado en ms
int duracion = 250;
//Funcion tone(), que recibe:
// 1ra posición: Pin del elemento sonoro
// 2da posición: Frecuencia deseada en Hz
// 3ra posición: Duración del tono
tone(buzzer, frecuencia, duracion);
//Retardo
delay(100);
}
//Fin programa

Auto fantástico:
6 leds que se encienden secuencialmente 1, 2, 3, 4, 5, 6, 5, 4, 3, 2.
Materiales. 7 leds rojos y resistencias de 220 Ω (rojo-rojo-marrón).
 46

Sketch
int i; //esta variable valdrá para numerar los pines y los leds,...
//pues al pin 1 conectaremos el ánodo del led 1 y así.
void setup() {
for(i=1;i<=6;i++){ //vamos a realizar este bucle 6 veces
pinMode(i,OUTPUT); //el pin i es de salida
digitalWrite(i,LOW); //apagamos el led i en caso de estar e
} //al terminar el bucle hemos declarado los pines del 1 al 6 ...
//como de salida y hemos apagado los seis leds
}
void loop() {
for(i=1;i<=6;i++){
digitalWrite(i,HIGH); //encendemos el led i ...
delay(100); //dura
digitalWrite(i,LOW); //y luego lo apagamos
} // al terminar el bucle hemos hecho la secuencia de leds 1, 2, ..., 6
for(i=5;i>=2;i--){
digitalWrite(i,HIGH); //encendemos el led i ...
delay(100); //durante 0,1 s ...
digitalWrite(i,LOW); //y luego lo apagamos
} //al terminar el bucle hemos hecho la secuencia de leds 5, 4, 3, 2.
}
Led a distinta intensidad (resistencia 220)
Se pretende que un led se encienda paulatinamente hasta un máximo y luego reduzca.
 47

const int led = 11; //conectaré el ánodo del led al pin 11, que es PMW~
int i; //usaremos la variable i para contar

void setup() {
pinMode(led, OUTPUT); //el pin al que conecto el ánodo del led es de salida
analogWrite(led, 0); //apagamos el led inicialmente
}

void loop() {
for(i=0;i<=255;i++){
analogWrite(led,i); //escribimos en el led el valor i
delay(10); //sin este retraso no nos daríamos cuenta de que el led ...
//se está encendiendo paulatinamente
} //al término del bucle el led pasa
for(i=254;i>=1;i--){
analogWrite(led,i);
delay(10);
} //al término del bucle el led pasa
//a estar casi totalmente apagado
}

PRÁCTICA 7. Control de la luminosidad de un LED (función analogRead)

 48

Materiales. 1 led rojo, 1 potenciómetro 10 kΩ, 1 resistencia de 220 Ω (rojo-rojo-

marrón).
Explicación. Se pretende controlar la luminosidad de un led mediante un
potenciómetro usando Arduino.

const int led = 11; //el ánodo del led al pin 11

const int pot = A0; //el terminal medio del potenciómetro al pin A0
int brillo; // nos dará el brillo del led (entre 0 y 255)

void setup() {
Serial.begin(9600); //esta sentencia es necesaria para usar la pantalla
pinMode(11, OUTPUT); //el pin al que conecto el ánodo del led es de salida
//no es necesario declarar que
//pues los pines analógicos son de entrada automáticamente
}
void loop() {
brillo=analogRead(pot)/4; //convertimos el valor de lectura
//(entre 0 y 1023) en el valor de escritura analógi
//en el led (entre 0 y 255) y lo guardamos en brillo
analogWrite(led,brillo); //encendemos el led con la luminosidad brillo
Serial.println(brillo); //sacamos por la pantalla el valor de brillo...
delay(100);
}

Práctica 9. Luminosidad de led aleatoria (función RANDOM)

 49

Materiales. 1 led amarillo, 1 led rojo, 2 resistencias de 220 Ω (rojo-rojo-marrón).

Explicación. En esta práctica vamos a hacer que la luminosidad con la que lucen los
dos led sea aleatoria, asemejándose a la luz de una vela. Para ello, usaremos la
función random, cuya sintaxis es:

const int ledAm = 11; //tiene que ser PWM~

const int ledRo = 9; //tiene que ser PWM~

void setup() {
pinMode(ledAm, OUTPUT);
pinMode(ledRo, OUTPUT);
}
void loop() {
analogWrite(ledAm,random(0,255));
analogWrite(ledRo,random(0,255));
delay(200);
}

Práctica 14. Farola (resistencia LDR)

 50

Materiales. 1 resistencia LDR, 1 resistencia de 10 kΩ (marrón-negro-rojo), 3 leds rojos y 3

resistencias de 220 Ω (rojo-rojo-marrón).
Explicación. Pretendemos que cuando haya muy poca luz se enciendan los tres leds, que cuando
haya poca luz se enciendan dos leds, que cuando haya un poco más de luz se encienda solo uno y
cuando haya mucha luz no se encienda ninguno. Para ellos necesitaremos una resistencia LDR, pues
su valor óhmico depende de la luz que incida sobre ella.
Una resistencia LDR tiene menor valor óhmico cuanta más luz le llegue; su valor puede ir de unos 50
Ω (mucha luz) a varios megaohmios (muy poca luz). Una LDR no tiene polaridad. En una primera
parte de la práctica habrá que calibrar esto. Conectaremos un extremo de la LDR a 5V y el otro
extremo, tanto a la entrada analógica A0 como a una resistencia de 10 kΩ que estará conectada a
tierra. La información de la luz nos la dará la lectura de A0: valores cercanos a 1023 significan mucha
luz y valores cercanos a 0 muy poca luz.

const int led1 = 13;

const int led2 = 10;
const int led3 = 7;
int lectura;
void setup() {
pinMode(led1,OUTPUT);
pinMode(led2,OUTPUT);
pinMode(led3,OUTPUT);
}

void loop() {
lectura=analogRead(A0);
if (lectura<50){
digitalWrite(led1,HIGH);
digitalWrite(led2,HIGH);
digitalWrite(led3,HIGH);
}
else if (lectura<200){
digitalWrite(led1,HIGH);
digitalWrite(led2,HIGH);
digitalWrite(led3,LOW);
}
else if (lectura<400){
digitalWrite(led1,HIGH);
digitalWrite(led2,LOW);
digitalWrite(led3,LOW);
}
else {
digitalWrite(led1,LOW);
digitalWrite(led2,LOW);
digitalWrite(led3,LOW);
}
delay(500);
}
Práctica 15. Theremin óptico (función MAP)
 51

Materiales. 1 resistencia LDR, 1 resistencia de 10 kΩ (marrón-negro-rojo), 1 piezo.

Explicación. Pretendemos que la frecuencia del piezo varíe con la luz; de esta manera, al acercar las
manos a la LDR variará la frecuencia del piezo. Cuando no tapemos nada la LDR, el piezo no debe
sonar.
La conexión de la LDR es idéntica a la práctica anterior. La cuestión ahora es que debemos
transformar los valores de lectura del pin analógico A0 (desde 0 hasta 1023) en frecuencia del piezo.
Para eso usaremos la función MAP

const int piezo = 13; //piezo al pin 13

const int lectBaja = 250; //lectura de A0 al tapar mucho la ldr
const int lectAlta = 650; //lectura de A0 al no tapar nada la ldr
const int frecBaja = 50; //menor frecuencia a la que sonará
const int frecAlta = 1000; //mayor frecuencia a la que sonará
int lectura; //lectura de A0 de cada instante
int frecuencia; //frec. a la que sonará el piezo

void setup() {
pinMode(piezo,OUTPUT);
}
void loop() {
lectura=analogRead(A0);
frecuencia = map(lectura,lectBaja,lectAlta,frecBaja,frecAlta);
if (lectura<lectAlta){
tone(piezo,frecuencia,100);
} //gracias a este if el piezo no suena si no se tapa nada la ldr
}

Práctica 16. Medidor de temperatura (dispositivo TMP36)

 52

Materiales. 1 sensor TMP36, 3 leds rojos y 3 resistencias de 220 Ω (rojo-rojo-marrón).

Explicación. Pretendemos que según el calor que desprenda tu mano se enciendan uno, dos o tres leds. Más
leds encendidos significarán más “pasión”. Para ello contamos con el sensor de temperatura TMP36.
Veamos cómo funciona el TMP36. Si lo miramos por su parte plana, el terminal izquierdo se conecta a 5 V, el
terminal derecho se conecta a 0 V y el terminal central a un pin analógico; por ejemplo, al A0. El voltaje del
terminal central estará comprendido entre 0 V y 5 V y será menor cuanta mayor sea la temperatura.
const int led1 = 13;
const int led2 = 10;
const int led3 = 7;
const int temp1 = 35;
const int temp2 = 30;
const int temp3 = 25;
int lectura;
float voltaje;
float temperatura;
void setup() {
Serial.begin(9600);
pinMode(led1,OUTPUT);
pinMode(led2,OUTPUT);
pinMode(led3,OUTPUT);
}
void loop() {
lectura=analogRead(A0);
voltaje=lectura*5.0/1023.0;
temperatura=100*voltaje-50;
Serial.println(voltaje);
if (temperatura>=temp1){
digitalWrite(led1,HIGH);
digitalWrite(led2,HIGH);
digitalWrite(led3,HIGH);
}
else if (lectura>=temp2){
digitalWrite(led1,HIGH);
digitalWrite(led2,HIGH);
digitalWrite(led3,LOW);
}
else if (lectura>=temp3){
digitalWrite(led1,HIGH);
digitalWrite(led2,LOW);
digitalWrite(led3,LOW);
}
else {
digitalWrite(led1,LOW);
digitalWrite(led2,LOW);
digitalWrite(led3,LOW);
}
delay(1000);
}