Este documento proporciona una descripción detallada de los componentes incluidos en un kit de prácticas con Arduino Uno R3. El kit incluye una tarjeta Arduino Uno R3, una protoboard, cables, sensores como LDR, pulsadores y LCD, módulos como RFID, ultrasonidos e infrarrojos, y actuadores como motores DC, servomotores y módulos de movimiento. El documento describe las especificaciones y funcionalidad de cada componente para permitir el desarrollo de proyectos prácticos con Arduino.

1. ARDUINO
2.016 Kit de prácticas con Arduino Uno R3

2. Arduino
Página 1
Arduino Uno R3 + cable USB
La tarjeta Arduino Uno R3 es un módulo diseñado para el desarrollo práctico y eficaz de circuitos
electrónicos, con un gran número de entradas y salidas analógicas y digitales, no necesita drivers.
Compatible con sistemas operativos Linux, Windows y Mac. Compatible con diferentes módulos
permitiendo de forma fácil adaptar comunicación inalámbrica y Ethernet entre otras.
Esta tarjeta tiene un microcontrolador ATMEGA328, con 14 pines de entradas/salidas digitales (de
los cuales 6 pines pueden ser usados para señales de salidas PWM), 6 entradas analógicas con
una frecuencia de reloj de 16MHz.
Se conecta mediante cable USB, posee una fuente de alimentación, cabecera ICSP y un botón de
RESET.Esta tarjeta difiere de sus antecesores en que no necesita drivers de USB a FTDI, en su
lugar cuenta con el ATMEGA 16U2, programado como conversor USB a serial.
Tensión de funcionamiento 5V
Tensión entrada recomendada 7 -12V
Tensión de entrada límite 6 a 20V
Pines digitales I/O 14 (6 PWM)
Pines analógicos de entrada 6
Corriente de salida 40mA
Corriente por el pin 3,3V 50mA
Memoria Flash 32 KB
SRAM 2KB
EEPROM 1KB
Frecuencia de reloj 16MHz Cable USB A-B

3. Arduino
Página 2
Conexiones Arduino Uno R3

4. Arduino
Página 3
Protoboard 830 pines
Modelo MB102 de 830 puntos
Fabricado en plástico ABS
Color Blanco
Resistencia de contacto 100mA
Resistencia aislante 100mA
Voltage dieléctrico 500VAC (1 minuto)
Conexiones 5000 veces
Temperatura de operación -20ºC +80ºC
Contactos Chapados de níquel/bronce fosforado
Calibre de alambre 20-29 AWG
Arquitectura No requiere soldar
Autoadhesiva
Modificación y revisión de circuitos
126 terminales separados de 5 puntos más 4 líneas horizontales
de 50 puntos
Juego de cables
Conector Dupont macho-macho
Espaciado 0,1mm
Unidades 49 piezas de 110mm
8 piezas de 160mm
4 piezas de 200mm
4 piezas de 240mm

5. Arduino
Página 4
Piezo Conector 9V LDR Resistencias
Led RGB Pulsador
Leds Interruptor
x10 x10 x10 x10 x10
Display
25x1K
x3
x3

6. Arduino
Página 5
LCD 2x16
Pin Nombre Función
1 Vss GND
2 Vcc +5V
3 Vo Contraste
4 RS Selección de registro
5 R/W Lectrua/escritura
6 E Enable
7 D0 Data LSB
8 D1 Data
9 D2 Data
10 D3 Data
11 D4 Data
12 D5 Data
13 D6 Data
14 D7 Data MSB
15 A Anodo retroiluminación
16 K Cátodo retroiluminación
Transmisor/receptor 433MHz
Transmisor MX-FS-03V
Alcance 20-200m (según voltage)
. Alimentación 3,5-12V
Dimensiones 19x19mm
Tasa de transmisión 4KB/s
Potencia 10mW
Frecuencia de transmisión 433MHz
Receptor MX-05V
Alimentación 5V
Consumo 4mAV
Dimensiones 30x14x7mm
Frecuencia de recepción 433MHz

7. Arduino
Página 6
Motor DC
Un motor de corriente continua convierte la energía eléctrica en mecánica. Se compone de dos
partes: el estator y el rotor. El estator es la parte mecánica del motor donde están los polos del
imán. El rotor es la parte móvil del motor con devanado y un núcleo, al que llega la corriente a
través de las escobillas. Cuando la corriente eléctrica circula por el devanado del rotor, se crea un
campo electromagnético. Este interactúa con el campo magnético del imán del estator. Esto
deriva en un rechazo entre los polos del imán del estator y del rotor creando un par de fuerza
donde el rotor gira en un sentido de forma permanente. Si queremos cambiar el sentido de giro
del rotor, tenemos que cambiar el sentido de la corriente que le proporcionamos al rotor; basta
con invertir la polaridad de la pila o batería.
Tensión de funcionamiento 0-6V
Joystick

