Universoarduino

UniversoArduino
15 PROYECTOS ARDUINO PARA PRINCIPIANTES
Jose V. Garlito
INDICE
Arduino…Que es?
IDE Arduino.
Nuestro primer programa.
Entradas digitales y analógicas.
Sensor de distancia HC-SR04.
Motores de corriente continua.
Sensor de temperatura LM35.
Display 7 segmentos 1 digito.
Mando infrarrojo ir.
Potenciómetro.
Motor paso a paso.
Sensor de movimiento.
Led RGB.
Joystick.
Control de accesos sensor RFID-RC522.
LCD táctil 2,4”.
Medidor de nivel de baterías.

Sensor de humedad DHT11.
PÁGINA 1
Arduino…Que es?
Arduino…Que es? es una plataforma de hardware libre, basada en una placa con un
microcontrolador y un entorno de desarrollo, diseñada para
facilitar el uso de la electrónica en proyectos multidisciplinares.
es una placa programable con entradas y salidas digitales y analógicas,
cuyo bajo precio la hace perfecta para iniciarse en domótica o realizar
pequeños proyectos domésticos en electrónica y robótica.
En la actualidad hay muchas clases de modelos, lo que puede ser un poco
confuso para los nuevos usuarios. Cuando tengamos que elegir qué
modelo de comprar, una de las cosas que tendremos que tener en cuenta
es la cantidad de entradas y salidas que tiene, especialmente las analógicas dado que
son las que más puedan limitar nuestro proyecto.
Dependiendo del tipo de proyecto que tengamos en mente crear,
necesitaremos un modelo u otro. Lo normal sería empezar por una Uno r3, es el modelo
más estándar y el más habitual a la hora de crear nuestros
proyectos.
A la hora de proyectos más grandes como robots, impresoras 3D, etc… nos
decantaremos por una Mega r3. Su mayor número de salidas
especialmente analógicas la hacen casi la mejor opción.
Una vez que lleguemos a ser usuarios avanzados, lo normal sería usar la
Arduino Mini.Su pequeño tamaño la hacen ideal para finalizar proyectos y

dejarla conectada para siempre. Para programarla se necesita
un adaptador USB FTDI. Hay que soldar las conexiones.
Todos los componentes son fáciles de encontrar a precios bastante
económicos, si buscamos en sitios como Ebay o Aliexpress. Siempre dependiendo del

país donde nos encontremos, los precios y los tiempos de
entrega pueden variar. Yo desde España no he tenido nunca ningún
problema de ningún tipo.
Ahora solo nos queda comprar nuestra placa Arduino que mejor nos valla
nuestro proyecto e instalar el entorno de desarrollo (IDE).
PÁGINA 2
IDE Arduino
Una vez tenemos nuestra placa arduino, lo que tenemos que hacer, es
instalar la IDE arduino, (ENTORNO DE DESARROLLO INTEGRADO), o
lo que es lo mismo…el software donde programaremos nuestra placa
arduino.
Hay varios IDE, pero vamos a ver hoy es el IDE oficial de arduino. En otras entradas
veremos alguno más y así tendremos más opciones de
programación.
Lo que vamos a ver en la entrada de hoy es la instalación de la IDE en
varios sistemas operativos.
INSTALACION DEL ARDUINO IDE
PÁGINA 3
WINDOWS:
Muy sencillo de instalar.
Descargar la última versión de la página oficial de arduino aquí.
Descomprimir el archivo descargado.
Instalar el archivo descomprimido.
Más fácil no puede ser…Todo continuar hasta que se instale.
UBUNTU – LINUX:
Seguramente la manera más fácil de instalar. Solo tenéis que abrir la
consola de comandos y escribir esto:
UBUNTU – LINUX: UBUNTU – LINUX:
Si queréis la última versión Beta o Nightly debéis escribir los siguiente: sudo rm –r
/usr/share/arduino
wget http://http://downloads.arduino.cc/arduino–1.5.4–linux64.tgz
tar zxvf arduino–1.5.4–linux64.tgz
sudo mv ./arduino–1.5.4 /usr/share/arduino
Tenéis que cambiar el nombre de la última versión.
Una vez que tenemos descargado el IDE, ya podemos preparar la
instalación.
conectamos nuestra placa Arduino mediante un cable USB A-B.
PÁGINA 4
Abrimos el IDE arduino.
Seleccionamos el modelo de placa que vamos a usar.
PÁGINA 5
Seleccionamos el puerto.
En Windows COM1, COM2…
En Linux algo así /dev/ttyACM0
Con esto ya lo tenemos todo listo para empezar a trabajar con nuestra
placa arduino.
PÁGINA 6
NUESTRO PRIMER PROGRAMA EN ARDUINO
Es la hora de nuestro primer programa en arduino. Ahora que lo tenemos
todo preparado…A la hora de programar en el IDE arduino la estructura es muy básica.
DECLARACIONES: Aquí se declaran las variables, funciones,
objetos…
FUNCION SETUP: Se ejecuta al encender la placa o al darle al
botón reset. Inicia comunicaciones, variables, etc…
FUNCION LOOP: Se ejecuta constantemente y hace las tareas del
autómata.
Ahora nos toca cargar un ejemplo y ver cómo funciona…
PÁGINA 7
Una vez seleccionamos el ejemplo nos aparcera un código como este…
Este ejemplo lo que hará será encender y apagar un led cada segundo.
Ahora solo nos quedaría compilar para mandar la información del
programa a la placa y ya estaría listo para funcionar…

PÁGINA 8
Si todo ha salido bien, el led de la placa empezara a parpadear y empezara a funcionar

nuestro led…
PÁGINA 9
ENTRADAS DIGITALES Y ANALOGICAS
Una señal digital seria a ser lo mismo que si dijéramos que la luz está
encendida o apagada, que la puerta está abierta o cerrada, sí o no,1 o 0.no hay zona
intermedia, es un todo o nada. Es una señal que sale del punto A al punto B sin ningún
valor intermedio. Solo pueden entender dos niveles
de señal, LOW o cercanos a 0v y HIGH o valores cercanos a 5v. Podemos
manejarlos desde el 0 al 13 de nuestro arduino. Aunque vienen configurados por

