Departamento de Tecnoloxía

ACTIVIDADES CON ARDUINO

La placa Arduino funciona controlando señales de tensión de 0 y
5 voltios (LOW y HIGH), del rango de los mA. Estas señales las
puede interpretar tanto como entradas (sensores, pulsadores,
etc) o como salidas (leds, motores, relés, etc).

El manejo de estas señales por parte del procesador, según las

instrucciones programadas, es lo que llamamos ejecución del
programa, y que podemos observar a través de los distintos
componentes de salida del circuito.
 ORGANIZACIÓN DEL

CONTENIDO DE UN PROGRAMA

EN ARDUINO
INSTRUCCIONES BÁSICAS

PARA INTRODUCIR EN EL

IDE DE ARDUINO
Introducción de datos:

Cuando se pretenda introducir un elemento en nuestro circuito

que queramos controlar a través del programa (led, motor,
sensor, etc), debemos declararlo, asignándole uno o varios pines
de la placa Arduino. Esto se hace de tres formas:

1. definiéndolo como una constante: #define led 3

2. definiéndolo como constante, pero de manera similar a como
se haría con una variable, aunque su valor no pueda cambiar:
const float pi = 3.14;
float x;
// ....
x = pi * 2;
3. declarándolo como una variable, lo que implica determinar de
qué tipo será: int led=3; en este caso de tipo entero.
TIPOS DE VARIABLES EN ARDUINO
 ESTRUCTURAS DE
PROGRAMACIÓN
COMPARTIDAS CON OTROS
LENGUAJES
COMPARADORES MATEMÁTICOS

➢ x == y (x es igual a y) IMPORTANTE!!
➢ x != y (x es distinto a y)
➢ x < y (x es menor que y)
➢ x > y (x es mayor que y)
➢ x <= y (x es menor o igual que y)
➢ x >= y (x es mayor o igual que y)

El signo “=” queda reservado para asignar un

valor a una variable.
 CONDICIONALES:

1. if (condicion) {……..}.

Por ejemplo: if (x>5) { digitalWrite(pinLed,HIGH); }

2. if – else. Sintaxis de la instrucción:

