ZonaE. Fundamentos de Arduino Con Aplicaciones Domoticas

Fundamentos de ARDUINO
Aplicados a la domótica y los automatismos
www.zonaelectronica.com
www.clubzona.zonaelectronica.com
Francisco Di Zonno
+58.414.246.48.25
fdizonno@zonaelectronica.com
fdizonno@gmail.com
La Automatización
El mundo del siglo XXI
¿Ficción? ¿Realidad?
¿Futuro? ¿Actualidad?
Domótica
El término domótica viene de la unión de

las palabras domus (que significa casa en
latín) y tica (de automática, palabra en
griego, que significa que funciona por sí
sola).
El término inmótica
El término urbótica
Domótica
La evolución de la Domótica es la consecuencia

de la evolución de varias ciencias y/o disciplinas.
1.- La Electricidad
2.- La Electrónica
3.- La Informática
La electricidad nos ha permitido elevar el nivel

de confort en nuestras viviendas y edificaciones.
La electricidad ha dado paso a la entrada de los

electrodomésticos:
Lavadoras, Neveras, Lavaplatos, Hornos, Cocinas

eléctricas,…
Máquinas capaces de realizar tareas cotidianas de forma

casi autónoma, elevando nuestro nivel de confort que en
otros tiempos eran inimaginables.
La Evolución de la Electrónica,
ha marcado el desarrollo de muchos sistemas, permitiendo
realizar programaciones y/o rutinas, que regulan cada proceso
que se quiera controlar.
La Electrónica
El Transistor
16 de diciembre de 1947
William Shockley,
John Bardeen
y Walter Brattain
Laboratorios Bell
La Electrónica
1956 aparece un computador con

transistores.
Jack Kilby, científico de Texas Instruments,

construye un circuito integrado con varios
transistores funcionando al unísono sobre
una base de silicio.
Es el inicio de la era de los computadores,

de los marcapasos o los vuelos espaciales.
La Informática
Automatismos y la Domótica
El conjunto de sistemas y tecnologías capaces de

automatizar inteligentemente una vivienda y/o
edificio, aportando servicios de:
• Gestión Energética,
• Seguridad,
• Bienestar y Confort,
• Accesibilidad,
• Comunicación.
Aspectos principales de la Domótica
Ahorro Energético
- Climatización (HVAC)
- Gestión Eléctrica
- Uso Energías Renovables
Confort
- Iluminación
- Automatización de todos los sistemas,
instalaciones y equipos
- Integración del Intercomunicador al teléfono
o al Televisor
- Control de dispositivos vía Internet
- Gestión Multimedia y Ocio
Seguridad
- Alarmas de intrusión
- Cierre de persianas puntual y
seguro
- Simulación de presencia
- Alarmas de detección de
incendios, fugas de gas, escape
de agua, concentración de
monóxido de carbono
- Alerta médica. Tele asistencia.
- Acceso a Cámaras IP.
Comunicaciones
- Ubicuidad en el control tanto externo
como interno, control remoto desde
Internet, PC, mandos inalámbricos
(Smartphone con WIFI)
- Tele asistencia
- Tele mantenimiento
- Informes de consumo y costes
- Transmisión de alarmas
- Intercomunicaciones
Accesibilidad
Aplicaciones o instalaciones de control
remoto del entorno que favorecen la
autonomía personal de personas con
limitaciones funcionales, o discapacidad.
Inmótica
¿Qué hace a un edificio más inteligente?
Los sistemas que conversan con sistemas
Urbótica – Smart Cities
Urbótica – Smart Cities
Videovigilancia en las calles

Servicios que se ofrecen a los
ciudadanos, en especial, en
términos de seguridad, generando
así lugares más conectados e
inteligentes.
Generación de energía
Pavegen tiene una instalación
permanente, fuera de la estación
de trenes en Saint Omer, Francia.
14 mosaicos instalados en marzo
de 2014, convierten energía
cinética de los pasajeros que van
caminando en energía eléctrica
sustentable.
Algunos fabricantes
http://www.insteon.com/
http://www.leviton.com/
http://www.crestron.com/
http://nest.com/
http://www.smarthome.com/
http://www.honeywell.es/
http://es-la.control4.com/ http://www.bticino.com/
Algunos productos
Actores importantes
Una plataforma de Apple

para dispositivos iOS
Actores importantes
Philips HUE, bombillos LED

conectados a Internet
Samsung Smart Home
Actores importantes
Es una casa conectada a la red y a

la nube
http://www.hondasmarthome.com/
Iniciativa Open Source Fundamentos de ARDUINO

Elementos de una instalación domótica y/o de
automatismo
• Sensores
• Actuadores
• Soportes de
comunicación
• Central de Gestión
o de Control
Arquitectura
El control está en un solo punto.

Se comunica con los dispositivos para
controlarlos ya que la coordinación está
centralizada
Arquitectura
El control está en varios puntos.

Los controladores se comunican entre ellos con
los dispositivos para controlarlos.
Arquitectura
El control está en el mismo dispositivo.

Sólo se comunica con otros dispositivos
para la coordinación entre ellos
Buses conexión de dispositivos
• Firewire (IEEE 1394)

– Bus serie, cable, hasta 400 MB/s. Topología en árbol.
– Máxima distancia: 4.2m. Hasta 63 dispositivos
• USB
– Bus serie, cable, 600 MB/s. Topología en bus/árbol.
– Máxima distancia: 6m. Hasta 127 dispositivos.
• IrDA
– Punto a punto, inalámbrico. Máxima distancia: 10m
• Bluetooth
– Bus inalámbrico. Máxima distancia 100m. Hasta 24MB/s.
Buses de Control
X10: Protocolo de comunicaciones para el control remoto de dispositivos eléctricos a través de los
enchufes eléctricos. Es de código abierto y el más difundido. Poco fiable frente a ruidos eléctricos.
CEBus abreviación para Consumer Electronics Bus, también conocida como EIA-600. Es un estándar
de protocolos eléctricos y DATA.
LonWorks: Plataforma estandarizada para el control de edificios, viviendas, industria y transporte.
Universal Plug and Play (UPnP): Arquitectura software abierta y distribuida que permite el
intercambio de información y datos a los dispositivos conectados a una red.
KNX/EIB: Bus de Instalación Europeo con más de 20 años y más de 100 fabricantes de productos
compatibles entre sí.
ZigBee: Protocolo estándar, recogido en el IEEE 802.15.4, de comunicaciones inalámbrico.
XBee. Es el nombre comercial para una familia de Radios de Digi

International. Están basados en el estándar IEEE 802.15.4, y diseñados
para comunicaciones inalámbricas punto a punto y en estrella con tasa
de transmisión de 250kbps.
Genéricos. Conectividad vía Ethernet (IEEE 802.3) y/o WiFi (IEEE 802.11)
Redes Domésticas
http://www.zigbee.org/
Redes Domésticas
325 Compañías. 1350 productos.

Todos interoperables en ellos
http://z-wavealliance.org/ Fundamentos de ARDUINO

Redes Domésticas
The worldwide STANDARD

for home and building control
http://www.knx.org
La idea propuesta por Kevin Ashton en 1999
Se estima que 50 mil millones de dispositivos
estarán conectados en el año 2020
Dispositivos IoT
Lo que hace a los dispositivos
IoT diferentes de un sensor
“ordinario” es básicamente la
habilidad de éste de
comunicarse (usualmente) en
forma directa o indirecta a la
Internet.
La pregunta es ¿Cuáles son las