defecto como entrada pueden configurarse como salida.
Cuando hablamos de valores analógicos podremos trabajar con medidas
intermedias entre un mínimo y un máximo. Las podemos encontrar en los
pines del A0 al A5. (hablamos de arduino uno). Se caracterizan por leer
valores de tensión de o a 5 voltios. Con una resolución de 1024 (10 bits). Si dividimos
5 entre 1024 veremos que es capaz de detectar variaciones de
señal de entrada de casi 5mv.
PÁGINA 10
Usando como ejemplo un sensor de temperatura LM35, aumentaría el
nivel de tensión proporcional a la temperatura. Y el sensor digital
DS18D20 cambiaría la sucesión de pulsos y el mensaje que contiene la
información de la temperatura.
PÁGINA 11
SENSOR DE DISTANCIA HC-SR04
El sensor de distancia HC-SR04 es uno de los componentes más utilizados
en la comunidad arduino. no solo por su sencillo funcionamiento, también por su bajo

precio, (siempre dependiendo la parte del planeta donde nos
situemos).
Exactamente igual que pasa con los murciélagos, lo que hace el sensor es, mandar la
señal de sonido a una frecuencia tan alta, que la hace imposible para el oído humano.
Calcula el tiempo que tarda desde que emite la
señal, rebota en algún objeto y vuelve al sensor. Calculando así, la
distancia entre el sensor y el objeto detectado. Por esto y por muchas
cosas más, el sensor de distancia HC-SR04, se hace casi imprescindible
como pareja para nuestro arduino.
En el ejemplo de hoy, lo que vamos a hacer con el sensor de distancia HC-
SR04, es un sensor de aparcamiento.
PÁGINA 12
Lo que hacemos es crear una variable menor a la que recibe el sensor, que va a ser de
50cm, cuando la distancia baje de esa medida, saltara el led
como alarma.
El código que usaremos es el siguiente:
#define trigPin 13
#define echoPin 12
#define led 2
void setup()
{ Serial.begin (9600);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
pinMode(led, OUTPUT);
void loop()
{ long duracion, distancia ;
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
duracion = pulseIn(echoPin, HIGH) ;
distancia = duracion / 2 / 29.1 ;
Serial.println(String(distancia) + ” cm.”) ;
int Limite = 50 ;
if ( distancia < Limite)
digitalWrite ( led , HIGH) ;
else
digitalWrite( led , LOW) ;
delay (500) ;
PÁGINA 13
MOTORES CORRIENTE CONTINUA

motores corrientes continua los tenemos muy presente en nuestra vida
cotidiana, DVD, ventilador, coche de juguete, etc…Los motores de
corriente continua, convierten la energía eléctrica en energía mecánica.
Si subimos la tensión de alimentación el motor gira. Si bajamos la tensión de

alimentación el motor girara más despacio y cambiando la polaridad el
motor gira en sentido contrario.
Para el ejemplo de hoy, vamos a utilizar también, un controlador de motor L298N, con
el que controlaremos los giros del motor. En otra entrada
entraremos más a fondo con el controlador.
PÁGINA 14
Lo que vamos a hacer en este ejemplo es bastante sencillo. Se activará el motor en un

sentido durante 4 segundos, se detendrá durante 0,5
segundos, se activará en sentido contrario durante otros 4 segundos y se
detendrá 5 segundos, así sucesivamente.
PÁGINA 15
int IN3 = 5;
int IN4 = 4;
void setup()
pinMode (IN4, OUTPUT); // Input4 conectada al pin 4
pinMode (IN3, OUTPUT); // Input3 conectada al pin 5
void loop()
// Motor gira en un sentido
digitalWrite (IN4, HIGH);
digitalWrite (IN3, LOW);
delay(4000);
// Motor no gira
delay(500);
// Motor gira en sentido inverso
digitalWrite (IN3, HIGH);
delay(4000);
// Motor no gira
delay(5000);
}
PÁGINA 16
SENSOR DE TEMPERATURA LM35
vamos con mediciones y con el sensor de temperatura LM35.El sensor
tiene una salida una salida análoga proporcional a la temperatura que
registra.
El ejemplo de hoy es de los más sencillos que nos podemos encontrar,
luego depende de cada uno el complicarlo más…
Vamos con el esquema.
PÁGINA 17
Este es el código para que funcione:

// www.universoarduino.com
// codigo para leer temperatura utilizando un LM35
// Declaracion de variables
float tempC;
int tempPin = 0; // Definimos la entrada en pin A0
void setup()
// Abre puerto serial y lo configura a 9600 bps
Serial.begin(9600);
void loop()
// Lee el valor desde el sensor
tempC = analogRead(tempPin);
// Convierte el valor a temperatura
tempC = (5.0 * tempC * 100.0)/1024.0;
// Envia el dato al puerto serial
Serial.print(tempC);
Serial.print(” grados Celsius\n”);
// Espera cinco segundo para repetir el loop
delay(5000);
}
Una vez cargado el código pondremos el monitor de serie y empezaremos
a ver la temperatura…
PÁGINA 18
Display 7 segmentos 1 digito
Un display de segmentos es un componente electrónico que se usa para mostrar

números. Está compuesto por siete segmentos que se enciende y
se apagan depende del número a representar.
podemos encontrar dos tipos distintos…
Cátodo común: todos los leds están unidos a una patilla común,
que está conectada al negativo de la placa.
Ánodo común: todos los ánodos están conectados al positivo.
En nuestro ejemplo usaremos un display 7 segmentos 1 digito de cátodo
común.
Conexiones:Segmento A – pin 7
Segmento B – pin 8
Segmento C – pin 9
Segmento D – pin 10
Segmento E – pin 11
Segmento F – pin 12
Segmento G – pin 13
PÁGINA 19
Código:
int pausa=1000; // Variable que define el intervalo
// de tiempo entre cada digito
void setup()
pinMode(7, OUTPUT); // Asignación de las salidas digitales
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
void display (int a, int b, int c, int d, int e, int f, int g)
// Funcion del display
digitalWrite (7,a); //Se reciben 7 variables y se asignan
digitalWrite (8,b); //a cada una de las salidas