8. Arduino
Página 7
Módulo ultrasonidos
Los ultrasonidos son señales acústicas cuyas frecuencias están por encima del rango de
frecuencias sensibles al oído humano. Los sensores de ultrasonidos son capaces de medir la
distancia a la que están respecto a un objeto por medio de un sistema de edición de ecos.
Estos sensores están formados por un transductor que emite un pulso corto de energía
ultrasónica. Cuando el pulso es reflejado por un objeto, el sensor captura el eco producido, por
medio de un receptor y mediante un sistema de tratamiento de la señal, calcula la distancia a la
que está dicho objeto.
Debido a sus características, se pueden encontrar sensores de ultrasonidos en aplicaciones como
edición de nivel en tanques que contienen diferentes productos en forma líquida, control de
posición en campos de robótica, industria del plástico, control de llenado de tanques, etc.
Las principales ventajas de éstos sensores se basan en que no necesitan contacto físico para
poder detectar objetos, tienen una buena relación calidad-precio y en comparación con otras
tecnologías los dispositivos basados en ultrasonidos son compactos.
El HC-SR04 está formado por un emisor y un receptor de ultrasonidos que opera a frecuencia de
40KHz. El sensor se alimenta a 5V, por lo que se puede alimentar directamente desde Arduino y
se puede llegar a detectar objetos hasta 5 metros con una resolución de 1cm.

9. Arduino
Página 8
Servomotor
El servo SG90 Tower Pro un servo miniatura de gran calidad y diminutas dimensiones. Funciona
con la mayoría de tarjetas electrónicas de control con microcontroladores y además con la
mayoría de los sistemas de radio control comerciales. Funciona especialmente bien en aeronaves
de aeromodelismo dadas sus características de torque, tamaño y peso.El servo SG90 tiene un
conector universal tipo “S” que encaja perfectamente en la mayoría de los receptores de radio
control incluyendo los Futaba, JR, GWS, Cirrus, Hitec y otros. Los cables en el conector están
distribuidos de la siguiente forma: Rojo =Alimentación (+), Cafe = Alimentación (–) o tierra,
Naranja= Señal PWM.
Este tipo de servo es ideal para las primeras experiencias de aprendizaje y prácticas con servos,
ya que sus requerimientos de energía son bastante bajos y se permite alimentarlo con la misma
fuente de alimentación que el circuito de control. Por ejemplo, si se conecta a una tarjeta arduino,
se puede alimentar durante las pruebas desde el puerto USB del PC sin mayor problema.
Micro Servo Tower-pro
Velocidad: 0.10 sec/60° @ 4.8V
Torque: 1.8 Kg-cm @ 4.8V
Voltaje de funcionamiento: 3.0-7.2V
Temperatura de funcionamiento: -30 ℃ ~ 60 ℃
Ángulo de rotación: 180°
Ancho de pulso: 500-2400 µs
Longitud de cable de conector: 24.5cm

10. Arduino
Página 9
Módulo RFID
El módulo utiliza 3.3V como voltaje de alimentación y se controla a través del protocolo SPI, por lo
que es compatible con casi cualquier microcontrolador, Arduino o tarjeta de desarrollo.
El RC522 utiliza un sistema avanzado de modulación y demodulación para todo tipo de
dispositivos pasivos de 13.56Mhz.
El circuito MF RC522 es utilizado para comunicación inalámbrica a 13.56Mhz para escribir o leer
datos de aplicaciones de bajo consumo de energía, bajo costo y tamaño reducido. Ideal para
dispositivos portátiles o tarjetas.
Modelo: MF522-ED
Corriente de operación: 13-26mA a 3.3V
Corriente de standby: 10-13mA a 3.3V
Corriente de sleep-mode: <80µA
Corriente máxima: 30mA
Frecuencia de operación: 13.56Mhz
Distancia de lectura: 0 a 60mm
Protocolo de comunicación: SPI
Velocidad de datos máxima: 10Mbit/s
Dimensiones: 40 x 60 mm
Temperatura de operación: -20 a 80ºC
Humedad de operación: 5%-95%
Máxima velocidad de SPI: 10Mbit/s
Módulo de infrarrojos
Este módulo sensor de infrarrojos emisor y receptor, se puede
adaptar a la luz ambiente y distancia de detección a través de
un potenciómetro que viene incluido en la placa. Dicha
distancia está comprendida entre 2 y 30 cm, con un ángulo de
detección de 35º. Estos infrarrojos emiten señales a cierta
frecuencia cuando se encuentran algún obstáculo.
La señal captada por éstos sensores es condicionada mediante
un circuito comparador, esto se ve reflejado en un led de color
verde, dependiendo de la configuración del usuario podrá
establecer niveles altos o bajos de tensión.
Tensión de funcionamiento 3,3V-5V
Angulo de detección 35º
Terminales de conexión OUT: salida
GND: tierra
Vcc: alimentación