principales razones para que
un dispositivo se tenga que
conectar a Internet o un
servicio de Internet? ¿Qué
clase de servicio será ese? Y
que tipo de servicio debería
obtener?
Interconectividad – Protocolo IP
Dirección IP
Numero único que identifica a un
equipo conectado a una red de
datos.
IPv4 posibilita 4.294.967.296 (232) direcciones de red

diferentes, un número inadecuado para dar una dirección
a cada persona del planeta, y mucho menos a cada
vehículo, teléfono, PDA, etcétera.
IPv6 admite
340.282.366.920.938.463.463.374.607.431.768.211.456
(2128 o 340 sextillones de direcciones) — cerca de 6,7 ×
1017 (670 mil billones) de direcciones por cada milímetro
cuadrado de la superficie de La Tierra. Fundamentos de ARDUINO
Fuente: Wikipedia
Algunas posibilidades
Actores principales
Microcontroladores
Las Computadoras
Microprocesadores (μP)
o simplemente Procesador
Dispositivo electrónico capaz de procesar la información (datos)

de acuerdo a un programa o secuencia de instrucciones que lo
gobiernan.
Es el encargado de realizar las

operaciones aritmético-lógicas, de
control y de comunicación de una
computadora PC, con el resto de
sus partes y componentes
funcionales.
Microcontrolador (μC)
Un microcontrolador es un circuito
integrado que contiene internamente
todos los componentes básicos de un
computador:
•CPU
•Memoria
•Unidades de E/S
Este se utiliza para controlar el

funcionamiento de Sistemas Electrónicos
con tareas determinadas. Sus pines de
entradas y salidas se utilizan para
conectar motores, relays, actuadores,
etc.
Microcontrolador (μC)
Área
de RAM
Reloj y Temporizadores
Puertos de E/S
Área
de ROM
Periférico 1 Periférico 2
Periférico 3 Periférico 4
Microcontroladores (μC) hoy en día
Sistemas embebidos (embedded)
Algunos fabricantes de Microcontroladores
Programando los
Microcontroladores
Proceso de desarrollo de proyectos con
Microcontroladores
Computador
Programa de
Grabación
Dispositivo de
Grabación
Unidad de Memoria
Memoria volátil de poca capacidad pues sólo debe contener el

Memoria
resultado de las operaciones (variables) y los cambios de información
RAM
que se produzcan con la ejecución del programa.
ROM con máscara Memoria no volátil de sólo lectura cuyo

contenido se graba durante la fabricación
del chip.
OTP Memoria no volátil de sólo lectura
“programable una sola vez” por el usuario.
OTP (One Time Programmable).
Memoria EPROM Memoria no volátil pueden borrarse con luz
ROM ultravioleta y grabarse muchas veces
EPROM (Erasable Programmable Read
OnIy Memory).
EEPROM Memoria no volátil programable y borrable
eléctricamente EEPROM (Electrical
Erasable Programmable Read OnIy
Memory).
FLASH Memoria no volátil basada en las EEPROM,
es de bajo consumo, que soporta muchos
procesos de escritura y borrado. Funciona
al mismo tiempo como una ROM y una
RAM.
Lenguajes de Programación
Lenguajes de Programación
Instrucción:
Suma 58 al registro de trabajo W y guarda el resultado
en este mismo registro W
Lenguaje de Máquina
11111000111010 – Binario
3E3A - Hexadecimal
Lenguaje Ensamblador
addlw d’58
Lenguaje de Alto Nivel

Lenguaje C, Basic, Diagramas de Flujo, C++, Python
Compiladores
Muchos fabricantes de microcontroladores ofrecen herramientas

para desarrollar aplicaciones para sus microcontroladores
Ambiente de Desarrollo Integrado - IDE
Tareas Típicas de un IDE
1.- Área para escribir el código “fuente”.

2.- Compilar, ensamblar y encadenar el código fuente con los programas
que conviertan el código fuente en “unos y ceros” que es lo que
finalmente entiende el microcontrolador.
3.- Probar el programa utilizando simuladores.
4.- “Quemar” o grabar el código en la memoria de programa del
microcontrolador y verificar que se ejecuta correctamente en la
aplicación definitiva.
ARDUINO
PINGUINO
MPLAB X
PICAXE Editor Fundamentos de ARDUINO

Escribiendo Programas
(Código fuente) para
los Microcontroladores
Pasos para elaborar un “Programa”
 Tener una idea clara de lo que se quiere

hacer.
 Realizar el algoritmo.
 Expresar el algoritmo mediante un diagrama
de flujo.
 Codificar el diagrama de flujo.
Escribir un Programa
Tareas – Pasos – Algoritmo
La idea principal de escribir un programa

consiste en dividir un problema en una serie de
pequeñas tareas.
Problema:
Tener un programa que mida la
temperatura y la muestre en una pantalla
LCD.
Tareas – Pasos – Algoritmo:

1.- Activar y fijar el convertidor A/D incluido
2.- Medir un valor analógico
3.- Calcular la temperatura
4.- Enviar la DATA en el formato apropiado al
LCD
Dispositivos Interactivos
Dispositivo electrónico capaz de
“sentir”
el medio ambiente usando
sensores,
que convierten las señales
externas en señales eléctricas.
Procesar la información recibida

que obtiene de los sensores con
comportamientos que están
implementados en el software.
Interactuar o “actuar” con el

mundo
exterior usando actuadores que
convierten señales eléctricas en
acciones físicas.
¿Qué es ARDUINO?
Arduino es una plataforma de

desarrollo de computación física,
de código abierto, basada en una
placa con un sencillo
microcontrolador y un entorno
de desarrollo para crear software
(para esa placa).
Software libre Hardware libre
ARDUINO
La plataforma Arduino se ha convertido en popular entre las personas

que están desarrollando proyectos en electrónica, por una serie de
buenas razones:
- No necesita un hardware especial (programador) para cargar el

código de programa en el microcontrolador.
- Se programa a través de puerto USB
- Usa una versión simplificada de C++, que lo hace fácil de aprender
a programar.
- Provee un estándar en cuanto a su construcción que divide las
funciones de un microcontrolador en paquetes mas accesibles
- Multiplataforma (Linux, Mac, Windows)
El hardware y software de Arduino fue diseñado para artistas,

diseñadores, publicistas, hobbistas, principiantes, y cualquiera
interesado en crear objetos y ambientes interactivos.
www.arduino.cc
ARDUINO - Historia
– Massimo Banzi
– David Cuartielles
– Gianluca Martino
– Tom Igoe
– David Mellis
Arduino nació como un proyecto

educativo - año 2005
Massimo Banzi y David Cuartilelles querían desarrollar una tarjeta de prototipos

que fuera fácil de programar por no expertos, de modo que los estudiantes de
diseño pudieran construir proyectos que usaran microcontroladores.
Subsistir ante el eminente cierre del Instituto de diseño Interactivo IVREA en

Italia, la idea era crear un producto open hardware (de uso público) que no
pudiese ser embargado.
Para su creación participaron alumnos que desarrollaban sus tesis como

Hernando Barragan (Colombia) quien desarrollo la plataforma de
programación Wiring con la cual se programa el microcontrolador.
El Ecosistema Arduino / Genuino
Consiste de:
o La placa Arduino
o El IDE Arduino
o El lenguaje Arduino
o Software (Bibliotecas) de terceros
o Shields o extensiones
o Componentes electrónicos
Arduino
Arduino
Arduino
Arduino UNO R3
Arduino UNO R3
ESPECIFICACIONES TECNICAS
- Microcontrolador ATmega328
- Voltaje de operación 5V
- Voltaje de entrada (recomendado) 7-12 V
- Voltaje de entrada (limite) 6-20 V
- Digital I/O Pins 14
- Canales PWM 6
- Entradas analógicas (6 pines)
- DC corriente I/O Pin 40 mA
- DC corriente 3.3V Pin 50 mA
- Memoria Flash 32 KB (ATmega328) con
0.5KB para el bootloader
- SRAM 2KB (ATmega328)
- EEPROM 1KB (ATmega328)
- Velocidad de reloj 16MHz
- ATmega 16U2 para comunicación USB
Arduino – Shields - Extensiones
Arduino - Shields
http://shieldlist.org/
Comenzando con ARDUINO
Pasos:
1. Conseguir un Arduino y un cable USB