digitalWrite (9,c);
digitalWrite (10,d);
digitalWrite (11,e);
digitalWrite (12,f);
digitalWrite (13,g);
void loop() //Funcion principal
// Dependiendo de cada dígito, se envía a la función display
// los estados (0 y 1) a cada uno de los segmentos
display (1,1,1,1,1,1,0); // 0
delay(pausa);
display (0,1,1,0,0,0,0); // 1
delay(pausa);
display (1,1,0,1,1,0,1); // 2
delay(pausa);
display (1,1,1,1,0,0,1); // 3
delay(pausa);
display (0,1,1,0,0,1,1); // 4
delay(pausa);
display (1,0,1,1,0,1,1); // 5
delay(pausa);
display (1,0,1,1,1,1,1); // 6
delay(pausa);
display (1,1,1,0,0,0,0); // 7
delay(pausa);
display (1,1,1,1,1,1,1); // 8
delay(pausa);
display (1,1,1,0,0,1,1); // 9
delay(pausa);
PÁGINA 20
MANDO INFRARROJOS IR
Para este ejemplo vamos a utilizar un mando infrarrojo ir y un receptor ir, en este
caso. el AX1838HS. Pero, podemos utilizar cualquier otro de los que podamos
encontrar en el mercado. El mando podremos utilizar
cualquier mando ir que tengamos por casa.
Un emisor infrarrojo, no es más que un transistor, a partir de un led
infrarrojo, diseñado para emitir una luz que no vemos… (con la cámara del móvil es
fácil que pudiéramos verlo).
El tea del receptor es más complejo. Cada fabricante pone su norma de
emisión ir. Actualmente prácticamente todos los receptores pueden
demodular cualquier emisión ir.
PÁGINA 21
En el ejemplo de hoy vamos a ver algo sencillo. Él encendido y apagado de varios leds
con un mando a distancia ir.
Lo primero que tenemos que hacer, es, descargar la librería NECIRrcv.h.
Para sacar los códigos de los botones del mando que vamos a utilizar y
poder configurarlo utilizaremos el siguiente código:
#include <NECIRrcv.h>
#define IRPIN 11 // Conectar el sensor de IR en el pin 11
NECIRrcv ir(IRPIN) ;
void setup()
Serial.begin(115200) ;
Serial.println(“Programa para configurar el mando”) ;
ir.begin() ;
void loop()
unsigned long ircode ;
while (ir.available()) {
ircode = ir.read() ;
Serial.print(“el codigo es: ” ) ;
Serial.println(ircode,HEX) ;
Una vez configurado ponemos el código:
PÁGINA 22
#include <NECIRrcv.h>
#define IRPIN 8 //Conectamos el sensor de IR en el pin 8
NECIRrcv ir(IRPIN) ;
int ledamarillo = 7;
int ledverde = 6;
int ledazul = 5;
int ledrojo = 4;
void setup()
ir.begin() ;
pinMode(ledverde, OUTPUT);
pinMode(ledamarillo, OUTPUT);
pinMode(ledazul, OUTPUT);
pinMode(ledrojo, OUTPUT);
void loop()
unsigned long ircode ;
while (ir.available()) {
ircode = ir.read() ;
switch (ircode) {
//para encender
case 0xF30CFF00://boton 1
digitalWrite (ledamarillo, HIGH);
break;
case 0xE718FF00: //boton 2
digitalWrite (ledverde, HIGH);

break;
case 0xA15EFF00: //boton 3
digitalWrite (ledazul, HIGH);
break;
case 0xF708FF00: //boton 4
digitalWrite (ledrojo, HIGH);
break;
//para parar
case 0xE31CFF00: //boton 5
digitalWrite (ledamarillo, LOW);
break;
case 0xA55AFF00: //boton 6
digitalWrite (ledverde, LOW);
break;
case 0xBD42FF00: //boton 7
digitalWrite (ledazul, LOW);
break;
case 0xAD52FF00: //boton 8
digitalWrite (ledrojo, LOW);
break; }
}
PÁGINA 23
Solo tendréis que cambiar los códigos de vuestro mando por los que hay
puestos, (que son los míos) y ya esta. Si una vez compilado el programa os da algún
error como este ‘F30CFF00’ was not declared in this scope.
Probar a añadir a l código 0x y con eso debería estar solucionado.
PÁGINA 24
POTENCIÓMETRO
Un potenciómetro es una resistencia variable con la que podemos elegir el valor que
puede tomar. Así, podemos controlar la intensidad de corriente
que pasa por un circuito en paralelo y la diferencia de potencia si esta en serie.
Lo normal es que un potenciómetro tenga tres pins. Los dos de los
extremos están unidos y siempre registran la resistencia máxima Rmax. El

pin del centro, varia su resistencia conforme giramos el potenciómetro,
siendo la suma de la resistencia con los otros pins igual a resistencia
máxima.
En el ejemplo de hoy vamos a ver como encender y apagar varios leds con
un potenciómetro.
PÁGINA 25
Código que utilizaremos en el ejemplo:
int leds;={2,3,4,5,6}; //Está definiendo los 5 pines.
int pot; // variable del potenciómetro
int n=0; // Variable que utilizaremos como contador en el bucle.
void setup(){
for(n=0;n<5;n++)
pinMode(leds[n],OUTPUT);
Serial.begin(9600); //Iniciamos la comunicación con el monitor serial
void loop(){
pot = analogRead(0);// Definimos el valor de la variable pot como una analógica en

el puerto A0
/*Monitorizamos el valor del potenciómetro con el serial.*/
Serial.print(“Valor del potenciometro: “);

Serial.print(pot);
Serial.print(“\n”);
delay(2000);
/*Ahora definimos los límites de acuerdo con los valores que va obteniendo el
potenciómetro*/
if(pot >= 0 && pot <= 150){ //Definimos el rango para el cual se encenderá el LED
for(n=0;n<1;n++) //solo se enciende un LED, de ahí el número 1
digitalWrite(leds[n],HIGH); // Se encienden n LEDs, aquí n = 1
for(n=1;n<5;n++) //Los demás LEDs están apagados
digitalWrite(leds[n],LOW);
//Para los demás bucles se procederá modificando las condiciones de encendido

if(pot >= 150 && pot <= 300){
for(n=0;n<2;n++)
digitalWrite(leds[n],HIGH);
for(n=2;n<5;n++)
if(pot >= 300 && pot <= 450){
for(n=0;n<3;n++)
for(n=3;n<5;n++)
}
if(pot >= 450 && pot <= 600){
for(n=0;n<4;n++)
for(n=4;n<5;n++)
if(pot >= 600){
for(n=0;n<5;n++)
PÁGINA 26
MOTOR PASO A PASO
El motor paso a paso es tan útil que lo encontraras en muchos proyectos
como robots o impresoras 3D. Debido a su precisión ya que puedes
controlar el giro del eje del motor. Su funcionamiento es muy parecido a la de los
servos, pero con la diferencia que no hay limitación en el giro de 180
grados. Si no, que puede dar vueltas enteras como un motor de corriente
continua.
Tiene dos modos de paso, Half-step mode y Full-step mode. Nosotros en
el ejemplo de hoy vamos a usar el Half-step mode, que es el que nos
recomienda el fabricante. El motor tiene cuatro bobinas que son excitadas en una
secuencia para hacer girar el eje del motor. Primero la bobina 1,
luego la 1 y la 2, después la 1, la 2 y la 3, y así, hasta completar la secuencia.
Las conexiones serían las siguientes:
IN1 — Pin 7
IN2 — Pin 6
IN3 — Pin 5
IN4 — Pin 4
+ — GND
– — 5V (se recomienda alimentación externa a la placa)
PÁGINA 27
El código que vamos a utilizar seria el siguiente:
//declaración de las variables para los pines del motor
int motorPin1 = 7; // Azul – 28BYJ48 pin 1 motor
int motorPin2 = 6; // Rosa – 28BYJ48 pin 2 motor
int motorPin3 = 5; // Amarillo – 28BYJ48 pin 3 motor
int motorPin4 = 4; // Naranja – 28BYJ48 pin 4 motor
// Rojo – 28BYJ48 pin 5 (VCC) motor

int motorSpeed = 1200; //variable para fijar la velocidad del motor (el retraso entre
cada secuencia) int count = 0; // cuenta de los pasos dados
int countsperrev = 512; // número de pasos por vuelta completa
int lookup[8] = {B01000, B01100, B00100, B00110, B00010, B00011, B00001,

B01001}; void setup() {
//declare the motor pins as outputs
pinMode(motorPin1, OUTPUT);
Serial.begin(9600);
void loop(){
if(count < countsperrev )
clockwise(); //sentido agujas del reloj
else if (count == countsperrev * 2)
count = 0;
else
anticlockwise(); //sentido antihorario
count++;
//creación funciones giro horario y antihorario
void anticlockwise()
{
for(int i = 0; i < 8; i++)
setOutput(i);
delayMicroseconds(motorSpeed);
void clockwise()
for(int i = 7; i >= 0; i–)
setOutput(i);
delayMicroseconds(motorSpeed);
void setOutput(int out) //función secuencia giro
digitalWrite(motorPin1, bitRead(lookup[out], 0));
}
PÁGINA 28
SENSOR DE MOVIMIENTO ARDUINO
El sensor de movimiento, (detectores PIR), o pasivo infrarrojo cuentan
entre sus características su indiferencia a la luz, reducido tamaño, bajo consumo y su

bajo coste. Solo reacciona ante determinadas fuentes de
energía como el calor humano o animal.
Reciben las variaciones de las fuentes de energía infrarrojas sobre el
ángulo que cubre. No emiten radiaciones, solo reciben, por eso se dice que son pasivos.
Detectando la diferencia entre el calor emitido por un cuerpo y su alrededor es como
captan la presencia.
En el ejemplo de hoy lo que vamos a hacer es encender un led cuando el
sensor de movimiento detecte un cuerpo.
Materiales:
Arduino uno.
Sensor de movimiento HC-SR501.
1 led.
1 resistencia 220 Ω.
PÁGINA 29
El código que vamos a utilizar es el siguiente:
int analogPin = 3; //vamos a leer el pin analogico 3
int ledPin = 8; // salida 8 para encender el led
int val = 0; // en esta variable guardamos las lecturas
void setup()
Serial.begin(9600); //setup serial
pinMode(ledPin, OUTPUT); //setemos el pin del led como salida
void loop()
val = analogRead(analogPin); // lectura analoga
if(val > 100) //revisa la variable para ver si senso movimiento
Serial.println(val); // imprime en el serial
digitalWrite(ledPin,HIGH); //enciende el led
delay(3000); //hace un delay de 3s
else
Serial.println(val); //imprime en el serial
digitalWrite(ledPin,LOW); //apaga el led cuando no hay movimiento

}
PÁGINA 30
LED RGB
En este ejemplo vamos a ver los leds RGB arduino. En otras entradas
hemos utilizado leds de un solo color, pero según para que proyectos, nos pueden hacer
falta leds que emitan varios colores. Hay nos encontramos
los leds RGB, que son leds que emiten luz roja, verde y azul, (tres leds que comparten
el cátodo), y que podemos mezclar y variar modificando la
programación.
PÁGINA 31
Vamos a poner dos ejemplos. El primer0, creara una secuencia de rojo,

verde y azul, se detendrá un segundo y continuara en bucle. Podemos
cambiar los colores cambiando los valores del void loop.
void setup()
for (int i =3 ; i<6 ; i++)
pinMode(i, OUTPUT);
void Color(int R, int G, int B)
analogWrite(3 , R) ; // Rojo
analogWrite(5, G) ; // Verde
analogWrite(6, B) ; // Azul
void loop()
{ Color(255 ,0 ,0) ;
delay(500);
Color(0,255 ,0) ;
delay(500);
Color(0 ,0 ,255) ;
delay(500);
Color(0,0,0);
delay(1000);
}
En el segundo ejemplo haremos una mezcla de colores aleatoria.
int Rojo = 3;
int Verde = 5;
int Azul = 6;
void setup(){
pinMode(Rojo, OUTPUT);
pinMode(Verde, OUTPUT);
pinMode(Azul, OUTPUT);
void EstablecerColor(int R, int G, int B)
analogWrite(Rojo, 255-R);
analogWrite(Verde, 255-G);
analogWrite(Azul, 255-B);
void loop()
Color(random(255), random(255), random(255)) ;
delay(500);
void Color(int R, int G, int B)

{
analogWrite(3 , R) ; // Rojo
analogWrite(5, G) ; // Green – Verde
analogWrite(6, B) ; // Blue – Azul
PÁGINA 32
JOYSTICK
El Joystick arduino es un dispositivo de entrada con el que se indica el
ángulo o posición del dispositivo que queremos controlar.
Pueden ser analógicos, posicionan mediante potenciómetro, o digitales,
encendido o apagado.
En el ejemplo de hoy veremos el uso del joystick arduino para controlar el movimiento
de dos servos (ya vimos su funcionamiento en otro tutorial).
PÁGINA 33
El código que utilizaremos es el siguiente:
//www.universoarduino.com
#include <Servo.h>
Servo panServo;//asignamos un eje a cada servo.
Servo tiltServo;
int servoPanPosition = 90;//posición de referencia.
int servoTiltPosition = 90;
int joystickPanSpeed = 0;
int joystickTiltSpeed = 0;
int joystickPanPin = A0; //marcamos entradas analógicas.
int joystickTiltPin = A1;
int servoPanPin = 9;//declaramos los pines digitales.
int servoTiltPin = 10;
void setup()
pinMode(servoPanPin, OUTPUT);
pinMode(servoTiltPin, OUTPUT);
panServo.attach(servoPanPin);
tiltServo.attach(servoTiltPin);
void loop()
{
joystickPanSpeed = (analogRead(joystickPanPin) – 512) / 50;
// -512 to provide equal +/- numbers
joystickTiltSpeed = (analogRead(joystickTiltPin) – 512) / -50;
servoPanPosition = constrain((servoPanPosition + joystickPanSpeed), 1, 180);

servoTiltPosition = constrain((servoTiltPosition + joystickTiltSpeed), 1, 180);
panServo.write(servoPanPosition);
tiltServo.write(servoTiltPosition);
delay(50);
PÁGINA 34
CONTROL DE ACCESOS CON SENSOR RFID-RC522
vamos a hacer un control de accesos con sensor RFID-RC522.Primero

hablaremos de la tecnología RFID.
La tecnología RFID (Radio Frecuency Identification), es un sistema de
memoria y recuperación de datos de forma automática. Los datos se
almacenan en llaveros, tarjetas, etiquetas, etc…
Las etiquetas RFID llevan dentro una antena de radiofrecuencia que
responden a las peticiones de un receptor RFID.
PÁGINA 35
Las conexiones del sensor a nuestra placa arduino seria de siguiente
manera:
SDA – 10
SCK – 13
MOSI – 11
MISO – 12
NC – N/A
GND – GND
RST – 9
3.3V – 3.3V
El código que utilizaremos para el ejemplo de hoy sería el siguiente:
#include <SPI.h>
#include <MFRC522.h>
#include <Servo.h>
Servo servo;
#define SS_PIN 10
#define RST_PIN 9
// Definimos pin modulo RC522
MFRC522 mfrc522(SS_PIN, RST_PIN);
// definimos leds abierto o denegado
int led_liberado = 5;
int led_negado = 6;
char st[20];
void setup()
pinMode(led_liberado, OUTPUT);
pinMode(led_negado, OUTPUT);
// Define el servo al pin digital 3
servo.attach(3);
// mueve el servo a la posicion inicial
servo.write(90);
// Inicia con serial
Serial.begin(9600);
// Inicia SPI bus
SPI.begin();
// Inicia MFRC522
mfrc522.PCD_Init();
// imprime mensajes en monitor serial
Serial.println(“Aproxime su tarjeta al lector…”);
PÁGINA 36
Serial.println();
void loop()
// espera aproximacion tarjeta
if ( ! mfrc522.PICC_IsNewCardPresent())
return;
// Seleciona ua de las tarjetas
if ( ! mfrc522.PICC_ReadCardSerial())
return;
// Muestra serial UID
Serial.print(“UID de tag :”);
String contenido= “”;
byte letra;
for (byte i = 0; i < mfrc522.uid.size; i++)

{
Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? ” 0″ : ” “);
Serial.print(mfrc522.uid.uidByte[i], HEX);
contenido.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? ” 0″ : ” “));

contenido.concat(String(mfrc522.uid.uidByte[i], HEX));
Serial.println();
Serial.print(“Mensaje : “);
contenido.toUpperCase();
// comprueba tarjeta 1
if (contenido.substring(1) == “1A FA AC D5”)
// eleva la barrera y enciende el led verde
servo.write(-90);
digitalWrite(led_liberado, HIGH);
Serial.println(“tarjeta1 – Acceso liberado !”);
Serial.println();
delay(3000);
servo.write(90);
digitalWrite(led_liberado, LOW);
// comprueba tarjeta 2
if (contenido.substring(1) == “90 DB 34 00”)
Serial.println(“tarjeta2 – Acceso negado !!”);
Serial.println();
// parpadea led rojo
for (int i= 1; i<5 ; i++)
digitalWrite(led_negado, HIGH);
delay(200);
digitalWrite(led_negado, LOW);
delay(200);
delay(1000);
PÁGINA 37
LCD TFT TACTIL DE 2,4″
No hay proyecto serio que se precie, que no lleve una pantalla, y mejor
aún si es un LCD TFT Táctil de 2,4″ Arduino.
En este ejemplo, os voy a enseñar un juguete que me ha llegado hace poco
y por desgracia, no he tenido el tiempo que me gustaría para ponerme a
trastear. Un Shield LCD TFT Táctil de 2,4 Arduino. Al tener formato shield la
conexión es más cómoda directamente del LCD a nuestro arduino uno.
Además de la pantalla táctil otra de sus principales características es que dispone de

ranura para tarjeta micro SD. Aunque de la ranura microSD y
la función táctil hablaremos en otro momento.
Las características del shield LCD TFT Táctil de 2,4 Arduino son las
siguientes:
320 x 240 pixeles de resolución y 262.000 colores.
Pantalla LCD TFT de 2,4″ táctil.
Chip controlador LCD ILI 9341.
Conexión shield para arduino uno.
Tamaño 71 x 52 x 7 mm
PÁGINA 38
Os voy a enseñar dos ejemplos de código. La librería que tendremos que
instalar en este link.
El primero seria para escribir texto en la pantalla
#include <Adafruit_GFX.h> // Libreria de graficos
#include <Adafruit_TFTLCD.h> // Libreria de LCD

// Pines de conexion del LCD
#define LCD_CS A3 // Chip Select – Pin analogico 3
#define LCD_CD A2 // Command/Data – Pin Analogico 2
#define LCD_WR A1 // LCD Write – Pin Analogico 1
#define LCD_RD A0 // LCD Read – Pin Analogico 0
#define LCD_RESET A4 // LCD Reset – Pin Analogico 4
Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET); //

Instancia del LCD
#define BLACK 0x0000 // Definimos los colores para poder referirnos a ellos con su
nombre
#define RED 0xF800
#define GREEN 0x07E0
#define WHITE 0xFFFF
#define BLUE 0x001F
#define CYAN 0x07FF
#define YELLOW 0xFFE0
#define MAGENTA 0xF81F
void setup(void)
tft.begin(0x9341); // Iniciamos el LCD especificando el controlador de nuestro LC.
// Otros controladores: 0x9325, 0x9328,0x7575, 0x9341, 0x8357.
tft.fillScreen(BLACK); // Colocamos el fondo en Negro
}
void loop(void)
tft.setRotation(5); // Establecemos la posición de la pantalla Vertical u Horizontal

tft.setCursor(15, 90); // Situamos el cursor en la posicion del LCD deseada,
// (X, Y) siendo X el ancho (240 px max.) e Y el alto (320 px max.)
tft.setTextSize(2); // tamaño del texto. (Probado tamaños del 1 al 10)
tft.setTextColor(CYAN); // color del texto
tft.println(“www.universoarduino.com”); // Escribimos nuestro texto en el LCD.
PÁGINA 39
El segundo ejemplo está disponible en la librería e inserta texto con
gráficos.
#include <Adafruit_GFX.h> // Core graphics library
#include <Adafruit_TFTLCD.h> // Hardware-specific library
#define LCD_CS A3 // Chip Select goes to Analog 3
#define LCD_CD A2 // Command/Data goes to Analog 2
#define LCD_WR A1 // LCD Write goes to Analog 1
#define LCD_RD A0 // LCD Read goes to Analog 0
#define LCD_RESET A4 // Can alternately just connect to Arduino’s reset pin
// Assign human-readable names to some common 16-bit color values:
#define BLACK 0x0000
#define BLUE 0x001F

#define RED 0xF800
#define CYAN 0x07FF
Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);
void setup(void) {
Serial.begin(9600);
Serial.println(F(“TFT LCD test”));
#ifdef USE_ADAFRUIT_SHIELD_PINOUT
Serial.println(F(“Using Adafruit 2.8\” TFT Arduino Shield Pinout”));
#else
Serial.println(F(“Using Adafruit 2.8\” TFT Breakout Board Pinout”));
#endif
Serial.print(“TFT size is “); Serial.print(tft.width()); Serial.print(“x”);

Serial.println(tft.height()); tft.reset();
uint16_t identifier = tft.readID();
if(identifier == 0x9325) {
Serial.println(F(“Found ILI9325 LCD driver”));
} else if(identifier == 0x9327) {

Serial.println(F(“Found HX8347G LCD driver”));
Serial.println(F(“Found HX8357D LCD driver”));
Serial.println(F(“Found S6D0154 LCD driver”));
} else {
Serial.print(F(“Unknown LCD driver chip: “));
Serial.println(identifier, HEX);
Serial.println(F(“If using the Adafruit 2.8\” TFT Arduino shield, the line:”));
Serial.println(F(” #define USE_ADAFRUIT_SHIELD_PINOUT”));
Serial.println(F(“should appear in the library header (Adafruit_TFT.h).”));

Serial.println(F(“If using the breakout board, it should NOT be #defined!”));
PÁGINA 40
Serial.println(F(“Also if using the breakout, double-check that all wiring”));

Serial.println(F(“matches the tutorial.”));
return;
tft.begin(identifier);
Serial.println(F(“Benchmark Time (microseconds)”));

Serial.print(F(“Screen fill “));
Serial.println(testFillScreen());
delay(500);
Serial.print(F(“Text “));
Serial.println(testText());
delay(3000);
Serial.print(F(“Lines “));
Serial.println(testLines(CYAN));
delay(500);
Serial.print(F(“Horiz/Vert Lines “));
Serial.println(testFastLines(RED, BLUE));
delay(500);
Serial.print(F(“Rectangles (outline) “));
Serial.println(testRects(GREEN));
delay(500);
Serial.print(F(“Rectangles (filled) “));
Serial.println(testFilledRects(YELLOW, MAGENTA));
delay(500);
Serial.print(F(“Circles (filled) “));
Serial.println(testFilledCircles(10, MAGENTA));
Serial.print(F(“Circles (outline) “));
Serial.println(testCircles(10, WHITE));
delay(500);
Serial.print(F(“Triangles (outline) “));
Serial.println(testTriangles());
delay(500);
Serial.print(F(“Triangles (filled) “));
Serial.println(testFilledTriangles());
delay(500);
Serial.print(F(“Rounded rects (outline) “));
Serial.println(testRoundRects());
delay(500);
Serial.print(F(“Rounded rects (filled) “));
Serial.println(testFilledRoundRects());
delay(500);
Serial.println(F(“Done!”));
void loop(void) {
for(uint8_t rotation=0; rotation<4; rotation++) {
tft.setRotation(rotation);
testText();
delay(2000);
PÁGINA 41
}
}
unsigned long testFillScreen() {
unsigned long start = micros();
tft.fillScreen(BLACK);
tft.fillScreen(RED);
tft.fillScreen(GREEN);
tft.fillScreen(BLUE);
return micros() – start;
unsigned long testText() {
unsigned long start = micros();
tft.setCursor(0, 0);
tft.setTextColor(WHITE); tft.setTextSize(1);
tft.println(“Hello World!”);
tft.setTextColor(YELLOW); tft.setTextSize(2);
tft.println(1234.56);
tft.setTextColor(RED); tft.setTextSize(3);
tft.println(0xDEADBEEF, HEX);
tft.println();
tft.setTextColor(GREEN);
tft.setTextSize(5);
tft.println(“Groop”);
tft.setTextSize(2);
tft.println(“I implore thee,”);
tft.setTextSize(1);
tft.println(“my foonting turlingdromes.”);
tft.println(“And hooptiously drangle me”);
tft.println(“with crinkly bindlewurdles,”);
tft.println(“Or I will rend thee”);
tft.println(“in the gobberwarts”);
tft.println(“with my blurglecruncheon,”);
tft.println(“see if I don’t!”);
unsigned long testLines(uint16_t color) {
unsigned long start, t;
int x1, y1, x2, y2,
w = tft.width(),
h = tft.height();
x1 = y1 = 0;
y2 = h – 1;
start = micros();
for(x2=0; x2<w; x2+=6) tft.drawLine(x1, y1, x2, y2, color);
x2 = w – 1;
for(y2=0; y2<h; y2+=6) tft.drawLine(x1, y1, x2, y2, color);
t = micros() – start; // fillScreen doesn’t count against timing
x1 = w – 1;
y1 = 0;
y2 = h – 1;
start = micros();
PÁGINA 42
x2 = 0;
t += micros() – start;
x1 = 0;
y1 = h – 1;
y2 = 0;
start = micros();
x2 = w – 1;
x1 = w – 1;
y1 = h – 1;
y2 = 0;
start = micros();
x2 = 0;
unsigned long testFastLines(uint16_t color1, uint16_t color2) {
unsigned long start;
int x, y, w = tft.width(), h = tft.height();
start = micros();
for(y=0; y<h; y+=5) tft.drawFastHLine(0, y, w, color1);
for(x=0; x<w; x+=5) tft.drawFastVLine(x, 0, h, color2);
unsigned long testRects(uint16_t color) {

int n, i, i2,
cx = tft.width() / 2,
cy = tft.height() / 2;
n = min(tft.width(), tft.height());
start = micros();
for(i=2; i<n; i+=6) {
i2 = i / 2;
tft.drawRect(cx-i2, cy-i2, i, i, color);
unsigned long testFilledRects(uint16_t color1, uint16_t color2) {
unsigned long start, t = 0;
int n, i, i2,
cx = tft.width() / 2 – 1,
cy = tft.height() / 2 – 1;
PÁGINA 43
n = min(tft.width(), tft.height());
for(i=n; i>0; i-=6) {

i2 = i / 2;
start = micros();
tft.fillRect(cx-i2, cy-i2, i, i, color1);
// Outlines are not included in timing results
tft.drawRect(cx-i2, cy-i2, i, i, color2);
return t;
unsigned long testFilledCircles(uint8_t radius, uint16_t color) {
int x, y, w = tft.width(), h = tft.height(), r2 = radius * 2;
start = micros();
for(x=radius; x<w; x+=r2) {
for(y=radius; y<h; y+=r2) {
tft.fillCircle(x, y, radius, color);
unsigned long testCircles(uint8_t radius, uint16_t color) {

int x, y, r2 = radius * 2,
w = tft.width() + radius,
h = tft.height() + radius;
// Screen is not cleared for this one — this is
// intentional and does not affect the reported time.
start = micros();
for(x=0; x<w; x+=r2) {
for(y=0; y<h; y+=r2) {
tft.drawCircle(x, y, radius, color);
unsigned long testTriangles() {
int n, i, cx = tft.width() / 2 – 1,
n = min(cx, cy);
start = micros();
for(i=0; i<n; i+=5) {

tft.drawTriangle(
cx , cy – i, // peak
cx – i, cy + i, // bottom left
cx + i, cy + i, // bottom right
tft.color565(0, 0, i));
PÁGINA 44
unsigned long testFilledTriangles() {
unsigned long start, t = 0;
int i, cx = tft.width() / 2 – 1,
start = micros();
for(i=min(cx,cy); i>10; i-=5) {
start = micros();
tft.fillTriangle(cx, cy – i, cx – i, cy + i, cx + i, cy + i,
tft.color565(0, i, i));
tft.drawTriangle(cx, cy – i, cx – i, cy + i, cx + i, cy + i,
tft.color565(i, i, 0));
}
return t;
unsigned long testRoundRects() {
int w, i, i2,
w = min(tft.width(), tft.height());
start = micros();
for(i=0; i<w; i+=6) {
i2 = i / 2;
tft.drawRoundRect(cx-i2, cy-i2, i, i, i/8, tft.color565(i, 0, 0));
unsigned long testFilledRoundRects() {
int i, i2,
start = micros();
for(i=min(tft.width(), tft.height()); i>20; i-=6) {
i2 = i / 2;
tft.fillRoundRect(cx-i2, cy-i2, i, i, i/8, tft.color565(0, i, 0));
PÁGINA 45
MEDIDOR DE NIVEL DE BATERÍAS
En el ejemplo de hoy, vamos a hacer un Medidor de nivel de baterías
arduino. Es un ejemplo bastante sencillo de hacer con el que crearemos un medidor de

nivel de baterías con arduino para poder ver la carga que les
quedan a nuestras baterías.
En el ejemplo vamos a utilizar:
arduino uno.
3 leds. (para la medición del voltaje)
4 resistencias.
cables.
PÁGINA 46
El código que utilizaremos para la medición será el siguiente:
#define verdeLED 2 // verde LED ‘bien’
#define amarilloLED 4 // verde LED ‘medio’
#define rojoLED 6 // rojo LED ‘baja’
int analogValue = 0;
float voltage = 0;
int ledDelay = 2000;
void setup()
pinMode(verdeLED, OUTPUT);
pinMode(amarilloLED, OUTPUT);
pinMode(rojoLED, OUTPUT);
void loop()
analogValue = analogRead(0);
voltage = 0.0048*analogValue;
if ( voltage >= 1.6 )
digitalWrite(verdeLED, HIGH);
delay(ledDelay);
digitalWrite(verdeLED, LOW);
else if ( voltage < 1.6 && voltage >= 1.4 )
digitalWrite(amarilloLED, HIGH);
delay(ledDelay);
digitalWrite(amarilloLED, LOW);
else if ( voltage <= 1.4 )
digitalWrite(rojoLED, HIGH);
delay(ledDelay);
digitalWrite(rojoLED, LOW);
PÁGINA 47
SENSOR HUMEDAD DHT11 Y TFT 2,4″ TOUCH
En ejemplos anteriores estuvimos viendo el sensor de temperatura
LM35.eN En el ejemplo de hoy vamos a ver el sensor de humedad y temperatura

DHT11.Vamos a usar el Sensor humedad DHT11 y TFT 2,4″
touch, que también vimos en otro ejemplo.
Las características son:
Funciona a 3.3 y a 5v.
Temperatura de 0º a 50º (5% de precisión).
Humedad del 20% al 80% (5% de precisión).
Su bajo precio (sobre los 2€).
Se conecta con tres pines que son Vcc, Gnd y Data. Dependiendo si son
chinos o no la posición de los pines puede cambiar. Hay modelos con
cuatro pines, pero solo se conectan tres.
PÁGINA 48
El código que utilizaremos es el siguiente:
#include <DHT11.h>
#include <Adafruit_GFX.h> // Libreria de graficos

#include <Adafruit_TFTLCD.h> // Libreria de LCD
int pin=10;
DHT11 dht11(pin); // define pin 10 sensor humedad
#define LCD_CS A3 // Chip Select – Pin analogico 3
#define LCD_CD A2 // Command/Data – Pin Analogico 2
#define LCD_WR A1 // LCD Write – Pin Analogico 1
#define LCD_RD A0 // LCD Read – Pin Analogico 0
#define LCD_RESET A4 // LCD Reset – Pin Analogico 4
Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);

// Instancia del LCD
#define BLACK 0x0000 // Definimos los colores para poder referirnos a ellos con
su nombre
#define RED 0xF800
#define BLUE 0x001F
#define CYAN 0x07FF
void setup()
tft.begin(0x9341); // Iniciamos el LCD especificando el controlador de nuestro LC.
// Otros controladores: 0x9325, 0x9328,0x7575, 0x9341, 0x8357.

tft.fillScreen(BLACK); // Colocamos el fondo en Negro
Serial.begin(9600);
void loop()
int err;
float temp, hum;
if((err = dht11.read(hum, temp)) == 0) // Si devuelve 0 es que ha leido bien
tft.print(“Temperatura: “);
tft.print(temp);
tft.print(” Humedad: “);
tft.print(hum);
tft.println();
tft.print(“universoarduino.com”);
else
tft.println();
tft.print(“Error Num :”);
tft.print(err);
tft.println();
}
delay(1000); //Recordad que solo lee una vez por segundo
tft.setRotation(10); // Establecemos la posición de la pantalla Vertical u Horizontal

tft.setCursor(15, 90); // Situamos el cursor en la posicion del LCD deseada,
// (X, Y) siendo X el ancho (240 px max.) e Y el alto (320 px max.)
tft.setTextSize(2); // tamaño del texto. (Probado tamaños del 1 al 10)

tft.setTextColor(CYAN); // color del texto
PÁGINA 49
www.universoarduino.com
PÁGINA 50

Universoarduino - .15 Proyectos D - Jose Vicente Garlito Aviles

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Universoarduino - .15 Proyectos D - Jose Vicente Garlito Aviles

Cargado por

Copyright:

Formatos disponibles

15 PROYECTOS ARDUINO PARA PRINCIPIANTES

Nuestro primer programa.

Entradas digitales y analógicas.

Sensor de distancia HC-SR04.

Motores de corriente continua.

Sensor de temperatura LM35.

Display 7 segmentos 1 digito.

Mando infrarrojo ir.

Motor paso a paso.

Control de accesos sensor RFID-RC522.

LCD táctil 2,4”.

Medidor de nivel de baterías.

facilitar el uso de la electrónica en proyectos multidisciplinares.

es una placa programable con entradas y salidas digitales y analógicas,

cuyo bajo precio la hace perfecta para iniciarse en domótica o realizar

pequeños proyectos domésticos en electrónica y robótica.

En la actualidad hay muchas clases de modelos, lo que puede ser un poco

Dependiendo del tipo de proyecto que tengamos en mente crear,

decantaremos por una Mega r3. Su mayor número de salidas

especialmente analógicas la hacen casi la mejor opción.

Arduino Mini.Su pequeño tamaño la hacen ideal para finalizar proyectos y

un adaptador USB FTDI. Hay que soldar las conexiones.

Todos los componentes son fáciles de encontrar a precios bastante

económicos, si buscamos en sitios como Ebay o Aliexpress. Siempre dependiendo del

entrega pueden variar. Yo desde España no he tenido nunca ningún

problema de ningún tipo.

nuestro proyecto e instalar el entorno de desarrollo (IDE).

instalar la IDE arduino, (ENTORNO DE DESARROLLO INTEGRADO), o

lo que es lo mismo…el software donde programaremos nuestra placa

Lo que vamos a ver en la entrada de hoy es la instalación de la IDE en

varios sistemas operativos.

INSTALACION DEL ARDUINO IDE

Muy sencillo de instalar.

Descargar la última versión de la página oficial de arduino aquí.

Descomprimir el archivo descargado.

Instalar el archivo descomprimido.

Más fácil no puede ser…Todo continuar hasta que se instale.

Seguramente la manera más fácil de instalar. Solo tenéis que abrir la

consola de comandos y escribir esto:

UBUNTU – LINUX: UBUNTU – LINUX:

tar zxvf arduino–1.5.4–linux64.tgz

sudo mv ./arduino–1.5.4 /usr/share/arduino

Tenéis que cambiar el nombre de la última versión.

Una vez que tenemos descargado el IDE, ya podemos preparar la

conectamos nuestra placa Arduino mediante un cable USB A-B.

Seleccionamos el modelo de placa que vamos a usar.

En Windows COM1, COM2…

En Linux algo así /dev/ttyACM0

Es la hora de nuestro primer programa en arduino. Ahora que lo tenemos

todo preparado…A la hora de programar en el IDE arduino la estructura es muy básica.

DECLARACIONES: Aquí se declaran las variables, funciones,

botón reset. Inicia comunicaciones, variables, etc…

FUNCION LOOP: Se ejecuta constantemente y hace las tareas del

Ahora nos toca cargar un ejemplo y ver cómo funciona…

Una vez seleccionamos el ejemplo nos aparcera un código como este…

Ahora solo nos quedaría compilar para mandar la información del

programa a la placa y ya estaría listo para funcionar…

Si todo ha salido bien, el led de la placa empezara a parpadear y empezara a funcionar

de señal, LOW o cercanos a 0v y HIGH o valores cercanos a 5v. Podemos

manejarlos desde el 0 al 13 de nuestro arduino. Aunque vienen configurados por

Cuando hablamos de valores analógicos podremos trabajar con medidas