11. Arduino
Página 10
Sensor humedad temperatura DHT11
Este sensor se caracteriza por tener la señal digital calibrada por lo
queasegura una alta calidad y una fiabilidad a lo largo del tiempo,
ya que contiene un microcontrolador de 8 bits integrado. Está
constituido por dos sensores resistivos (NTC y humedad). Tiene
una excelente calidad y una respuesta rápida en las medidas.
Puede medir la humedad entre el rango 20% – aprox. 95% y la
temperatura entre el rango 0ºC – 50ºC.
Cada sensor DHT11 está estrictamente calibrado en laboratorio,
presentando una extrema precisión en la calibración. Los
coeficientes de calibración se almacenan como programas en la memoria OTP, que son empleados
por el proceso de detección de señal interna del sensor.
El protocolo de comunicación es a través de un único hilo (protocolo 1-wire), por lo tanto hace
que la integración de este sensor en nuestros proyectos sea rápida y sencilla. Además presenta un
tamaño reducido, un bajo consumo y la capacidad de transmitir la señal hasta 20 metros de
distancia.
Módulo detector de movimientos
Este sensor detecta el movimiento de personas (animales) que se
encuentran hasta 7 metros de distancia, mediante el uso de una
lente de Fresnel y el elemento sensible al infrarrojo para detectar
cambios en los patrones infrarrojos emitidos por los objetos en su
cercanía. Es económico y fácil de usar, ideal para sistemas de
alarma, iluminación, proyectos educativos, etc.
El sensor es compatible con todos los microcontroladores. Este
sensor es sensible a la temperatura. Se compone de óxido de
cerámicapiezoeléctrico o elementos de cristal.Su distancia de
detección es de menos de 2m, con la lente óptica la detección
puede ser mayor de 7m.
Sensor Infrarrojos
Voltage de entrada 4,5V-20V
Consumo 65 uA
Voltaje de salida 3,3V
Tiempo de retardo Ajustable de 1 a 18 seg.
Tiempo de bloqueo 2,5 seg.
Modo de disparo L: no puede repetirseH: puede ser repetidoValor por defecto L
Rango de detección <120º de cono
Distancia de detección 2m – 7m
Temperatura -15ºC +70ºC

12. Arduino
Página 11
Mando/receptor infrarrojos
El nuevo control universal ultra delgado de 38KHz por
sensor de infrarrojos con formato de codificación de 21
botones. Tiene un módulo receptor inalámbrico.
Sensor de alta sensibilidad HX1839
Batería CR2025
Voltage de operación (mando) 3,3V
Corriente (mando) 160mAh
Angulo efectivo (nmando) 60º
Voltage de operación (HX1839) 2,7V-5,5V
Corriente (HX1839) 1,4mAh
Angulo (HX1839) 45º
Longitud de onda 940 nanometros
Frecuencia portadora 38KHz
Alcance 15metros
Tamaño 8,6cmx4cm
Peso 22Gr.
Módulo sensor de voz
Este módulo puede detectar intensidad de sonido que se
en el medio ambiente, cuenta con un potenciómetro el
cual permite ajustar su sensibilidad así de ésta manera
sólo se detectaría en ciertos niveles de frecuencia.
Este módulo proporciona una señal de salida en forma
digital por un único canal, es decir, manejando niveles
bajos y altos. La señal recibida es tratada mediante
software por Arduino. Cuando no hay presencia de
sonido, la señal de salida y el indicador envía un nivel
bajo de tensión.Este dispositivo puede ser usado para
control de luces mediante acústica o para alarmas a
través del micrófono incorporado.
Circuito integrado LM393 Pines 1:Vcc - 2:GND - 3:OUT Voltage 4 – 6V
Módulo relé