2. Descargar el IDE de Arduino
3. Instalar - descomprimir el IDE
4. Conectar la placa
5. Instalar los drivers
6. Ejecutar el IDE Arduino
7. Abrir el ejemplo Blink
8. Seleccionar la placa (tarjeta Arduino)
9. Seleccionar el puerto serie (COM)
10.Subir (Cargar) el sketch a la placa
Descargar el IDE - Arduino
http://www.arduino.cc/en/Main/Software
Puertos COM Virtuales – Ambiente Windows
ARDUINO - IDE
Barra de menues
Barra de herramientas
Pestañas
Editor de texto
Área de mensajes
Consola
Los programas en Arduino se llaman SKETCHs

Abrir el sketch de ejemplo BLINK
Seleccionar la tarjeta Arduino y el puerto serial
“Cargar” el sketch y verificar el
funcionamiento en la tarjeta
ARDUINO – Ejemplos
ARDUINO - Bibliotecas
(Libraries)
ARDUINO – Ayuda
ARDUINO – Otros IDE
Arduino se puede programar por medio de otras plataformas
Arduino Create
Eclipse
VisualMicro – Entorno para

Visual Studio
Atmel Studio - Entorno de
programación de
microprocesadores
• Programino: http://programino.com/ (de pago)

• Codebender: https://codebender.cc/ (on-line)
• PlatformIO: http://platformio.org/platformio-ide (IDE
para IoT con soporte para Arduino)
• Ardublock: http://blog.ardublock.com/ (IDE con
entorno gráfico de programación)
• Uecide: http://uecide.org/
ARDUINO – Sketch o programa base
Los programas son

estructurados en
forma de funciones.
Elementos de los sketchs o programas
Comentarios:
Proveer información al ser humano de los que hace o debe hacer cierta parte de un
programa.
/* Esto es un comentario
dentro de un sketch de Arduino */
int ledPin = 13; // Esto también es un comentario
Declaraciones:
Se usa para crear elementos de un programa como variables y funciones y también
para indicar sus propiedades.
unsigned char contador; // Define una variable llamada contador
Elementos de los sketchs o programas
Instrucciones, Sentencias o Comandos:

