EJERCICIO 1

La multinacional francesa Flante experta en maquinaria industrial te ha contratado para que

automatices una máquina cortadora de papel. La condición principal es que el operario de la máquina
cuando vaya a realizar el corte siempre mantenga las dos manos ocupadas, esta es una regla de
seguridad industrial para evitar accidentes. El operario debe oprimir los dos pulsadores uno con cada
mano y la cuchilla cortadora debe bajar y hacer el corte. El siguiente montaje simula el control de la
máquina, los dos pulsadores (S1 y S2) y el LED rojo simula la cuchilla cortadora.
TUTORIAL ARDUINO #02 – LECTURA SERIAL DE UNA ENTRADA DIGITAL

¿QUÉ APRENDO? CONOCIMIENTOS PREVIOS

 Manejar una entrada digital  Señal digital
 Ver datos por la pantalla del computador.  Función digitalRead() y Serial.println()
 Consola serial  Opción de Consola serial,
 Leer una entrada digital y escribir por
consola seria

MATERIALES
 Arduino UNO
 Pulsador
 Resistencia de 1k
 Conectores
 Protoboard
 Cable USB

DISEÑO y CÓDIGO
//Declara puertos de entradas y salidas
int boton=2; //Pin donde se
encuentra el pulsador, entrada

//Función principal
void setup() // Se ejecuta cada vez que el Arduino se inicia
{
pinMode(boton, INPUT); //Configurar el botón como una entrada
Serial.begin(9600); //Inicia comunicación serial
}