13. Arduino
Página 12
Módulo sensor de lluvia
Sensor usado en Arduino, kits de robots, control de
nivel de lluvia, etc.
Las señales capturadas pueden ser traducidas a
través del terminal A0 o D0 del sensor. Este
dispositivo cuenta con tecnología TTL, lo que significa
que proporciona una señal digital entre 0 y 1 por el
pin D0. A través del terminal A0 del sensor, que es
una salida analógica, se puede hacer la recepción de
señales que irán directo al microcontrolador, para así
detectar la cantidad de precipitaciones que hay. La
superficie de la placa sensórica se encuentra hecha
de níquel plateado con propiedades antioxidantes,
asegurando una buena conductividad y excelente
rendimiento.
Este módulo posee un comparador LM393, el cual se
encarga de asegurar que la señal de salida se
encuentre limpia, para obtener una mayor calidad en el sensado de datos. Para calibrar su
sensibilidad sólo basta con adecuar el potenciómetro acorde a las medidas a tomar.
Cuando se polariza el dispositivo, el módulo tiene un LED indicador, el cual, al sensar la presencia
de lluvia se obtiene la salida un nivel de tensión y viceversa, aunque estos niveles vienen a estar
calibrados gracias al potenciómetro, esto, acorde a la misma necesidad del usuario.
Voltage de operación 3,3-5V
Corriente de operación 15mA
Salida analógica A0
Salida digital D0

14. Arduino
Página 13
ARDUINO
2.016 Kit de prácticas con Arduino Uno R3
Kit de prácticas con Arduino Uno R3
Prácticas con Arduino

15. Arduino
Página 14
1.Led intermitente
Aprenderemos a activar una salida digital, encender un LED, temporizar una señal de salida.
Esquema y plano
Código del programa
//Enciende un LED por un segundo y lo apaga por el mismo tiempo
//Función principal
Voidsetup() // Se ejecuta cada vez que el Arduino se inicia
{
pinMode(13,OUTPUT); // Inicializa el pin 13 como una salida
}
//Función cíclica
Voidloop() // Esta función se mantiene ejecutando
{ // cuando esté encendido el Arduino
digitalWrite(13,HIGH); // Enciende el LED
delay(1000); // Temporiza un segundo (1s = 1000ms)
digitalWrite(13,LOW); // Apaga el LED
delay(1000);
} // Fin del programa

16. Arduino
Página 15
2.Control de un led con pulsador
Aprenderemos a cablear un circuito, leer el estado de un pulsador, leer una entrada digital,
escribir una salida digital, el condicional if/else.
Esquema y plano
Código del programa
//Encender LED con un pulsador y mientras éste se mantenga accionado el LED se apaga
//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
//Función principal
voidsetup() // 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
}
//Función cíclica
voidloop() // Esta función se mantiene ejecutando
{ // cuando esté alimentado el Arduino
//Condicional para saber estado del pulsador
if (digitalRead(pulsador)==HIGH)
{ //Pulsador oprimido
digitalWrite(led,HIGH); //Apaga el LED
}
else
{ //Pulsador NO oprimido
digitalWrite(led,LOW); //Enciende el LED
}
} //Fin programa