if (condicion) {.....

instrucciones si se cumple

else {......

instrucciones si no se cumple

}
BUCLE FOR:

Sintaxis:
for (variable índice; condición; incrementador)
{
// comandos
}
Ejemplo:
for (int i = 0; i<=4; i++)
{
digitalWrite(led, HIGH);
delay(1000);
digitalWrite(led, LOW);
delay(1000);
}
BUCLE WHILE:
Sintaxis:
while (condición)
{
// comandos
}
Ejemplo:
int var
while (var<200)
{
digitalWrite(8, HIGH);
delay(500);
digitalWrite(8, LOW);
delay(500);
}
FUNCIONES ESPECÍFICAS DE
ARDUINO
FUNCIÓN pinMode()

Cuando se pretenda introducir un elemento en nuestro circuito

que queramos controlar a través del programa (led, motor,
sensor, etc), debemos definirlo como entrada ( sensor, pulsador,
etc) o como salida (led, motor, zumbador, lcd).

Esto se consigue mediante la instrucción pinMode. Por ejemplo,

● para declarar un led como salida: pinMode(led, OUTPUT);

● o un pulsador como entrada: pinMode(pulsador, INPUT);
FUNCIÓN digitalWrite()
FUNCIÓN digitalRead()
LINK PARA EXPLICACIÓN DE PULL-UP, PULL-DOWN
 // Práctica encender y apagar un LED a través de
botón pulsador
const int LED=13;
const int BOTON=7;
int val;
void setup(){
pinMode(LED,OUTPUT);
pinMode(BOTON,INPUT);
}
void loop(){
val=digitalRead(BOTON);
if (val==HIGH){
digitalWrite(LED,HIGH);
}
else { digitalWrite(LED,LOW);
}
}
FUNCIÓN analogRead()
FUNCIÓN analogWrite()
COMUNICACIÓN PLACA-PUERTO DEL PC

La placa ARDUINO envía datos al PC. Estos datos pueden ser

observados en el monitor serie del IDE. Las siguientes
instrucciones son importantes para esta utilidad:

1. Serial.begin(9600); // abre el puerto serie a 9600 bps

2. Serial.print(val); //escribe el valor del dato en el monitor

serie

3. Serial.println(); // retorno del carro después de la última

etiqueta
ENTRADAS ANALÓGICAS:
SENSORES
QUÉ SON LOS SENSORES:
Un sensor es un dispositivo que capta del mundo real las
variaciones de una magnitud física (luz, tª, sonido, distancia,
luz infrarroja, presión,...) y las convierte en variaciones de una
magnitud eléctrica ( resistencia, tensión o intensidad).
 TIPOS DE SEÑALES

SEÑAL DIGITAL
Las variables digitales sólo tienen dos posibles estados:
● 0, apagado (0V)

● 1, encendido (5V)

SEÑAL ANALÓGICA
En el mundo real, las magnitudes pueden tener múltiples
valores. P.e., las variaciones de tª a lo largo del día, pueden ser
recogidas por un sensor que mida la tª, aportando distintos
valores de tensión que se corresponden con una tª en ºC.
MUESTREO Y RESOLUCIÓN
ARDUINO no lee continuamente la señal analógica (tiempo continuo), sino que
toma una muestra cada 100 𝛍s (tiempo discreto), lo que le permite convertir
una señal analógica continua en una señal discreta (dividida en trocitos).

ARDUINO dispone de 10 bits para expresar el valor digital de los

voltios leídos en la señal analógica proporcionada por el sensor,
por lo que puede expresar 210 =1024 valores distintos.
VRef
Resolución= = 5V/1024 = 0,00488 V ≃ 5mV
210
Dos resultados medidos tienen que diferenciarse al menos en 5
m-v para expresarlos como dos nº digitales diferentes
El proceso anterior lo realizará ARDUINO cada vez que se utilice
la sentencia:

int valor = analogRead(A0)

Para entender lo que hace ARDUINO, leemos la sentencia de

derecha a izquierda:

1. Toma una muestra de voltaje en la entrada analógica A0.

2. Lo convierte en un valor numérico entre 0 y 1023.
3. Lo guarda en la variable valor, que es de tipo integer (int),
para poder usarla más tarde en el programa.
EJEMPLO: SENSORES DE LUZ, LDR
Una LDR es un componente que varía su resistencia en función de
la luz que recibe (100𝛀 con luz intensa, 1M𝛀en oscuridad).

Par utilizar la LDR, se debe construir un divisor de tensión con una

resistencia de 10 k𝛀 , en el que Vout se conectará a una entrada
analógica de ARDUINO.

● Si la R en la LDR es pequeña,
Vout aumenta, por lo que la
entrada será próxima a 5V.
● Si es grande, Vout disminuye y
la entrada será próxima a 0V.
MEDIDA DE DISTANCIAS. SENSOR ULTRASÓNICO.
Los ultrasonidos son unas señales acústicas en un rango de frecuencias por
encima de lo que puede percibir el oído humano. Los sensores de ultrasonidos
permiten medir la distancia a la que se encuentra un objeto sin contacto físico:

1. Emiten un pulso de ultrasonidos.

2. El pulso rebota en el objeto y vuelve al sensor.
3. Se mide el tiempo que ha tardado el pulso en ir y volver.
4. Se calcula la distancia a la que está el objeto:

Velocidad . Tiempo
Distancia =
2

La velocidad del sonido en el aire

a 20ºC es de 343 m/s.
ESQUEMA PARA CIRCUITO DE MEDIDA DE
DISTANCIA CON SENSOR ULTRASÓNICO
PROGRAMA PARA MEDIR DISTANCIAS
/* Muestra la distancia a la que se encuentran los objetos*/
#define pulso 9 //define la salida por donde se manda el pulso como 9
#define rebote 8 //define la salida por donde se recibe el rebote como 10
int distancia; //crea la variable "distancia"
float tiempo; //crea la variable tiempo (como float)

void setup()
{
Serial.begin(9600); //inicializa el puerto serie
pinMode(pulso, OUTPUT); //Declaramos el pin 9 como salida (pulso ultrasonido)
pinMode(rebote, INPUT); //Declaramos el pin 8 como entrada (recepción del pulso)
}

void loop()
{
digitalWrite(pulso,LOW); //Por cuestión de estabilización del sensor
delayMicroseconds(5);
digitalWrite(pulso, HIGH); //envío del pulso ultrasónico
delayMicroseconds(10);
tiempo = pulseIn(rebote, HIGH); //funcion para medir el tiempo y guardarla en la variable "tiempo"
distancia = 0.01715*tiempo; //fórmula para calcular la distancia

/*Monitorización en centímetros por el monitor serial*/

Serial.print("Distancia: ");
Serial.print(distancia);
Serial.println(" cm");
delay(3000);
}
MEDIDA E DISTANCIAS CON SENSOR ULTRASÓNICO
Medir distancias con sensor ultrasónico void loop() {
long duracion, distancia;
#define trigPIN 2 digitalWrite(trigPIN,LOW);
#define echoPIN 3 delayMicroseconds(2);
#define ledPIN 5 digitalWrite(trigPIN,HIGH);
delayMicroseconds(10);
digitalWrite(trigPIN,LOW);
void setup() { duracion=pulseIn(echoPIN,HIGH);
Serial.begin(9600); distancia=duracion/2/29.1;
pinMode(trigPIN,OUTPUT); Serial.println(String(distancia)+"cm");
pinMode(echoPIN,INPUT); int limite=200;
pinMode(ledPIN,INPUT); if (distancia<limite){
digitalWrite(ledPIN,HIGH);
} }
else {
digitalWrite(ledPIN,LOW);
}
}
DETECTOR DE DISTANCIA CON ZUMBADOR
int DISTANCIA = 0;

long LECTURASENSOR(int triggerPin, int echoPin)

{
pinMode(triggerPin, OUTPUT); // Resetea el trigger
digitalWrite(triggerPin, LOW);
delayMicroseconds(2);
// Deja el pin Trigger en HIGH durante 10 microsegundos
digitalWrite(triggerPin, HIGH);
delayMicroseconds(10);
digitalWrite(triggerPin, LOW);
pinMode(echoPin, INPUT);
// Lee el pin Echo y devuelve el tiempo de viaje de la onda sonora, en microsegundos.
return pulseIn(echoPin, HIGH);
}
void setup()
{
pinMode(2, OUTPUT); // PIN destinado al terminal positivo del zumbador
}
void loop()
{
DISTANCIA = 0.01723 * LECTURASENSOR(6, 7);
if (DISTANCIA < 20) {
digitalWrite(2, HIGH);
} else {
digitalWrite(2, LOW);
}
delay(10);
}
CONTROL DE LA VELOCIDAD DE UN MOTOR A
TRAVÉS DE UNA SALIDA PWM
Mediante este circuito se puede controlar la velocidad de un motor DC a
través de transistor y potenciómetro.
MAPEADO

La potencia entregada al motor será un mapeado de la lectura del

potenciómetro (entre 0 y 1023)a un valor comprendido entre 0 y 255, que
es el rango de valores que puede entregar una salida PWM (modulación
de ancho de pulso) de ARDUINO.

int potencia=map(seleccion,25,990,40,255);

Debemos cambiar los valores 0-1023 de la entrada analógica por 25-990

d. Se sustituye 0 por 40 para que el motor se detenga justo en el cero del
potenciómetro.
CONTROL DE VELOCIDAD DE UN MOTOR DC
MEDIANTE POTENCIÓMETRO
#define PIN_POT A0 //Pin al que conectamos el potenciómetro
#define PIN_MOTOR 11 //Pin al que conectamos el motor
void setup()
{
pinMode(PIN_POT, INPUT); //Declaramos el pin del potenciómetro como entrada
pinMode(PIN_MOTOR, OUTPUT); //Declaramos el pin del motor como salida
Serial.begin(9600); //Iniciamos la comunicación a través del puerto serie
}
void loop()
{
int seleccion = analogRead(PIN_POT); //Creamos una variable que recoja el valor del
potenciómetro
Serial.print(seleccion);
Serial.print(" : "); //Muestra la información en el monitor serie
int potencia = map(seleccion,25,990,40,255); //Potencia entregada al motor
Serial.println(potencia);
analogWrite(PIN_MOTOR,potencia); //Entregamos a la salida analógica el valor de la
//variable potencia
delay(1000); // Espera 1000 millisecond(s)
}
MANEJO DE SERVOMOTORES O SERVOS
Los servos están constituidos por:
● Un motor.
● Engranajes reductores de velocidad.
● Un potenciómetro que determina la posición del eje en todo
momento.
● Una pequeña placa electrónica para posicionar el eje según la señal
recibida.
MANEJO DE SERVOMOTORES O SERVOS
Los servos funcionan a base de pulsos de corriente:
● Si el pulso es de 1 ms, va a la posición 0º.
● Si dura 2 ms, se sitúa en la posición 180º.
● Para pulsos entre 0 y 2, se situará en posiciones intermedias entre 0 y
180º.
CIRCUITO PARA UN LIMPIAPARABRISAS
PROGRAMA PARA LIMPIAPARABRISAS
PROGRAMA CONECTADO A MONITOR SERIE
SERVO CONTROLADO POR POTENCIÓMETRO
#include <Servo.h>
#define PINSERVO 9
Servo myservo;

int valor_potenciometro;

void setup() {
//put your setup code here, to run once:
myservo.attach(PINSERVO);
}

void loop() {
// put your main code here, to run repeatedly:
valor_potenciometro=analogRead(A0);
valor_potenciometro=map(valor_potenciometro,0,1023,0,180);

myservo.write(valor_potenciometro);
delay(20);

}
Código ARDUINO para el servo
#include <Servo.h>
#define PINSERVO 9
Servo myservo;
int posicion = 0;

void setup() {
//put your setup code here, to run once:
myservo.attach(PINSERVO);
}

void loop() {
// put your main code here, to run repeatedly:
for(posicion=0;posicion<=180;posicion=posicion+1){
myservo.write(posicion);
delay(20);
}
for(posicion=180; posicion>=0; posicion=posicion-1){
myservo.write(posicion);
delay(20);
}
}
CIRCUITO PARA LCD
PROGRAMA BÁSICO PARA LCD I
#include <LiquidCrystal.h>

LiquidCrystal lcd(2, 4, 13, 12, 7, 6); //(RS, E, D4,D5, D6, D7)

void setup()
{
Serial.begin(9600);
lcd.begin(16, 2); // Inicia un LCD 16x02 (columnas,fila)
lcd.setCursor(0, 0); // Pone el cursor en las coordenadas (0,0)
lcd.print("Iniciar proceso"); // Escribe el LCD
lcd.setCursor(0, 1); // Ponemos el cursor en la segunda Fila
lcd.print("Carga de piezas"); // Escribe el LCD
delay(2000);
}

void loop()
{

lcd.clear();
lcd.setCursor(0, 0);
lcd.print("PIEZA DETECTADA");
delay(2000);
lcd.clear();
lcd.print("CARGANDO PIEZA");
delay(2000);
}
PROGRAMA BÁSICO PARA LCD II
PROGRAMA BÁSICO PARA LCD II
#include <LiquidCrystal.h>
LiquidCrystal lcd(2, 4, 13, 12, 7, 6); //(RS, E, D4,D5, D6, D7)
int PIR=0;
int CONTADOR=0;

void setup()
{
Serial.begin(9600);
lcd.begin(16, 2); // Inicia un LCD 16x02 (columnas,fila)
lcd.setCursor(0, 0); // Pone el cursor en las coordenadas (0,0)
lcd.print("Iniciar proceso"); // Escribe el LCD
lcd.setCursor(0, 1); // Ponemos el cursor en la segunda Fila
lcd.print("Carga de piezas"); // Escribe el LCD
delay(2000);
pinMode(8, INPUT);
}
void loop()
{
PIR=digitalRead(8);
if (PIR==1){
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("PIEZA DETECTADA");
delay(2000);
lcd.clear();
lcd.clear();
CONTADOR++;
lcd.setCursor(0, 0);
lcd.println("N PIEZAS:");
lcd.print(CONTADOR);
delay(2000);
lcd.clear();
}
else{
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("ESPERANDO");
delay(1000);
}
}
USO DE LCD: EJEMPLO DE APLICACIÓN
/* Conexión
PIN2 - LCD4 (RS)
PIN4 - LCD6 (E)
PIN13 - LCD11 (D4)
PIN12 - LCD12 (D5)
PIN7 - LCD13 (D6)
PIN6 - LCD14 (D7)*/
#include <LiquidCrystal.h>
LiquidCrystal lcd(2, 4, 13, 12, 7, 6); //(RS, E, D4,D5, D6, D7)
int FOTOELECTRICO = 0;
int CONTADOR=0;

void setup()
{
pinMode(5, INPUT);
pinMode(10, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
Serial.begin(9600);
pinMode(11, OUTPUT);
lcd.begin(16, 2); // Inicia un LCD 16x02 (columnas,fila)
lcd.setCursor(0, 0); // Pone el cursor en las coordenadas (0,0)
lcd.print("Iniciar proceso"); // Escribe el LCD
lcd.setCursor(0, 1); // Ponemos el cursor en la segunda Fila
lcd.print("Carga de piezas"); // Escribe el LCD
}

void loop()
{
FOTOELECTRICO = digitalRead(5);
digitalWrite(10, HIGH);
digitalWrite(8, HIGH);
digitalWrite(9, LOW);
Serial.println(FOTOELECTRICO);
if (FOTOELECTRICO == 1) {
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("PIEZA DETECTADA");
delay(2000);
digitalWrite(10, LOW);
digitalWrite(11, HIGH);
delay(1000);
digitalWrite(11, LOW);
digitalWrite(10, HIGH);
digitalWrite(8, HIGH);
digitalWrite(9, LOW);
lcd.clear();
CONTADOR++;
lcd.print("NUMERO PIEZAS:");
lcd.print(CONTADOR);
}
}