//Función cíclica
void loop() // Esta función se mantiene ejecutando cuando este energizado el Arduino
{
int estado = digitalRead(boton); //Guardar en una variable entera el valor del botón 0 ó 1
if (estado==1) //Condicional para saber estado del pulsador
{
// Pulsado
Serial.println("Pulsado"); //Imprime en la consola serial "Pulsado"
}
else
{
// No está pulsado
Serial.println("NO Pulsado"); //Imprime en la consola serial "NO Pulsado"
}
delay(100); //Retardo para la visualización de datos en la consola
}
//Fin programa
EJERCICIO 1
Una empresa de gaseosas tiene un sistema con dos sensores, uno de ellos indica si la botella se ha
llenado con el líquido y el otro sensor indica si la botella ya tiene la tapa. Para este caso simularemos los
dos sensores por medio de dos pulsadores (S1 y S2).
La rutina se describe de esta manera: si la botella se llena de manera adecuada (se debe activar S1 y
mostrar por consola “Gaseosa llena” luego de ello si tiene la tapa colocada (se debe activar S2 y
mostrar por consola “Gaseosa tapada”, al finalizar el proceso se debe encender un LED que indica que
el proceso terminó bien y además se debe mostrar un mensaje por la consola ―Gaseosa bien
empacada‖. Recuerda que primero se debe activar S1 y luego S2 para que le proceso sea válido.
TUTORIAL ARDUINO #03 – LECTURA SERIAL DE UNA ENTRADA ANÁLOGA

¿QUÉ APRENDO? CONOCIMIENTOS PREVIOS

 Manejar una entrada análoga  Señal digital
 Ver datos por la pantalla del computador  Función analogRead() y Serial.println()
 Múltiples estados de un potenciómetro  Opción de Consola serial,
 Leer una entrada análoga

MATERIALES
 Arduino UNO
 Potenciómetro
 Conectores
 Protoboard
 Cable USB

DISEÑO

CÓDIGO
//Función principal
void setup() // Se ejecuta cada vez que el Arduino se inicia
{
Serial.begin(9600); //Inicia comunicación serial
}

void loop() // Esta función se mantiene ejecutando cuando este energizado el Arduino
{
int valor= analogRead(A0); //Guardar en una variable entera el valor del potenciómetro 0 a 1024
Serial.println(valor); //Imprime en la consola serial el valor de la variable
delay(100); //Retardo para la visualización de datos en la consola
}
//Fin programa
TUTORIAL ARDUINO #04 – ESCRITURA SERIAL

¿QUÉ APRENDO? CONOCIMIENTOS PREVIOS

 Entrada por consola (teclado)  Señal digital
 Variables booleanas  Función digitalWrite() y Serial.read()
 Estado de un LED  Configuración de una comunicación serial .
 Escritura serial digital  Polaridad de un LED

MATERIALES
 Arduino UNO
 Led
 Cable USB

DISEÑO

CÓDIGO
//Declara puertos de entradas y salidas y variables
int led = 13; //Pin donde se encuentra el LED, salida
char leer; //Variable donde se almacena la letra
boolean prendido=false; //Estado LED la primera vez, apagado

//Función principal
void setup() { // Se ejecuta cada vez que el Arduino se inicia
Serial.begin(9600); //Inicia comunicación serial
pinMode(led, OUTPUT); //Configurar el LED como una salida
}

//Funcion ciclicla
void loop() // Esta función se mantiene ejecutando cuando este energizado el Arduino
{
leer=Serial.read(); //Guardar en una variable el valor de la consola serial
if ( (leer=='a') && (prendido==false) ) // Si es la letra 'a' y además el LED está apagado
{
digitalWrite(led,HIGH); // Enciende el LED
 prendido=true; // Actualiza el estado del LED
}
// Si es la letra 'a' y además el LED está encendido
else if ( (leer=='a') && (prendido==true) )
{
digitalWrite(led,LOW); // Apaga el LED
prendido=false; // Actualiza el estado del LED
}
}
//Fin programa

EJERCICIO 2: AVISOS LUMINOSOS

Avisos luminosos S.A. te ha contratado para que realices un programa que tiene la característica de
recibir datos, porque la idea es que el aviso de luces se ubique en el piso 130 del Edificio Bulli y tu lo
puedas controlar desde el piso 1, así que por cada letra que le escribas por teclado a la Consola serial el
programa debe hacer determinada rutina con tres LEDs, si le escribes:
 Letra A: Prende los tres LED
 Letra B: Prende el LED1 por un segundo y lo apaga, luego prende el LED2 por un segundo y lo
apaga y finalmente prende el LED3 por un segundo y lo apaga, y vuelve a comenzar. Esta rutina
genera una sensación de movimiento
 Letra C: Apaga los tres LED

//Declara puertos de entradas y salidas y variables

int led1 = 2; //Pin donde se encuentra el LED, salida
int led2 = 3;
int led3 = 4;
char leer; //Variable donde se almacena la letra
boolean prendido=false; //Estado LED la primera vez, apagado
//Función principal
void setup() // Se ejecuta cada vez que el Arduino se inicia
{
Serial.begin(9600); //Inicia comunicación serial
pinMode(led1, OUTPUT); //Configurar el LED como una salida
pinMode(led2, OUTPUT);
pinMode(led3, OUTPUT);
}

//Funcion ciclicla
void loop() // Esta función se mantiene ejecutando cuando este energizado el Arduino
{
leer=Serial.read(); //Guardar en una variable el valor de la consola serial
if ( (leer=='a') && (prendido==false) ) // Si es la letra 'a' y además el LED está apagado
{
digitalWrite(led1,HIGH); // Enciende el LED1
digitalWrite(led2,HIGH); // Enciende el LED2
digitalWrite(led3,HIGH); // Enciende el LED3
prendido=true; // Actualiza el estado del LED
}
// Si es la letra 'b' y además el LED está encendido

if ( (leer=='b') && (prendido==true) )

{
digitalWrite(led1,HIGH); // Enciende el LED1
delay (1000);
digitalWrite(led1,LOW); // Apaga el LED
delay (1000);
digitalWrite(led2,HIGH); // Apaga el LED
delay (1000);
digitalWrite(led2,LOW); // Apaga el LED
delay (1000);
digitalWrite(led3,HIGH); // Enciende el LED1
delay (1000);
digitalWrite(led3,LOW); // Apaga el LED
delay (1000);
digitalWrite(led1,HIGH); // Enciende el LED1
digitalWrite(led2,HIGH); // Enciende el LED1
digitalWrite(led3,HIGH); // Enciende el LED1

//prendido=true; // Actualiza el estado del LED

 }
if ( (leer=='c') && (prendido==true) )
{
digitalWrite(led1,LOW); // Enciende el LED1
digitalWrite(led2,LOW); // Enciende el LED2
digitalWrite(led3,LOW); // Enciende el LED3
prendido=false; // Actualiza el estado del LED
}
}
//Fin programa

EJERCICIO 3: SISTEMA DE RIEGO

Tu abuelito tiene un cultivo de grandes y verdes lechugas, este cultivo tiene 3 aspersores de agua y tu
abuelito quiere prender estos aspersores desde su computador solo escribiendo unos valores por
teclado, los aspersores tienen un estado digital (Valor 0 es apagado y valor 1 es prendido). Debes
realizar un programa que lea una cadena de tres valores, para este ejercicio los aspersores los vamos a
simular con tres LED 1, 2 y 3 por ejemplo:
 Si tu abuelito escribe 000 : Todos los aspersores de agua deben estar apagados
 Si tu abuelito escribe 101 : El aspersor 1 y 3 se prenden pero el dos debe estar apagado
 Si tu abuelito escribe 001 : El aspersor 1 y 2 se apagan pero el tres debe estar prendido
TUTORIAL ARDUINO #05– CONTROL ON/OFF CON POTENCIÓMETRO

¿QUÉ APRENDO? CONOCIMIENTOS PREVIOS

 Salida digital  If/else
 Control ON/OFF  Función digitalWrite() y analogRead()
 Comparación Condicional a partir de un  Valor de una entrada a
valor entero de una entrada análogo

MATERIALES
 Arduino UNO
 Led
 PROTOBOARD
 Potenciómetro
 Resistencia de 220 ohm
 Cable USB

DISEÑO

CÓDIGO

//Función principal
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
}

//Función cíclica
void loop() // Esta función se mantiene ejecutando cuando este energizado el Arduino
{
 int valor = analogRead(A0); //Guardar en una variable el valor de la lectura análoga
Serial.println(valor); //Imprime el valor por la consola
if (valor >= 500) //Si el valor es mayor o igual a 500
{
digitalWrite(13,HIGH); //Enciende el LED en el pin 13 Si el valor es menor a 500
}
else
{
digitalWrite(13,LOW); //Apaga el LED en el pin 13
}
delay(100); //Retardo de 100ms para ver los datos de la consola
}
//Fin programa

EJERCICIO 4
Un carro de tunnig tiene luces de neón en la parte de abajo, éste es la sensación de la feria. El piloto
controla las luces (tres LEDs) por medio de un potenciómetro al lado de la palanca de cambios, él tiene
tres opciones de luces de acuerdo al valor de lectura del potenciómetro que va de 0 a 1023:
0 - 350 Intermitencia de los 3 LED a 100ms
351 - 700 Intermitencia de los 3 LED a 500ms
701 - 1023 Intermitencia de los 3 LED a 1000ms
TUTORIAL ARDUINO #07: SENSOR LDR

1. DEFINICIÓN: El sensor LDR es un componente electrónico pasivo cuyo

valor de la resistencia varía en función de la luz que recibe. Cuanta más
luz reciba, el valor de su resistencia será menor.

2. MATERIALES
 Placa breadboard
 5 Diodos LED
 5 resistencias de 220 Ω
 1 LDR (resistencia dependiente de luz)
 1 potenciómetro 50kΩ (uno de 10kΩ también podría ser útil)
 1 resistencia de 1kΩ
 Cables

3. PROCEDIMIENTO
Se conectarán 5 LED que irán encendiéndose dependiendo del dicho valor de resistencia, ligado
inversamente con la cantidad de luz, de forma que conforme vaya disminuyendo la cantidad de luz, se
irán encendiendo los LED de forma progresiva. Un ejemplo típico podría ser la utilización en farolas
urbanas que van encendiéndose conforme va anocheciendo.

4. IMPLEMENTACIÓN DEL CIRCUITO

El circuito distribuido en la breadboard podría tener esta forma:

Primero concretamos los pines que vamos a utilizar para los LED. Por orden, utilizaremos el 12, 11, 10, 9
y 8. Unidos mediante un cable a la breadboard, colocamos las resistencias de 220 Ω puesto que
podríamos quemar los diodos por un exceso de calor.
El potenciómetro, por otro lado, es una
resistencia variable que dispone de tres
patillas: entre las dos de sus extremos existe
siempre un valor fijo de resistencia, y entre
cualquiera de esos extremos y la patilla
central tenemos una parte de ese valor
máximo. Es decir, la resistencia máxima que
ofrece el potenciómetro entre sus dos
extremos no es más que la suma de las
resistencias entre un extremo y la patilla
central, y entre la patilla central y el otro
extremo.
Lo utilizamos para determinar el valor
mínimo de la luz que es capaz de detectar el
sensor LDR, de forma que cuando vayamos
a ponerlo en marcha debemos regularlo para un correcto funcionamiento. Si ponemos el valor de la
referencia muy baja, empezarán a funcionar los LED con menos luz ambiente que si ponemos una
referencia elevada.
De forma práctica, conectaremos la patilla central al pin AREF (ofrece un voltaje de referencia externo
para poder aumentar la precisión de las entradas analógicas) que luego le diremos al programa que lo
vamos a usar como referencia externa (moverlo manualmente según el valor mínimo de luz que
queramos detectar). Mientras que cada patilla la conectaremos al ánodo y al cátodo (la patilla de la
izquierda al cátodo, y la de la derecha al ánodo) de la breadboard para unirlo con el sensor y los LED.
Para el sensor, la señal que recibe es una señal analógica que obtenemos del exterior para transformarla
en digital, por lo que colocaremos el cable de entrada en un pin analógico, A0 en nuestro caso. Al
colocar la resistencia de 1kΩ en la parte de arriba del sensor, estamos creando un divisor de tensiones,
de manera que cuanta más luz haya, más tensión tendremos a la entrada de nuestra entrada analógica.

Quedando finalmente el montaje de la siguiente manera:

Nos queda escribir el código que le pasaremos al arduino (copiar y pegar):

//Aquí almacenamos los datos recogidos del LDR:

int valorLDR = 0;

//Decimos que pines vamos a utilizar para LED

int pinLed1 = 12;
int pinLed2 = 11;
int pinLed3 = 10;
int pinLed4 = 9;
int pinLed5 = 8;
int pinLDR = 0; //Y que pin para la LDR

void setup(){
pinMode(pinLed1, OUTPUT); //Establecemos como salida los pines para LED
pinMode(pinLed2, OUTPUT);
pinMode(pinLed3, OUTPUT);
pinMode(pinLed4, OUTPUT);
pinMode(pinLed5, OUTPUT);

//Le decimos que vamos a usar una referencia externa

analogReference(EXTERNAL);

void loop()
{
//Guardamos el valor leido en una variable
valorLDR = analogRead(pinLDR);

//Y comenzamos las comparaciones:

if(valorLDR >= 1023)
{
digitalWrite(pinLed1, LOW);
digitalWrite(pinLed2, LOW);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if((valorLDR >= 823) & (valorLDR < 1023))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, LOW);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if((valorLDR >= 623) & (valorLDR < 823))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
 digitalWrite(pinLed5, LOW);
}
else if((valorLDR >= 423) & (valorLDR < 623))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if((valorLDR >= 223) & (valorLDR < 423))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, HIGH);
digitalWrite(pinLed5, LOW);
}
else
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, HIGH);
digitalWrite(pinLed5, HIGH);
}

}
EJERCICIO 6: MONTAJES BÁSICOS: FUNCIONES LÓGICAS