17. Arduino
Página 16
3.Lectura serie de una entrada digital
Aprenderemos a manejar una entrada digital, ver datos por la pantalla del PC, utilizar la consola
serial, leer una entrada digital y escribir por consola serie, la función digitalRead() y
serial.println().
Esquema y plano
Código del programa
//Leer una entrada digital y mostrar en pantalla el estado del pulsador cuando es oprimido
//Declara puertos de entradas y salidas
intboton=2; //Pin donde se encuentra el pulsador, entrada
//Función principal
Voidsetup() // Se ejecuta cada vez que el Arduino se inicia
{
//Configuración
pinMode(boton,INPUT); //Configurar el botón como una entrada
Serial.begin(9600); //Inicia comunicación serial
}
//Función cíclica
Voidloop() // Esta función se mantiene ejecutando
{ // cuando esté encendido el Arduino
int estado = digitalRead(boton); //Guardar en una variable entera el valor del boton 0 ó 1
if (estado==0) //Condicional para saber estado del pulsador
{
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
} //Fin programa

18. Arduino
Página 17
4.Lectura serie de una entrada analógica
Aprenderemos a manejar una entrada analógica, ver datos por la pantalla del PC, múltiples
estados de un potenciómetro, leer una entrada analógica, la función analogRead() y
Serial.println().
Esquema y plano
Código del programa
//Leer una entrada analógica y mostrar por la pantalla el valor luego de girar el potenciómetro
//Función principal
voidsetup() // Se ejecuta cada vez que el Arduino se inicia
{
Serial.begin(9600); //Inicia comunicación serial
}
//Función cíclica
voidloop() // Esta función se mantiene ejecutando
{ // cuando esté encendido el Arduino
int valor= analogRead(A0); //Guardar en una variable 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

19. Arduino
Página 18
5.Escritura serie
Aprenderemos el concepto de entrada por consola (teclado), variables booleanas, ver el estado de
un LED, escritura serie digital, función digitalWrite() y serial.read(), configuración de una
comunicación serie.
Esquema y plano
Código del programa
//Escribe por la pantalla una letra, la primera vez se enciende un LED y la segunda se apaga
//Declara puertos de entradas y salidas y variables
intled = 13; //Pin donde se encuentra el LED, salida
char leer; //Variable donde se almacena la letra
boolean encendido=false; //Estado LED la primera vez, apagado
//Función principal
Voidsetup() // 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
}
//Función cíclica
Voidloop() // Esta función se mantiene ejecutando
{ // cuando esté encendido el Arduino
leer=Serial.read(); //Guardar en una variable el valor de la consola serial
if ( (leer=='a') && (encendido==false) ) // Si es la letra 'a' y además el LED está apagado
{
digitalWrite(led,HIGH); // Enciende el LED
encendido=true; // Actualiza el estado del LED
}
else if ( (leer=='a') && (encendido==true) ) // Si es la letra 'a' y además el LED está encendido
{
digitalWrite(led,LOW); // Apaga el LED
encendido=false; // Actualiza el estado del LED
}
} //Fin programa

20. Arduino
Página 19
6.Encender un led por PWM
Aprenderemos a encender un LED de manera proporcional, el concepto de PWM, escribir una
salida análoga, los comandos If/else con operadores lógicos.
Esquema y plano
Código del programa
//Programa que enciende proporcionalmente un LED, cuando llega a su máximo punto de brillo
//comienza a apagarse proporcionalmente.
//Declara puertos de entradas y salidas y variables
int brillo = 0; //Variable de brillo inicia en 0
intvariacion = 5; //Variable de incremento configurada de 5 en 5
int led = 9; //Pin donde se encuentra el LED, salida
//Función principal
Voidsetup () // Se ejecuta cada vez que el Arduino se inicia
{
pinMode(led, OUTPUT); //Configurar el LED como una salida
}
//Función cíclica
Voidloop () // Esta función se mantiene ejecutando
{ // cuando esté encendido el Arduino
analogWrite(led, brillo); // Escritura analógica (PWM) en el LED escribo el valor de brillo
brillo = brillo + variacion; // Incremento la variable brillo de 5 en 5
// Nota: PWM ----> 0 - 255
// Si el brillo es 0 o 255
if (brillo == 0 || brillo == 255)
variacion = -variacion; //La variación se vuelve negativa
delay (30); //Tiempo de incremento en el brillo
} //Fin programa

21. Arduino
Página 20
7.Control ON/OFF con potenciómetro.
Aprenderemos a manejar una salida digital, concepto de comparación, comando If/Else, función
digitalWrite() y analogRead(), valor de una entrada analógica, condicional y operadores de
comparación.
Esquema y plano
Código del programa
//Programa que enciende un LED cuando el valor de la entrada análoga comandada por el
//potenciómetro esta en cierto valor, cuando éste valor cambia el LED se apaga.
//Función principal
Voidsetup() // 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
Voidloop() // Esta función se mantiene ejecutando
{ // cuando esté encendido 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
}
else //Si el valor es menor a 500
{
digitalWrite(13,LOW); //Apaga el LED en el pin 13
}
delay(100); //Retardo de 100ms para ver los datos de la consola
} //Fin programa

22. Arduino
Página 21
8.Control de un led con LDR
Aprenderemos a realizar escritura por PWM en un LED, leer una entrada análoga por medio de
una LDR, trabajar con una variable, ajustar una entrada análoga a una salida análoga, la función
analogWrite() y analogRead(), concepto de PWM e imprimir datos por consola serie.
Esquema y plano
Código del programa
//Programa que enciende un LED de manera proporcional a la luz que incida en una LDR.
//Función principal
voidsetup() // 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
}
//Función cíclica
voidloop() // Esta función se mantiene ejecutando
{ // cuando esté encendido el Arduino
int foto = analogRead(A0); //Guardar en una variable el valor de la lectura análoga de la
LDR
Intconversion = 780 - foto; //Verifica el valor máximo y realizar una conversión
if ( conversion< 0) //Condicional para establecer un valor absoluto
conversion = conversion * -1; //Multiplicar por -1 porque es negativo
Serial.print("Foto : "); //Imprimir datos del valor de la lectura análoga de la LDR
Serial.print(foto);
Serial.println("");
Serial.print("Conv : "); //Imprimir datos del valor de la conversión
Serial.print(conversion);
Serial.println("");
analogWrite(9, conversion); //Escritura análoga de PWM en el LED
delay(100); //Retardo para datos en la consola
} //Fin programa
T