Es donde ocurre la acción de un programa. Realizan operaciones matemáticas u
operaciones lógicas y establecen el flujo del programa. Cada instrucción que no
sea un bloque debe terminar en un ; (punto y coma).
Todas las sentencias deben encontrarse dentro de una función
digitalWrite(13, HIGH);
contador = 1;
Bloques de Código:
Tanto las Declaraciones como las Instrucciones pueden ser agrupadas en Bloques.
Un bloque se define como lo encerrado entre dos símbolos de llaves.
while (1) {
digitalWrite(13, HIGH); // turn the LED on (HIGH is the
voltage level)
delay(1000); // wait for a second
}
Ejercicio: XC8_Plantilla
Elementos de los sketchs
Funciones:
Una función (también conocida
como procedimiento o sub-
rutina
es una pieza de código que
puede ser usada en cualquier
parte de un Sketch.
Se puede llamar a una función

que ha sido definida dentro del
sketch o que es parte del
lenguaje Arduino.
Las funciones pueden o no

contener parámetros, y
pueden o no devolver un valor
de resultado.
Algunas definiciones que se deben conocer
Bit – Unidad mínima de información
Byte – Conjunto de 8 Bits
Algunas definiciones que se deben conocer
Sistemas de Numeración
Sabia usted que toda las personas pueden ser clasificadas en 10
grupos La que conocen el Sistema de numeración binaria y las que
no lo conocen.
Un sistema de numeración es un conjunto de símbolos y

reglas de generación que permiten construir todos los
números válidos.
Decimal, Binario, Hexadecimal
Diferentes bases numéricas
TIPO SINTAXIS COMENTARIO

Decimal 123
(base 10)
Hexadecimal 0x3F Caracteres del
(base 16) 0 - 9, A - F, también
son válidos de la a – f
Octal 0173 Caracteres del

(base 8) 0–7
Binario B11110000 Solo trabaja con
(base 2) valores de 0 – 255
ASCII ‘A’ o “HOLA” Cualquier símbolo

ASCII
Transducción
Conversión de un tipo de energía en otra
Energía Física
Sensores Actuadores
Energía Eléctrica
Conceptos Fundamentales
CORRIENTE:
También denominada intensidad, es el flujo de electrones libres a través de un
conductor o semiconductor en un sentido. La unidad de medida de este parámetro
es el amperio (A).
Al igual que existen tensiones continuas o alternas,

las intensidades también pueden ser continuas o
alternas, dependiendo del tipo de tensión que se
utiliza para generar estos flujos de corriente.
Fuente: Wikipedia
VOLTAJE:
Es la diferencia de potencial generada entre los extremos de un componente o
dispositivo eléctrico. También podemos decir que es la energía capaz de poner en
movimiento los electrones libres de un conductor o semiconductor. La unidad de
este parámetro es el voltio (V).
Existen dos tipos de tensión: la continua y la alterna.
Voltaje continuo (VDC) – Es aquel que tiene una

polaridad definida, como la que proporcionan las pilas,
baterías y fuentes de alimentación.
Voltaje alterno (VAC) – Es aquel cuya polaridad va

cambiando o alternando con el transcurso del tiempo.
Las fuentes de voltaje alterno más comunes son los
generadores y las redes de energía doméstica.
Fuente: Wikipedia
RESISTENCIA ELECTRICA:
Es la propiedad física mediante la cual todos los materiales tienden a oponerse al
flujo de la corriente. La unidad de este parámetro es el Ohmio (Ω).
Fuente: Wikipedia
ElectroDroid - Android
ElectroDroid - Android
Electrónica – Conceptos Fundamentales
Ley de Ohm
La ley de Ohm dice que la intensidad de la corriente que

circula entre dos puntos de un circuito eléctrico es
proporcional a la tensión eléctrica entre dichos puntos.
Tareas en las que usamos el Arduino
1.- Salidas Digitales

2.- Entradas Digitales
3.- Salidas Analógicas
4.- Entradas Analógicas
Salidas Digitales
Salida Digital:
Cualquier dispositivo que pueda ser
encendido-apagado, puede ser un Simples:
potencial transductor de salida digital LEDs, Buzzer
El reto de estos transductores es Complejas:

Motores, Solenoides, Bombillos,
determinar cuales pueden interactuar Calentadoras de Café
directamente con el Microntrolador, es
Dispositivos que requieren un
decir, cuales pueden ser encendidos o intermediario para funcionar
apagados directamente con 5 volts y con
alrededor de 10 a 20 mA que son los Relés y transistores
niveles que un puerto de salida de un
microcontrolador puede manejar.
ARDUINO – Salidas Digitales
LED en Pin 13
Instrucciones
- pinMode(pin,TIPO)
- digitalWrite(pin,ESTADO)
- delay(tiempo)
Pasos para crear un sketch

1.- Escribir el código
2.- Compilar el sketch
3.- Cargar el Arduino
NOTA: LED_BUILDIN es una constante predefinida

para el pin 13 del Arduino
Proyecto – Hola Mundo
LED Intermitente (Blink) Salidas Digitales
Por una de las patas del Arduino hacer parpadear
un LED.
/* Encender y apagar un LED durante 1 segundo, repetidamente
*/
Algoritmo
- Encender el LED // El pin 13 del Arduino está conectado a un LED
- Esperar un tiempo
- Apagar el LED // Rutina de inicialización.
- Esperar otro tiempo void setup() {
- Repetir siempre // Inicializa el pin 13 como salida
pinMode(13, OUTPUT);
}
// La rutina loop de ejecuta continuamente

void loop() {
Ejemplos: digitalWrite(13, HIGH); // Enciende el LED
E01_LedParpadeando01 delay(1000); // Retardo de 1 segundo
E01_LedParpadeando02 digitalWrite(13, LOW); // Apaga el LED
delay(1000); // Retardo de un segundo
} Fundamentos de ARDUINO
Electrónica – Semiconductores
DIODO:
Un diodo es un componente electrónico de dos terminales
que permite la circulación de la corriente eléctrica a través
de él en un solo sentido.
LEDs – Diodos emisores de luz
Diodo emisor de luz, también conocido como LED (acrónimo

del inglés de Light-Emitting Diode).
Dispositivo semiconductor (diodo) que emite luz incoherente

Ánodo (A) de espectro reducido cuando se polariza de forma directa la
unión PN del mismo y circula por él una corriente eléctrica.
Cátodo (K) Este fenómeno es una forma de electroluminiscencia. El color

(longitud de onda), depende del material semiconductor
empleado en la construcción del diodo y puede variar desde
el ultravioleta, pasando por el visible, hasta el infrarrojo.
Fuente: wikipedia Fundamentos de ARDUINO
LEDs – Diodos Emisores de Luz
Voltaje de Operación: 1,8 a 3,8 v

Corriente directa de polarización: 10 y 40 mA
El color de la luz de los LEDs (longitud de onda),

depende del material semiconductor empleado
Ánodo (A)
Cátodo (K)
Protoboard
El protoboard o placa de conexiones es una herramienta utilizada

para construir prototipos electrónicos sin necesidad de realizar
conexiones físicas permanentes o conexiones con soldaduras.
http://fritzing.org
Proyecto
Crear el siguiente
circuito y determinar el
valor aproximado de la
resistencia del circuito.
El LED se conecta en el
pin 5 del Arduino.
Realizar el montaje y la
respectiva
programación
de 2 segundos
prendido y 1 segundo
apagado.
Proyecto
Hacer un montaje de 2 LEDs
Intermitentes en una placa
Arduino.
Se debe encender 1 LEDs en

la pata 5 mientras el otro en la
pata 7 está apagado, y luego
se invierten.
Realizar el montaje y la
respectiva programación de
500ms segundos prendido y
500ms segundos apagado
Variables
Las variables son espacios en la

memoria de datos del microcontrolador,
que se usan para almacenar
temporalmente información que
posteriormente será utilizada.
Una Variable es un nombre asignado a

una o varias posiciones de memoria.
Variables
Toda variable debe ser declarada antes de poder ser utilizada

• Las variables ocupan espacio en la memoria RAM del microcontrolador
• Las variables pueden ser locales o globales
• Las variables deben tener un tipo de dato definido
• Las variables se les debe inicializar con un valor
• Los nombres de las variables deben empezar con una letra
• Los nombres son “Case Sensitive”
Para la inmensa mayoría de las aplicaciones con sistemas embebidos, solo

se requerirá de variables tipo int
El chip ATmega328 del Arduino Uno tiene las siguientes

cantidades de memoria:
Flash - 32k bytes (de los cuales 0,5k
son usados por el bootloader)
SRAM - 2k bytes
EEPROM - 1k byte
Formas de declarar Variables
Tipos de datos y sus tamaños
TIPO DE TAMAÑO
RANGO DE VALORES
DATO (EN BITS)
Usada sólo en declaraciones de funciones

void 0
donde no hay un valor de retorno
boolean 8 true o false / 1 o 0
char 8 -128 a 127
unsigned char 8 0 a 255
byte 8 0 a 255
int 16 -32.768 a 32.767
unsigned int 16 0 a 65.535

ARDUINO
Tipos de Datos y sus Tamaños
TIPO DE TAMAÑO
( N U M E RO D E RANGO DE VALORES
DATO BITS)
long 32 -2.147.483.648 a 2.147.483.647

unsigned long 32 0 a 4.294.967.295
float 32 -3.4028235E+38 a 3.4028235E+38
double 32 -3.4028235E+38 a 3.4028235E+38
string Arreglo de tipo char, donde el arreglo
(char array) termina en carácter null
String Clase String para manipular cadenas de
(clase) textos en forma mas compleja
Colección de variables que
array
se aceden con un índice
ARDUINO
Uso de Variables
LED Intermitente (Blink) Salidas Digitales

Por una de las patas del Arduino hacer parpadear
un LED.
/* Encender y apagar un LED durante 1 segundo, repetidamente
*/
Algoritmo // El pin 13 del Arduino está conectado a un LED
- Encender el LED int led = 13;
- Esperar un tiempo
- Apagar el LED // Rutina de inicialización.
- Esperar otro tiempo void setup() {
- Repetir siempre // Inicializa el pin 13 como salida
pinMode(led, OUTPUT);
}
// La rutina loop de ejecuta continuamente

Ejemplos: void loop() {
E01_LedParpadeando03 digitalWrite(led, HIGH); // Enciende el LED
delay(1000); // Retardo de 1 segundo
digitalWrite(led, LOW); // Apaga el LED
delay(1000); // Retardo de un segundo
Operadores aritméticos
OPERADOR OPERACION
+ Adición
- Sustracción
* Multiplicación
/ División
% Modulo
Operadores de asignación
/* Uso de Constantes y variables en un programa

con operadores de Asignación
*/
// Definir la pata de salida para el LED

int pinLed = 5;
int a = 0;
void setup() {
// inicializa la pata pinLed como salida
pinMode(pinLed, OUTPUT);
}
void loop() {
a = a + 100;
digitalWrite(pinLed, HIGH); // enciende el Led
delay(a); // retardo
Ejercicios:
E02_OperadoresAsignacion digitalWrite(pinLed, LOW); // apaga el led
E02_OperadoresAsignacion01 delay(a); // retardo
}
Operadores compuestos
E JEMPLO
OPERADOR
Expresión Equivalente
+= a += 8 a=a+8
-= a -= 8 a=a-8
*= a *= 8 a=a*8
/= a /= 8 a=a/8
%= a %= 8 a=a%8
OPERADOR E JEMPLO DESCRIPCION

++a
++ Variable "a" es incrementada en 1
a++
--b
-- Variable "b" es decrementada en 1
b--
Operadores condicionales o de control
Se usan para tomar decisiones o bifurcaciones basadas en varias
condiciones que pueden ocurrir durante la ejecución del programa
Instrucciones
NO / SI
¿Condición?
SI / NO
Operador condicional If --- if / else
if (pin5Entrada < 500) { if (x > 120) digitalWrite(LEDpin, HIGH);

// Acción 1
} else {
// Acción 2 if (x > 120)
} digitalWrite(LEDpin, HIGH);
if (pin5Entrada < 500) { if (x > 120) { digitalWrite(LEDpin, HIGH); }

// Acción 1
} else if (pin5Entrada >=1000) { if (x > 120){
// Acción 2 digitalWrite(LEDpin1, HIGH);
} else { digitalWrite(LEDpin2, HIGH);
// Acción 3 }
}
Condicionales lógicos
CONDICIÓN
OPERADOR SIGNIFICADO E JEMPLO
VERDADERA
> Es mayor que b>a Si b es mayor que a
Si a es mayor o igual que
>= Es mayor o igual que a >= 5
5
< Es menor que a<b Si a es menor que b
Si a es menor o igual que
<= Es menor o igual que a <= b
b
== Es igual a a == 6 Si a es igual a 6
!= No es igual a a != b Si a es diferente de b
Verdadero es 1 -- Falso es 0
Valores diferentes de Cero son tratados como Verdadero
Valores iguales a Cero son tratados como Falso
Operadores de condicionales
/* Uso de Operadores condicionales en un programa */

int pinLed = 5;
int a = 0;
void setup() {
}
void loop() {
a += 100; // a = a + 100
digitalWrite(pinLed, LOW); // apaga el led
if (a > 1000) { // Si la variable a es mayor

a = 0; // de 1000 se inicializa
}
}
Ejercicio:
E03_OperadoresFundamentos
Condicionales01
de ARDUINO
Operadores booleanos
OPERADOR Y LÓ G I CO
Operando 1 Operando 2 Resultado
0 0 0
&& 0 1 0
1 0 0
1 1 1
OPERADOR O LÓ G I C A
Operando 1 Operando 2 Resultado
0 0 0
|| 0 1 1
1 0 1
1 1 1
OPERADOR N E G A D O LÓ G I CO
Operador Resultado
! 0 1
1 0
Operadores de condicionales
/* Uso de Operadores condicionales en un programa */

int pinLed = 5;
int a = 0;
int b = 0;
void setup() {
}
void loop() {
a += 100; // a = a + 100
b += 200;
digitalWrite(pinLed, LOW); // apaga el led
if (a > 1000 && b > 2000) { // Si la variable a es mayor

Ejercicio: a = 0; // de 1000 y b > 20000
E03_Operadores Condicionales02
}
}
Lazos, bucles o saltos
Lazo de repetición infinita

Lazo que se repite un
número
conocido de veces
Instrucciones
Inicia Contador
Instrucciones
Lazo condicionado
Decrementar Contador
Instrucciones
NO / SI
¿Contador=0? NO / SI
¿Condición?
SI / NO
SI / NO
Instrucciones de repetición
Operador for
for(initial_expression; condition_expression; change_expression) {
operations
...
}
for(k=1; k<5; k++) // repetir el ciclo 5 veces (desde 1 a 5)

operation //
ARDUINO – Ejercicio – Ciclo for
/* Ejemplo Semaforo */
// Inicializaciones. Configura los pines 2, 3 y 4 como salida

void setup() {
pinMode (2,OUTPUT);
pinMode (3,OUTPUT);
pinMode (4,OUTPUT);
}
void loop() {
digitalWrite (2,HIGH); //Asigna un estado 1 lógico al pin 2
delay (4000);
digitalWrite (2,LOW); //Asigna un estado 0 lógico al pin 2
for (int cuenta = 0;cuenta <5;cuenta++) {

digitalWrite (3,HIGH);
delay (1000);
digitalWrite (3,LOW);
delay (200);
}
delay (5000); Ejercicio:
digitalWrite (4,LOW); E04_SemaforoFOR
Instrucciones de repetición
Operador while
Permite crear un loop continuo hasta que se cumpla que la
expresión entre paréntesis sea falsa.
while (expression) {
// statement(s)
}
var = 0;
while(var < 200) {
// Repetir 200 veces
var++;
Instrucciones de Bucle, lazo o Loop
Operador do - while
Trabaja de la misma manera que el comando while,

pero la condición es evaluada al final, asegurando que
la rutina se ejecute al menos una vez.
do {
// hacer algo
} while (x < 100);
ARDUINO – Ejercicio – Ciclo while
/* Ejemplo Semaforo */
//Configura los pines 2, 3 y 4 como salida
void setup() {
pinMode (2,OUTPUT); Ejercicio:
pinMode (3,OUTPUT); E05_SemaforoWHILE
pinMode (4,OUTPUT);
}
void loop() {
byte cuenta =0;

digitalWrite (2,HIGH); //Asigna un estado 1 lógico al pin 2
delay (4000);
digitalWrite (2,LOW); //Asigna un estado 0 lógico al pin 2
while (cuenta<5) {
delay (1000);
delay (200);
cuenta++;
}
delay (5000);
Entradas Digitales
Entrada Digital: Suiche ON–OFF Apagado-Encendido
Suiche normalmente abierto Algoritmo

Poner el puerto como entrada
Suiche normalmente cerrado Loop
Suiche momentáneo Verificar si la entrada está en 0v o en 5v
Si la entrada está en 5v
Hacer algo
Si la entrada está en 0v
Número de Polos, Pole: Loop
Cada polo conecta (o desconecta) 2 cables
Número de tiro, piso, throw:

Indica la cantidad de posibles posiciones cerradas
que tiene un Suiche.
SPST (Single-Pole, Single-Throw)

DPDT (Double-Pole, Double-Throw)
SPDT (Single-Pole, Double-Throw)
Electrónica – Componentes
BOTONES y/o PULSADORES
Pines o Patas Digitales
Las patas configuradas como Entradas que no tengan nada

conectado deben colocársele una resistencia de Pull-Up o
Pull-Down, típicamente de 10K.
Pines o Patas Digitales
Las patas configuradas como
Entradas que no tengan nada
conectado deben colocársele una
resistencia de Pull-Up o
Pull-Down, típicamente de 10K.
ARDUINO – Entradas Digitales
ARDUINO – Entradas Digitales
// Botón conectado al pin 2

// LED conectado al pin 5
ARDUINO – Ejercicios
/* Instrucción: digitalRead()
Botón para controlar un LED
Encender un LED mientras se mantiene pulsado un Botón y
Apagarlo cuando se suelta el botón …
void loop(){ // Programa principal
El Circuito: // Lee el estado del boton
* LED conectado entre el pin 5 y tierra EstadoBoton = digitalRead(BotonPin);
* Botón momentáneo conectado al pin 2 y a +5V
* Resistencia de 10K entre el pin 5 y tierra // Verifica si el boton está presionado
*/ if (EstadoBoton == HIGH) { // Condición para el botón
// presionado.
// Definición de constantes // Encender el LED
int BotonPin = 2; // Botón conectado al pin 2 digitalWrite(LEDPin, HIGH);
int LEDPin = 5; // LED conectado al pin 5
} else { // Condición para botón no presionado.
// Definición de variables // Apagar el LED
int EstadoBoton = 0; // En esta variable se guardo la digitalWrite(LEDPin, LOW);
// lectura del boton }
}
void setup() { // Inicializaciones del programa
// Inicializa el puerto para leer el botón

pinMode(BotonPin, INPUT); Ejercicio:
// Inicializa el pin como salida
E07_LedControladoPorBoton01
pinMode(LEDPin, OUTPUT);
}
…
ARDUINO – Ejercicio
Semáforo peatonal
Resistencias internas de Pull-Up
El Arduino tiene internamente resistencias de Pull-Up de 20K, que se pueden

activar por Software.
Resistencia
Interna de pull-up
Usando las Resistencias INTERNAS
Esquema con resistencia interna de /*
Con un botón encendemos el LED, el cual se mantiene
Pull-up encendido hasta que pisamos el otro botón.
El Circuito:
* LED conectado entre el pin 5 y tierra
* Botón momentáneo conectado al pin 9 y pin 8 y a tierra
*/
int ledPin = 5;
int buttonApin = 9;
int buttonBpin = 8;
byte leds = 0;
void setup() {
pinMode(ledPin, OUTPUT);
pinMode(buttonApin, INPUT_PULLUP);
pinMode(buttonBpin, INPUT_PULLUP);
}
void loop() {
if (digitalRead(buttonApin) == LOW) {
digitalWrite(ledPin, HIGH);
}
if (digitalRead(buttonBpin) == LOW) {
digitalWrite(ledPin, LOW);
}
}
Ejercicio:
E07_LedControladoPorBoton02 Fundamentos de ARDUINO
Arduino con PIR
/*Muestra el funcionamiento de un PIR o sensor

de movimiento*/
void setup(){
pinMode(13,OUTPUT);
pinMode(2,INPUT);
}
void loop(){
digitalWrite(13,digitalRead(2));
}
Arduino con sensor TILT Ejercicio:

E08_PIR
Arduino reed switch Fundamentos de ARDUINO
ARDUINO – Monitor Serial
/*
-------------------------------------- Serial.begin(speed)
Mostar información por el monitor serial
-------------------------------------- Serial.println()
*/
Imprime datos en el monitor serial en
void setup() { // Comienzo de la función setup() formato legible por los humanos,
Código ASCII con el texto seguido de
Serial.begin(115200);
un carácter de retorno de carro
Serial.println(“Salida de información por el monitor serial”); (carriage return), ASCII 13, o '\r‘ y un
carácter de nueva línea ASCII 10, o
} // Final de la función setup()
'\n').
void loop() { // Comienzo de la función loop
} // Final de la función loop
Ejercicio:
E09_SerialConsola00
E09_SerialConsola01
Código ASCII
Ejercicio:
IDE Arduino
Archivo>Ejemplos>
Communication>ASCIITable
ARDUINO – Revisando el estado de una señal
/*
--------------------------------------
Lectura serial de una entrada digital
--------------------------------------
Leer una entrada digital y mostrar por la pantalla del
computador (consola serial) el estado del pulsador
*/
int pulsador=2; //Pin donde se encuentra el pulsador, entrada

void setup(){
pinMode(pulsador,INPUT); //Configurar el pulsador como una entrada
Serial.begin(9600); //Inicia comunicación serial
}
void loop(){
// Lee el botón
int estado = digitalRead(pulsador);
//Condicional para saber estado del pulsador
if (estado==1){
// Pulsado
Serial.println("Pulsado"); //Imprime en la consola serial "Pulsado"
}else{
// No esta pulsado
Serial.println("NO Pulsado"); //Imprime en la consola serial "NO Pulsado"
} Ejercicio:
delay(100); //Retardo para la visualización de datos en la consola E08_SerialConsola02
}
ARDUINO – Activando una señal desde la consola
/*
--------------------------------------------------------
Controlar un LED desde el Monitor Serial
--------------------------------------------------------
Encendemos o apagamos un LED en función de la tecla pulsada
*/
int input;
void setup() {
pinMode(13, OUTPUT); // Declaramos que utilizaremos el pin 13 como salida
Serial.begin(9600);
}
void loop() {
if (Serial.available() > 0) {
input = Serial.read();
if (input == '1') {
digitalWrite(13, HIGH); //Si el valor de input es 1, se enciende el led Ejercicio:
} E09_SerialConsola03
else
{
digitalWrite(13, LOW); //Si el valor de input es diferente de 1, se apaga el LED
}
}
}
No todo es blanco y negro, hay grises
Sensores
Transducción:
Transformación o conversión de una forma de energía de
entrada, en otra diferente de salida
Entradas Analógicas
Resistencias Variables Fotoceldas, fotorresistencias

Convierten un cambio mecánico, de
iluminación, de temperatura y de otras
formas de energía en un cambio en la
resistencia eléctrica que ofrece.
Potenciómetros, reóstatos
Resistores Flex
Resistores de fuerza
Termistores
Entradas analógicas
Sensores de fuerza o presión

o Materiales que varían su resistencia eléctrica al deformarse.
o Materiales piezoeléctricos. Producen diferencias de potencial
al deformarse.
Sensores de temperatura
o Detectores de temperatura resistivos (RTD).
o Termistores.
o Termopar.
Sensores de caudal/flujo
o Basados en diferencias de presión
o Basados en turbinas
o Basados en flujo magnético
Sensores de Calidad del Aire
o Humedad
o Oxigeno, CO2
o Otros gases
Sensores de movimiento o presencia
o Aceleración, velocidad
o Desplazamiento (posición, distancia, proximidad, tamaño).
Convertidores Análogos a Digitales
Permiten leer un nivel de voltaje en un

momento dado y convertirlo a un valor
digital que puede ser manipulado o
almacenado en el microcontrolador o
Computadora
Suministran una señal digital en un momento

y la convierten en un equivalente analógico
para manipular objeto que produce una
acción
Proceso de Conversión Análogo a Digital
Pines o Patas de Entrada Analógicas
Los Arduinos UNO contienen 6 canales que realizan la conversión análoga-

digital.
Los convertidos A/D tienen una resolución de 10-Bits, desde el valor 0 al

valor 1023.
Estas patas son usadas principalmente para conectarles sensores análogos y

poder “sentir” el entorno exterior que se quiera controlar.
Los puertos o pines análogos pueden configurar como como puertos

digitales, usando el alias A0 (para decir puerto Análogo 1).
Potenciómetro
Electrónica – Divisor de Tensión
ARDUINO – Entradas Análogas
Instrucciones
analogRead(pin)
Valor entre 0 y 1023
map(valor, deBajo, deAlto, aBajo, aAlto)

Cambiar la escala
constrain(valor, min, max)

Restringe el rango de un valor
Las Entradas analógicas son de 10 bits
El rango de voltaje está dado entre 0 y 5

volts, pero utilizando el pin AREF, este
rango se puede variar a algún otro
El convertidor analógico/digital tarda deseado.
alrededor de 100 microsegundos (0,0001s) en
procesar la conversión y obtener el
valor digital. Por lo tanto la lectura en los pines
analógicos es de 10.000 veces por segundo. Fundamentos de ARDUINO
/*
Leer una entrada análoga y mostrar por la pantalla
del computador (consola serial) el valor luego de
girar el potenciómetro
*/
void setup(){
Serial.begin(9600); //Inicia comunicación serial
}
void loop(){
//Guardar en una variable entera el valor
//del potenciómetro 0 a 1023
int valor= analogRead(A0);
//Imprime en la consola serial el valor de la variable
Serial.println(valor);
//Retardo para la visualización de datos
//en la consola
delay(100); Ejercicio:
} E12_LecturaPotenciómetro
E12_LecturaPotenciómetroMapeado
E12_LecturaPotenciometroConstrain
Ejercicio
Se requiere hacer parpadear un LED con el parpadeo controlado por un potenciómetro
/*
Leer una entrada análoga y varía la velocidad de parpadeo de un LED
en función del valor leído, luego de girar el potenciómetro.
*/
#define LED 7 //Llamamos al pin 7 LED

#define POT A0 //Llamamos al pin A0 pot
//Creamos una variable para almacenar el valor del potenciómetro

int lectura = 0;
void setup(){
pinMode(LED, OUTPUT);
}
void loop(){
//leemos el pin del potenciómetro
lectura = analogRead(POT); // El valor leído está comprendido
// entre 0 y 1023
digitalWrite(LED, HIGH);
//Esperamos un tiempo equivalente al valor del potenciómetro
delay(lectura);
digitalWrite(LED, LOW);
delay(lectura);
}
Ejercicio Vúmetro
Se necesita diseñar un sistema de señalización en función del

voltaje muestreado por el PINA3 del Arduino.
El rango es:
0v < Valor <= 1v // Leds apagados
1v < Valor <= 2,2v // Led verde encendido
2,2v < Valor <= 3,6v // Led verde y amarillo encendido,
3,6v < Valor <= 4,6 // Led verde,- amarillo y rojo encendido
4,6v < Valor <= 5v // Todos los Leds parpadean
// Parpadear un LED a una tasa definida por un valor analógico
int LED = 3; // Ponemos el LED en el pin 3

int val = 0; // Variable usada para almacenar el valor analógico que
viene del sensor
void setup() {
Serial.begin(9600);
// Nota: Los pines Análogos están predispuestos como entradas

//por omisión por lo que no hay que prefijarlos
}
void loop() {
val = analogRead(A0); // Lee el valor del pin 0 (análogo)
digitalWrite(LED, HIGH); // Enciende el LED
delay(val); // Detiene el programa por un tiempo
digitalWrite(LED, LOW); // Apaga el LED
delay(val); // Detiene el programa por un tiempo
Serial.println(val);
}
Ejercicio:
E12_SensorAnalogicoFotoresistenciaDigital
Actuadores
Es un dispositivo capaz de ejecutar y/o recibir una orden del

controlador y realizar una acción sobre un aparato o sistema
(encendido/apagado, subida/bajada, apertura/cierre, etc.).
Salidas Analógicas
Salida Analógicas:
Cuando queremos realizar algo mas que

simplemente encender o apagar un
elemento, es decir, generar un voltaje de
salida variable
Ejemplos:
Cambiar el brillo de un LED
Control de la velocidad de un motor DC
Generar tonos
Servomecanismos
Pines o Patas de Salidas Analógicas - PWM
La PWM o Modulación por Ancho de Pulso, es una técnica que permite obtener
resultados de salidas análogas usando medios digitales.
ARDUINO – Salidas Análogas
Instrucción
PWM: Modulación por ancho de Pulso - analogWrite(pin,valor)
- Valor entre 0 y 255
Voltaje Efectivo
Voltaje Efectivo
D = t/T Ciclo de Trabajo
Es una señal rectangular formada por pulsos de

frecuencia constante de aproximadamente
de 490 Hz.
ARDUINO – Efecto dimmer
Ejercicio:
// Efecto dimmer con un LED E14_EfectoDimmerConLED
int LED = 3; // Se usa el pin 3 PWM

int i = 0; // Se usa para llevar un contador
// ascendente y descendente
void setup() {
}
void loop(){
for (i = 0; i < 255; i++) { // loop de 0 to 254 (fade in)
analogWrite(LED, i);
delay(10);
}
for (i = 255; i > 0; i--) { // loop de 255 to 1 (fade out)
analogWrite(LED, i);
delay(10);
}
}
// Fijar el brillo del LED en función al valor de la entrada analógica
int LED = 3; // Pin donde se coloca el LED

int val = 0; // Variable para almacenar el valor del sensor
void setup() {
Serial.begin(9600);
pinMode(LED, OUTPUT); // Se fija el pin del LED como salida
}
void loop() {
val = analogRead(0); // lee el valor del sensor a través de
// analogRead() y retorna un número
// entre 0 y 1023
Serial.println(val);
val = map(val,0,150,0,255);
analogWrite(LED, val); // Ajusta el brillo del LED al brillo fijado por

// el sensor
// analogWrite() acapta un maximo de 255
delay(100); // detiene el programa por un tiempo

}
Ejercicio:
E14_SensorAnalogicoFotoresistenciaAnaloga
LED RGB - Semiconductores
LED RGB - Semiconductores
Teoría del Color

Si fijamos el brillo de los 3 LEDs igual, el color que tendríamos es el blanco.
Controlando cada uno de los LEDs de

colores en forma independiente,
hacemos posibles las diferentes
tonalidades de color.
Así como el blanco el brillo de los 3

LEDs en conjunto, el negro es la
ausencia de todos los colores, de
modo que para producir negro
apagamos los tres colores.
LED RGB - Creando funciones
Ejercicio:
E15_LED_RGB
Funciones en Arduino
/* LEDs RGB LED */
int redPin = 11;

int greenPin = 10;
int bluePin = 9; Ejercicio:
E15_LED_RGB
//Si el LED es Anodo comun quite el comentario de
// esta linea
//#define COMMON_ANODE
void setup(){
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);
}
void loop(){
setColor(255, 0, 0); // red
delay(1000);
setColor(0, 255, 0); // green ….
delay(1000); void setColor(int red, int green, int blue){
setColor(0, 0, 255); // blue #ifdef COMMON_ANODE
delay(1000);
red = 255 - red;
setColor(255, 255, 0); // yellow
delay(1000); green = 255 - green;
setColor(80, 0, 80); // purple blue = 255 - blue;
delay(1000); #endif
setColor(0, 255, 255); // aqua
delay(1000); analogWrite(redPin, red);
}
analogWrite(greenPin, green);
….
analogWrite(bluePin, blue);
Los colores usados en INTERNET
Ejercicio:
LED_RGB
En el código colores #4B0082 lo que tenemos

es una representación de 3 pares de valores:
4B 00 82. Cada par representa la intensidad
que queremos para cada LED RGB, es decir
queremos 4B para el RED, 00 para el GREEN y
82 para el BLUE. Estos números se
representan en formato hexadecimal.
Para usarlos en nuestra función debemos

indicar el número en formato hexadecimal, es
decir,
setColor(0x4B, 0x0, 0x82);
Relé – Relay - Relevador
Manejo de Carga con Relés
Voltaje de la bobina:
• AC / DC
• Voltios
Electrónica – Semiconductores
NPN
PNP
Manejo de Carga
Carga
Motores, Solenoides,
Bombillos,
Manejo de Carga con Relés
Motor DC
ARDUINO – Motores DC
// Variar la velocidad de un motor
int Motor = 3; // Se usa el pin 3 PWM

int i = 0; // Se usa para llevar un contador
// ascendente y descendente
void setup() {
pinMode(Motor, OUTPUT);
}
void loop(){
for (i = 0; i < 255; i++) { // loop de 0 to 254 (fade in)
analogWrite(Motor, i); // fija la velocidad
delay(10);
}
for (i = 255; i > 0; i--) { // loop de 255 to 1 (fade out)
analogWrite(Motor, i); // fija la velocidad
delay(10);
}
}
Ejercicio:
E16_MotorDC Fundamentos de ARDUINO
ARDUINO – Motores DC
/* Motor DC */
int motorPin = 3;
void setup(){
pinMode(motorPin, OUTPUT);
Serial.begin(9600);
}
void loop(){
if (Serial.available()){
int speed = Serial.parseInt();
// La velocidad debe ser entre 0 y 255

if (speed >= 0 && speed <= 255){
analogWrite(motorPin, speed);
}
}
}
Ejercicio:
MotorDCVelocidad
Motores DC
/* Velocidad del Motor DC controlada por un

potenciómetro*/
int motorPin = 03;

int velocidad = A0;
void setup(){
pinMode(motorPin, OUTPUT);
}
void loop(){
// velocidad toma un valor de 0 a 1023

velocidad = analogRead(velocidad);
// La velocidad debe ser un valor entre 0 y 255

velocidad = map(velocidad,0,1023,0,255);
analogWrite(motorPin, velocidad); Ejercicio:

E16_MotorDCPotenciometro
}
Motores DC – Puente H
Motores DC – Puente H
Servomotores
Un servomotor (también llamado servo) es

un dispositivo similar a un motor de
corriente continua que tiene la capacidad
de ubicarse en cualquier posición dentro
de su rango de operación, y mantenerse
estable en dicha posición.
Servomotores
Servomotores DC
/* Servomotores */
#include <Servo.h>
int servoPin = 9;
Servo servo;
int angle = 0; // Posición del servo en grados
void setup(){
servo.attach(servoPin);
}
void loop(){
// Realiza un barrido desde 0 hasta 180 grados
for(angle = 0; angle < 180; angle++){
servo.write(angle);
delay(15);
}
// Realiza un barrido desde 180 hasta 0 grados
for(angle = 180; angle > 0; angle--){
servo.write(angle);
delay(15);
}
} Ejercicio:
E17_ServoMotor
ARDUINO – Servomotores
/* Controlar la rotación de un servo con un potenciómetro*/
#include <Servo.h>
Servo myservo; // Crear el objeto servo
int potpin = 0; // Pata análoga para controlar el servo

int val;
void setup(){
myservo.attach(9); // Colocar el servo en la pata 9
}
void loop(){
val = analogRead(potpin);
val = map(val, 0, 1023, 0, 180);
myservo.write(val);
delay(15);
}
Ejercicio:
E17_ServomotorPotenciometro
Servomotores
NOTA:
Los servos pueden
producir
comportamientos
erráticos cuando están
conectados a algunos
puertos USB.
Usualmente se corrige
con un condensador
mayor de 470uF.
ARDUINO – Buzzer
void setup () {
pinMode (8, OUTPUT); // Pin al que está
// conectado
// el zumbador
}
void loop () {
digitalWrite (8, HIGH);
delayMicroseconds (1000);
digitalWrite (8, LOW);
delayMicroseconds (1000);
}
Ejercicio:
E18_Buzzer1
E18_Buzzer2
E18_BuzzerSirena
ARDUINO – Melodía
*/
#include "pitches.h"
// notes in the melody:

int melody[] = {
NOTE_C4, NOTE_G3,NOTE_G3, NOTE_A3, NOTE_G3,0, NOTE_B3,
NOTE_C4};
// note durations: 4 = quarter note, 8 = eighth note, etc.:

int noteDurations[] = {
4, 8, 8, 4,4,4,4,4 };
void setup() {
// iterate over the notes of the melody:
for (int thisNote = 0; thisNote < 8; thisNote++) {
// to calculate the note duration, take one second

// divided by the note type.
//e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
int noteDuration = 1000/noteDurations[thisNote];
tone(8, melody[thisNote],noteDuration);
// to distinguish the notes, set a minimum time between them.

// the note's duration + 30% seems to work well:
int pauseBetweenNotes = noteDuration * 1.30;
delay(pauseBetweenNotes);
// stop the tone playing:
noTone(8); Ejercicio:
} E19_Melodía 1
}
void loop() {
// no need to repeat the melody.
Termistores
Son sensores de temperatura resistivos donde la el elemento sensor

cambia su resistencia de acuerdo con las variaciones de temperatura.
Existen dos tipos de termistor, aquellos cuya resistencia aumenta en

función de la temperatura, también llamados PTC ( Positive Temperature
Coefficient ) y aquellos cuya resistencia disminuye conforme aumenta la
temperatura, llamados NTC ( Negative Temperature Coefficient).
El término termistor proviene de Thermally Sensitive Resistor.
Curva típica de un Termistor NTC
ARDUINO – Termistor
/*
Alerta Recalentamiento
El programa convierte la tensión Analógica que cae en el termistor

en un valor digital.
Cuando el valor de tensión toma valores inferiores al umbral, se
ejecuta una rutina de alerta por sonido por medio de un buzzer
*/
int sensor = A0;

int buzzer = 13;
void setup() {
pinMode(buzzer, OUTPUT);
}
void loop() {
while(analogRead(sensor)<60) {
tone(buzzer,1000,500); //Bucle: mientras se mantenga la
temperatura elevada, el micro estará emitiendo sonido por el pin
13
delay(1000);
}
digitalWrite(buzzer,LOW);
} Ejercicio:
E20_Recalentamiento
ARDUINO – Recursos
Scratch for Arduino – S4A
ARDUINO para todos
Gracias
Francisco Di Zonno
+58.414.246.48.25
fdizonno@zonaelectronica.com
fdizonno@gmail.com
@fdizonno

ZonaE. Fundamentos de Arduino Con Aplicaciones Domoticas

Cargado por

Información del documento

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

ZonaE. Fundamentos de Arduino Con Aplicaciones Domoticas

Cargado por

Copyright:

Formatos disponibles

Fundamentos de ARDUINO

Aplicados a la domótica y los automatismos

El término domótica viene de la unión de

La evolución de la Domótica es la consecuencia

La electricidad nos ha permitido elevar el nivel

La electricidad ha dado paso a la entrada de los

Lavadoras, Neveras, Lavaplatos, Hornos, Cocinas

Máquinas capaces de realizar tareas cotidianas de forma

1956 aparece un computador con

Jack Kilby, científico de Texas Instruments,

Es el inicio de la era de los computadores,

El conjunto de sistemas y tecnologías capaces de

Videovigilancia en las calles

Una plataforma de Apple

Philips HUE, bombillos LED

Samsung Smart Home

Es una casa conectada a la red y a

Iniciativa Open Source Fundamentos de ARDUINO

El control está en un solo punto.

El control está en varios puntos.

El control está en el mismo dispositivo.

• Firewire (IEEE 1394)

LonWorks: Plataforma estandarizada para el control de edificios, viviendas, industria y transporte.

ZigBee: Protocolo estándar, recogido en el IEEE 802.15.4, de comunicaciones inalámbrico.

XBee. Es el nombre comercial para una familia de Radios de Digi

325 Compañías. 1350 productos.

http://z-wavealliance.org/ Fundamentos de ARDUINO

The worldwide STANDARD

La pregunta es ¿Cuáles son las

IPv4 posibilita 4.294.967.296 (232) direcciones de red

Dispositivo electrónico capaz de procesar la información (datos)

Es el encargado de realizar las

Este se utiliza para controlar el

Memoria volátil de poca capacidad pues sólo debe contener el

ROM con máscara Memoria no volátil de sólo lectura cuyo

Lenguaje de Alto Nivel

Muchos fabricantes de microcontroladores ofrecen herramientas

1.- Área para escribir el código “fuente”.

PICAXE Editor Fundamentos de ARDUINO

 Tener una idea clara de lo que se quiere

La idea principal de escribir un programa

Tareas – Pasos – Algoritmo:

Procesar la información recibida

Interactuar o “actuar” con el

Arduino es una plataforma de

Software libre Hardware libre

La plataforma Arduino se ha convertido en popular entre las personas

- No necesita un hardware especial (programador) para cargar el

El hardware y software de Arduino fue diseñado para artistas,

Arduino nació como un proyecto

Massimo Banzi y David Cuartilelles querían desarrollar una tarjeta de prototipos

Subsistir ante el eminente cierre del Instituto de diseño Interactivo IVREA en

Para su creación participaron alumnos que desarrollaban sus tesis como

1. Conseguir un Arduino y un cable USB

Los programas en Arduino se llaman SKETCHs

VisualMicro – Entorno para

• Programino: http://programino.com/ (de pago)

Los programas son

int ledPin = 13; // Esto también es un comentario

unsigned char contador; // Define una variable llamada contador

Instrucciones, Sentencias o Comandos:

Se puede llamar a una función

Las funciones pueden o no