ELEVADOR.
Tenemos un elevador neumático que se puede controlar desde 2 habitaciones contiguas del taller. Para
que el elevador funcione debe estar accionado cualquiera de los 2 pulsadores existentes, pero por
seguridad no funcionará si dos operarios la accionan simultáneamente.

1. Identificamos las variables de entrada y función de salida:

a) Entradas:
 A: un pulsador
 B: un pulsador
b) Salida o valor de la función:
 Motor que acciona el compresor del elevador

2. Elaboramos la Tabla De Verdad:

VARIABLES DE ENTRADA FUNCION SALIDA
A B M
0 0 0 Función Lógica = NOT(A) * B + A * NOT(B)
0 1 1
1 0 1
1 1 0

3. Puertas Lógicas:

 2 puertas NOT
 2 puertas AND
 1 puerta OR

4. Circuito Lógico
PROGRAMA:

/*
Implementación de Función lógica
*/

int var1 = 1; //Pin de entrada del pulsador 1

int var2 = 2; //Pin de entrada del pulsador 1
int led = 5; //Pin de salida para el led(rojo)

int A = 0; //Para almacenar el estado de la variable1

int B = 0; //Para almacenar el estado de la variable2
int resultado = 0; //Para almacenar el resultado

void setup() {
pinMode(var1, INPUT); //Init pin de entrada 1 como salida
pinMode(var2, INPUT); //Init pin de entrada 2 como salida
pinMode(led, OUTPUT); //Iniciliza el pin del led como salida
}

void loop(){
A = digitalRead(var1); //Lee el estado 1 y lo almacena
B = digitalRead(var2); //Lee el estado 2 y lo almacena
//Función Lógica ------ R=(â*b)+(a*^b)
resultado = (!A && B) || (A && !B);
digitalWrite(led, resultado); //Escribimos el resultado en el led
}