23. Arduino
Página 22
9.Contador de pulsos
Aprenderemos a incrementar variables, condicional If/else anidado, anti-rebote de un pulsador,
leer una entrada digital y escribir una salida digital a determinada condición, función digitalWrite()
y digitalRead(), imprimir datos por consola, declarar variables enteras.
Esquema y plano
Código del programa
//Programa que muestra por pantalla 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
Intconta = 0; //Variable para guardar el conteo de los pulsos
//Función principal
Voidsetup() // 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
}
//Función cíclica
Voidloop() // Esta función se mantiene ejecutando
{ // cuando esté encendido el Arduino
if ( digitalRead(2) == HIGH ); // Si el pulsador está oprimido
{
if ( digitalRead(2) == LOW ) ; // Si el pulsador no está oprimido
{

24. Arduino
Página 23
conta++; //Incrementa el contador
Serial.println(conta); //Imprime el valor por consola
delay (100); // Retardo
}
}
if (conta==5); // Si el valor del contador es 5
{
digitalWrite(13,HIGH); //Enciende el LED
}
if (conta==8); // Si el valor del contador es 8
{
digitalWrite(13,LOW); // Apaga el LED
}
} //Fin programa

25. Arduino
Página 24
10.Led RGB apoyado por tabla de colores
Aprenderemos a manejar el código de colores de un led RGB, el PWM a tres salidas, manipular
una variable, la función analogWrite(), el LED de anodo común y la estructura de un programa en
Arduino.
Esquema y plano
Código del programa
//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
IntledRojo = 9; //Declara Pin LED Rojo
IntledVerde=10; //Declara Pin LED Verde
IntledAzul=11; //Declara Pin LED Azul
//Función principal
voidsetup() // 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
}
//Función cíclica
voidloop() // Esta función se mantiene ejecutando
{ // cuando esté encendido el Arduino

26. Arduino
Página 25
// Función Color que recibe:1.Rojo/2.Verde/3.Azul
color(255,0,0); //Rojo
delay(1000);
color(0,255,0); //Verde
delay(1000);
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);
}
//Función color
void color(introjo, intverde, intazul)
{
analogWrite(ledRojo, 255); //Escritura de PWM del color Rojo
analogWrite(ledVerde, 255); //Escritura de PWM del color Verde
analogWrite(ledAzul, 255); //Escritura de PWM del color Azul
} //Fin programa

27. Arduino
Página 26
11.Control ON/OFF de un motor DC
Aprenderemos el concepto de control ON/OFF, el condicional If/else, a conectar un motor DC por
transistor, los condicionales a partir del estado del pulsador, la función digitalWrite() y
digitalRead(), el divisor de voltaje, a reconocer un transistor y un motor.
Esquema y plano
Código del programa
//Programa que hace uso de un motor y un pulsador, mientras se mantenga pulsado, el motor
//debe estar encendido, de lo contrario debe estar apagado
//Declara puertos de entradas y salidas y variables
int pulsador =7; //Declara Pin del pulsador
int motor=3; //Declara Pin del motor
//Función principal
Voidsetup() // Se ejecuta cada vez que el Arduino se inicia
{
pinMode(pulsador,INPUT); //El pulsador como una entrada
pinMode(motor,OUTPUT); //El motor como una salida
}
//Función cíclica
Voidloop() // Esta función se mantiene ejecutando
{ // cuando esté encendido el Arduino
if(digitalRead(pulsador) == HIGH)//Si el pulsador está oprimido
{
digitalWrite(motor,HIGH); //Enciende el motor
}
else //si el pulsador no esta oprimido
{
digitalWrite(motor,LOW); //Apaga el motor
}
} // Fin programa

28. Arduino
Página 27
12.Control por PWM de un motor
prenderemos a leer datos de la Consola Serie, el manejo de la función map(), a variar el PWM
para producir 5 velocidades distintas, la etapa de potencia para un motor a través de transistor, la
función analogWrite() y Serial.print(), condicional y operadores de comparación.
Esquema y plano
Código del programa
//Programa que hace uso de un motor y la Consola serial de Arduino
//Declara puertos de entradas y salidas y variables
int motor=3; //Declara Pin del motor
//Función principal
voidsetup() // Se ejecuta cada vez que el Arduino se inicia
{
Serial.begin(9600); //Inicia la comunicación serial Arduino-PC
} //Función cíclica
Voidloop() // Esta funcion se mantiene ejecutando
{ // cuando esté encendido el Arduino
if (Serial.available()) // Si hay algun valor en la Consola Serial
{
char a = Serial.read(); //Variable donde se guarda el caracter enviado del teclado
if (a>='0' && a<='5') // Si el caracter ingresado esta entre 0 y 5
{
int velocidad = map(a,'0','5',0,255); //Variable para escalar el valor ingresado a rango de PWM
analogWrite(motor,velocidad); //Escritura de PWM al motor
Serial.print("El motor está girando a la velocidad ");//Mensaje para el usuario
Serial.println(a);
}
else{ // Si el caracter ingresado NO está entre 0 y 5
Serial.print("Velocidad invalida"); //Mensaje para el usuario
Serial.println(a);
}}} //Fin programa

29. Arduino
Página 28
13.Generar tonos con un buzzer
Aprenderemos el manejo de variables de tipo entera, usar funciones especiales de Arduino, a
generar diversos tonos, producir salidas de frecuencia, la función map() y analogRead(), a enviar
parámetros a las funciones, retardos a través de delay().
Esquema y plano
Código del programa
//Programa que hace uso de un buzzer 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.
//Declara puertos de entradas y salidas y variables
intbuzzer = 9; //Declara Pin del buzzer
int tono = 0; //Declara Pin del potenciómetro
//Función principal
voidsetup() // 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()
}
//Función cíclica
voidloop() // Esta función se mantiene ejecutando
{ // cuando esté encendido el Arduino
int sensor = analogRead(tono); //Variable entera donde se almacena el valor del potenciómetro
int frecuencia = map(sensor,0,1023,100,5000); //Variable,se escala la frecuencia de 100 a 5000Hz
intduracion = 250; //Variable entera para guardar el tiempo deseado en ms
//Funciontone(), 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);
delay(100);//Retardo
} //Fin programa

30. Arduino
Página 29
14.Control de tráfico con leds
Aprenderemos el manejo de variables de tipo entera, usar funciones especiales de Arduino, a
simular el control de un semáforo.
Esquema
Código del programa
//------Control de tráfico---------
//Declara puertos de entradas y salidas y variables
intcarRed = 12; //asigna colores de las luces
intcarYellow = 11;
intcarGreen = 10;
int button = 9; //asigna pin a button
intpedRed = 8; //asigna duración
intpedGreen = 7;
intcrossTime =5000; //tiempo para cruzar
unsignedlongchangeTime; //tiempo desde que se pulsa el botón
//Función principal
void setup() {
pinMode(carRed, OUTPUT);
pinMode(carYellow, OUTPUT);
pinMode(carGreen, OUTPUT);
pinMode(pedRed, OUTPUT);
pinMode(pedGreen, OUTPUT);
pinMode(button, INPUT);
digitalWrite(carGreen, HIGH); //enciende luz verde
digitalWrite(pedRed, HIGH);

31. Arduino
Página 30
}
//Funcióncíclica
void loop()
{
int state = digitalRead(button); //chequeasi el botónestápulsado
if(state == HIGH && (millis() - changeTime)> 5000)
{
changeLights(); //llama a la función para cambiar las luces
}
}
voidchangeLights()
{
digitalWrite(carGreen, LOW); //green off
digitalWrite(carYellow, HIGH); //yellow on
delay(2000); //espera 2 segundos
digitalWrite(carYellow, LOW); //yellow off
digitalWrite(carRed, HIGH); //red on
delay(1000); //espera 1 segundo
digitalWrite(pedRed, LOW); //red off
digitalWrite(pedGreen, HIGH); //green on
delay(crossTime); //espera para cruzar
for (int x=0; x<10; x++) { //parpadea el verde
digitalWrite(pedGreen, HIGH);
delay(250);
digitalWrite(pedGreen, LOW);
delay(250);
}
digitalWrite(pedRed, HIGH); //red on
delay(500);
digitalWrite(carRed, LOW); //red off
digitalWrite(carYellow, HIGH); //yellow on
delay(1000);
digitalWrite(carYellow, LOW); //yellow off
digitalWrite(carGreen, HIGH);
changeTime = millis(); //graba el tiempo desde el último cambio de luces
//vuelve al inicio del programa
} // Fin del programa

32. Arduino
Página 31
15.Led RGB
Aprenderemos el manejo de un led RGB.
Esquema
Código del programa
//------Control de led RGB---------
//Declara puertos de entradas y salidas y variables
intredPin = 9;
intgreenPin = 10;
intbluePin = 11; //Función principal
void setup(){
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);
} //------Función cíclica---------------
}
void loop(){
colorRGB(random(0,255),random(0,255),random(0,255)); // Cambia colores aleatoriamente
delay(1000);
}
voidcolorRGB(int red, int green, int blue)
{
analogWrite(redPin,constrain(red,0,255));
analogWrite(greenPin,constrain(green,0,255));
analogWrite(bluePin,constrain(blue,0,255));
}

33. Arduino
Página 32
16.ALARMA de temperatura
Aprenderemos el manejo del sensor de temperatura LM35.
Esquema
Código del programa
//------Alarma por temperatura-----
floatsinVal;
inttoneVal;
unsigned long tepTimer ;
//-----Función principal--------------
void setup(){
pinMode(8, OUTPUT);
Serial.begin(9600);
}
//------Función cíclica---------------
voidloop(){
int val;
double data;
val=analogRead(0);
data = (double) val * (5/10.24); //convierte tensión en temperatura
if(data>27){ //Si la temperature sube de 27º, suena la alarma
for(int x=0; x<180; x++)
{
sinVal = (sin(x*(3.1412/180)));
toneVal = 2000+(int(sinVal*1000));
tone(8, toneVal);
delay(2);
}

34. Arduino
Página 33
} else { // Si la temperature es menor de 27º, no suena la alarma
noTone(8);
}
if(millis() - tepTimer> 500){
tepTimer = millis();
Serial.print("temperature: ");
Serial.print(data);
Serial.println("C");
}
}

35. Arduino
Página 34
17.Control de un servo
Aprenderemos el manejo de un servomotor.
Esquema
Código del programa
//------Control de un servo--------
//Declara puertos de entradas y salidas y variables
#include <Servo.h>
Servo myservo;
int pos = 0;
//Función principal
voidsetup() {
myservo.attach(9); // conecta el servo en pin 9
}
//------Función cíclica---------------
voidloop() {
for(pos = 0; pos < 180; pos += 1)
{ // va de 0º a 180º en pasos de 1º
myservo.write(pos); //llama al servo a la posición de variable ‘pos'
delay(15); // espera 15ms
}
for(pos = 180; pos>=1; pos-=1)
{ // va de 180º a 0º
myservo.write(pos); //llama al servo a la posición de variable ‘pos'
delay(15);// Espera 15ms
}
} // Fin del programa

36. Arduino
Página 35
18.Interactuando con un servo
Aprenderemos nuevas utilidades de un servomotor.
Esquema
Código del programa
//------Control de un servo--------
//Declara puertos de entradas y salidas y variables
#include <Servo.h>
Servo myservo;
intpotpin = 0;
intval;
//Función principal
void setup() {
myservo.attach(9);
}
//------Función cíclica---------------
voidloop() {
val = analogRead(potpin);// lee el valor del potenciómetro(0-1023)
val = map(val, 0, 1023, 0, 179); // ajusta el valor para el servo(200 - 180)
myservo.write(val); // ajusta la posición del servo
}
delay(15);
}

37. Arduino
Página 36
19.Control velocidad de un motor DC
Aprenderemos el manejo de un motor DC y controlar su velocidad.
Esquema
Código del programa
//------Control de led RGB---------
//Declara puertos de entradas y salidas y variables
intbuttonPin = 2;
intrelayPin = 3;
intrelayState = HIGH;
intbuttonState;
intlastButtonState = LOW;
longlastDebounceTime = 0;
longdebounceDelay = 50;
//Función principal
void setup() {
pinMode(buttonPin, INPUT);
pinMode(relayPin, OUTPUT);
digitalWrite(relayPin, relayState);
}
//------Función cíclica---------------
voidloop() {
intreading = digitalRead(buttonPin); // Comprueba si se ha pulsado
if (reading != lastButtonState) {
lastDebounceTime = millis();}
if ((millis() - lastDebounceTime) >debounceDelay) {

38. Arduino
Página 37
if (reading != buttonState) {
buttonState = reading;
if (buttonState == HIGH) {
relayState = !relayState;}
}
}
digitalWrite(relayPin, relayState); // activa el relé
lastButtonState = reading;
} //Fin del programa

39. Arduino
Página 38
20. Manejo de infrarrojos IR
Aprenderemos el manejo de equipos de infrarrojos.
Esquema
Código del programa
//------Manejo de infrarrojos------
//Declara puertos de entradas y salidas y variables
#include <IRremote.h>
int RECV_PIN = 11;
intledPin = 10;
booleanledState = LOW;
IRrecvirrecv(RECV_PIN);
decode_results results;
void setup(){
Serial.begin(9600);
irrecv.enableIRIn();
pinMode(ledPin,OUTPUT);
}
void loop() {
if (irrecv.decode(&results)) {
Serial.println(results.value, HEX);
if(results.value == 0xFD00FF){
ledState = !ledState;
digitalWrite(ledPin,ledState);
}
irrecv.resume();
}
}

40. Arduino
Página 39