1

ARDUINO

PLACA ARDUINO

La placa Arduino esta compuesta por diferentes pines que cumplen las distintas funciones.

● VIN: es la entrada de alimentación cuando se usa una fuente externa

● 5V : es el suministro de energía usado para alimentar al microcontrolador a través de la
conexión USB u otro suministro.
● 3.3 V : esun suministro de 3,3 V generado por el chip FTDI, tiene una correinte máxima de 50
mA.
● GND: Pines de tierra ( en la placa nano la polaridad del gnd digital y analogico estan
invertidos )
● ENTRADAS Y SALIDAS : Tiene 13 pines digitales que pueden ser usados como entradas o
salidas , usando funciones pinMode, digitalWrite, y digitalRead, operan a 5 V, puede
proporcionar o recibir un máximo de 40 mA y tiene una resistencia interna pullup, lo que
signfica que por defecto esta desconectada
● PINES DE FUNCIONES ESPECIALES:
a) Serial: 0 (Rx) y 1 (Tx) , usados para recibir (Rx) y transmitir (Tx) datos TTL ( entre
transistores, logica transistor a transistor TTL)
b) PWM : 3,5,6,9,10 y 11, proporciona salidas PWM de 8 bits , estas permiten simular salida
analógicas para poder controlar, leds , motores . La señal analógica se comporta como la
correinte alterna variando constantemente los valores ( onda sinusoidal) de esta manera la
salida PWM varia la onda para generar esa variación y simular esa salida analógica ,
variando de 0 a 5 V
● LED 13: este pin tiene un led empotrado cuando el pin esta a valor HIGH (1) esta encendido
si esta en valor LOW (0) está apagado.
● AREF: básicamente lo que hace es limitar la tensión , por ej si estamos trabajando con un
sensor de temperatura, la medición de temperatura se debe convertir en una señal eléctrica ,
2

Arduino va a necesitar una tensión externa de referencia para poder “leer” esa señal,
entonces si por ejemplo estoy trabajando con el sensor cuya tensión máxima es 1,5 V , si
toma como referencia 5 V será muy imprecisa la medición entonces AREF nos permite
establecer ese valor máximo de referencia para poder mejorar la lectura del sensor.

protoboard

ESTRUCTURA DE PROGRAMACIÓN:

La programación en Arduino conta de 3 bloques

1° Declaración de variables , se indica los pines que se van a utilizar

2° void setup (): es la fución encargada de recoger la información, se invoca solo una vez cuando se
inicializa el programa, se utiliza para inicializar los modos de trabajo de los pins , indica si el pin
usado es una entrada o una salida, configura la comunicación etc.
3° void loop () : en la función bucle se establece que es lo que quiero hacer en el programa, por ej
que encienda o apague un led, que funcione un motor, que lea un sensor y actue en consecuencia ,
etc , es ciclico , estas funciones pueden estar incluidas en void setup, pero la función que realice se
llevará a cabo sólo una vez , en cambio con el loop se repite infinitamente

● FUNCIONES: son las encargadas de realizar tareas, setup y loop son dos funciones pero no
son las unicas , las funciones tienen un nombre y un conjunto de estamentos que se ejecutan
al llamarse la función, la estructura de la funcion es la siguiente

type nombre de la función(parámetros)

{
estamentos;
}

type es la funcion con la que se trabaja, el nombre de la función es el mismo nombre con que
se la definio y los parametros son las condiciones a cumplir por ejemplo en la función void
setup lo que se hace es definir que es cada pin , por eso el type es void ( que significa vacio,
ya que no va a devolver ningun valor sino que va a ejecutarse ) el nombre de la función es
setup y el parametro al ser vacio se coloca (), por eso la función setup se escribe
3

void setup ( )

● ENTRE LLAVES {}
las llaves indican el principio y el final de una función, siempre se debe colocar al inicio de los
estamentos y al finalizarlos, siempre que se inicia una funcion se coloca llave y cuando se
termina se cierra la llave, caso contrario el programa dara error
● PUNTO Y COMA ;
Se utiliza para separar lineas de programación cada vez que se finaliza una linea se coloca ;
● BLOQUE DE COMENTARIOS: // se indica con dos barras permiten comentar cada linea de
programación para hacer aclaraciones o visibilizar para el programador referencias, al
colocar // el programa ignora lo que se escribe a continuacion de las mismas
● VARIABLES:
es una manera de nombrar y almacenar un valor numérico para su posterior uso , es por eso
que se inicia la programación declarando variables ya que nos indicara que datos se
almacenan y que pin se utiliza. La variable será global si se puede usar por cualquier función,
por eso se declara al principio del programa ya que se utlizara dentro de void setup y/o void
loop. La variable sera local si solo puede ser utilizada dentro de la función por ejemplo si
defino la variable dentro de void loop , esa variable no se puede usar en void setup.

Tipos de varibles

int: variable entero, son datos primarios que almacenan valores enteros, estos valores pueden ir
entre 32767 y – 32768, ej
int numero = 1500;

byte : almacena un valor numerico de 8 bits sin decimales, tiene un rango de entre 0 y 255 en
decimal o 00000000 hasta 11111111( Con 8 bits se pueden representar 28 caracteres, lo que en decimal equivale a 256
combinaciones posibles, desde el 0 hasta el 255.)
ej
byte numero = 180
long: se refiere anumeros enteros extendidos va desde -2147483648 hasta 2147483647 ( 2 32)

ej
long numero = 10254

CONSTANTES
Son valores predeterminados, se usan para hacer los programas mas fáciles de leer

● CIERTO/FALSO ( TRUE/FALSE): Son variables que se asocian a 1 ( true ) y 0 ( false), por

ejemplo se usa con el condicional if , o sea si se cumple una condicion ( true) pasa tal cosa (
si se conecta el pulsador, se enciende la lampara)
● HIGH / LOW : definen los niveles alto y bajo ( alta tension = 1 ) , (baja tensión = 0)
● INPUT/OUTPUT: Definen el modo de funcionamiento de los pines , indican si es una entrada
o una salida
4

● IF: indica si una determinada condición se ha alcanzado, por ejemplo determinar si un valor
analógico esta por encima de cierto numero

if ( a>2)
{ instrucción de que debe pasar
}

● IF …. ELSE ( SI ….. SINO…): Es una estructura que se ejecuta en respuesta a la idea “ si

esto no se cumple se hace esto otro” ej

if ( a > 2 )
{ insrrucción que debe pasar
}
else
{ instrucción que pasa “sino”
}

● FOR: se usa para repetir un bloque de sentencias encerradas entre llaves un número
determinado de veces, la declaracion for tiene 3 partes , la inicialización, que indica de donde
se parte, la condición que se testea cada vez que se termina la ejecución del bucle, y la
expresión que inndica que se debe hacer
for ( inicializacion, condicion , expresion)

ej determinar si un valor es menor a 20

for ( i=0 ; i< 20, i ++)
{
}

i=0 indica del valor de partida

i < 20 indica la condición que debe cumplir ( es menor a 20?)
i ++ , indica que al valor inicial se le suma 1 , y luego 1 mas , y luego 1 mas …..
5

● WHILE: Es un bucle de ejecución continua, mientras se cumpla la condición colocada entre

paréntesis se realizara tal cosa , por ejemplo mientras un valor sea < 20 el robot avanza
While ( a<20)
{ instrucciones
}

pinMode(pin,mode):
se usa en setup y sirve para configurar el modo de trabajo de un pin, o sea se indica si es una
entrada o una salida, pudiendo ser input u output ( entradas o salidas)

pinMode(pin, OUTPUT)

digitalRead(pin): lee el valor de un pin ( lee los valores de una entrada por ejemplo un sensor)

digitalWrite(pin, value): envia al pin determinado como salida el valor high o low , se us apor
ejemplo en un motoral que se le manda una señal
digitalWrite(pin,HIGH)

analogRead(pin): lee el valor de un pin analógico ( lee los valores de una entrada de los pines de
0 a 5 puede oscilar entre 0 a 1023)

analogWrite(pin, value): escribe un pseudo valor analógico usando el procedimiento de

modulación por ancho de pulso (PWM) a uno de los pins de arduino
ejemplo
analogWrite(pin,valor)

delay(ms): detiene la ejecución del programa la cantidad de tiempo en ms que se indica en la

propia instrucción ( 1000ms equivale a 1 seg)
delay(1000);

PRÁCTICAS
6

si la placa arduino no carga el scketch , revisar que la placa usada

sea la correcta ( nano, mini uno) que sea el procesador el correcto
(328 , 168, oldBootloader) y el puerto com

ejemplos de programación

1) programar un led que se encienda y apague en forma intermitende cada 2 segundos

int led = 5;
void setup(){
pinMode(led, OUTPUT); //se define el pin como salida
}
void loop()
{
digitalWrite(led, HIGH); //indica que el led se enciende
delay(2000);
digitalWrite(led, LOW); delay(2000);
}

2) programar dos led que se enciendan y apaguen simultaneamente cada 2 segundos

7

int led1=3;
int led2=4;
void setup()
{
pinMode(led1,OUTPUT);
pinMode(led2,OUTPUT);
}
void loop()
{
digitalWrite(led1,HIGH);
digitalWrite(led2,HIGH);
delay(2000);
digitalWrite(led1,LOW);
digitalWrite(led2,LOW);
delay(2000);
}

3) encender dos leds en forma intermitente

int led1=3;
int led2=4;
8

void setup()
{
pinMode(led1,OUTPUT);
pinMode(led2,OUTPUT);
}
void loop()
{
digitalWrite(led1,HIGH);
delay(2000);
digitalWrite(led1,LOW);
delay(2000);
digitalWrite(led2,HIGH);
delay(2000);
digitalWrite(led2,LOW);
delay(2000);
}
9

4) hacer la programación de un semaforo

int rojo=6; //se definen donde se conectan los leds con salidas
int amarillo=7;
int verde=8;
void setup() { //se definen las salidas
pinMode(rojo,OUTPUT); // se define al led como salida que prende
pinMode(amarillo,OUTPUT);
pinMode(verde,OUTPUT);
digitalWrite(rojo,LOW); // indica que empiezan apagados los leds
digitalWrite(amarillo,LOW);
digitalWrite(verde,LOW);
}
void loop(){ //funcionamiento
digitalWrite(rojo,HIGH);
delay(4000);
digitalWrite(rojo,LOW);
digitalWrite(amarillo,HIGH);
delay(2000);
digitalWrite(amarillo,LOW);
digitalWrite(verde,HIGH);
delay(4000);
digitalWrite(verde,LOW);
digitalWrite(amarillo,HIGH);
delay(2000);
digitalWrite(amarillo,LOW);
}
10

5) encendido de led con un pulsador

en este caso se usa el comando if , porque si esta apretado circula corriente entonces se enciende
el led, sino esta apretado no circula corriente y el led esta apagado, el pulsador es una salida
entonces se usa digitalRead , el led es una entrada entonces se usa digitalWrite. Como se quiere
determinar si esta o no circulando corriente se usa la condicion de comparacion entonces se indica
if(digitalRead==HIGH) para saber si esta o no circulando corriente

(rojo 5v negro gnd)

se comienza indicando las conexiones

int led = 3;
int pulsador = 2;

void setup () {

pinMode (pulsador , INPUT) ; // indico que el pulsador es una entrada

11

pinMode (led, OUTPUT); // indico que el pulsador es una salida

}

void loop () {
if ( digitalRead (pulsador) ==HIGH) // se compara a ver si hay o no en este caso el pulsador
tensión tiene dos opciones, que
usando == ( esta es la este en 0V (LOW) o que
condición este en 5V ( HIGH) si el
verdadera ) pulsador esta apretado
{ digitalWrite(led ,HIGH); // se indica que el led se debe encender circula corriente ( HIGH) y
al si no esta apretado no
pulsar (condicion verdadera) circula (LOW)
}
para que funcione se usa
else { la funcion if (si) lo que
digitalWrite(led ,LOW) ; // se indica que si no esta pulsado se hace esta función es
apaga comparar si la tensión es
} alta (HIGH) o baja ( LOW)
primero se indica la
} condicion verdadera y se
indica que debe suceder
para el caso de que sea
verdadera y luego se
coloca else (sino) para
determinar que debe
ocurrir si la condicion no
es asi

6) con un pulsador cambiar el estado actual del led ( de encendido a apagado y viceversa)
como si fuera un pulsador con retencion ( SE PULSA Y EL LED QUEDA ENCENDIDO, SE
VUELVE A PULSAR Y SE APAGA )

while : ( mientras) si la condicion establecida es verdadera ejecuta todo lo que este dentro de el si
es falso hace la otra condicion

int led = 3;
int pulsador = 2;
int ESTADO = LOW ;// se comienza con led apagado

void setup () {
pinMode (pulsador , INPUT) ; // indico que el pulsador es una entrada
pinMode (led, OUTPUT); // indico que el pulsador es una salida
12

}
void loop () {
while ( digitalRead (pulsador) ==LOW) // si el valor es bajo no hace nada
ESTADO = digitalRead (led); // verifica si el led esta encendido o apagado
digitalWrite(led,!ESTADO); // !niega la variable (not) o que hace es cambiar al opuesto
while(digitalRead(pulsador)==HIGH){ //impide el rebote del pulsador
}
}

7 ) programación variar led con potenciometro y sin potenciometro de manera que al llegar al
maximo valor de luminosidad luego comience a diminuir la misma hasta apagarse

digitalWrite : la salida digital tiene dos valores 0 y 5 V en digital son las únicas dos posibilidades 0
o 5V , si queremos hacer que varie desde un valor a otro y que pase por todos los valores debemos
usarlo en forma analógica y para ello se agrega un potenciómetro para regular el valor entre 0 y 5 V
13

cuando programamos el digitalWrite lo que hace es mandar tensión durante un determinado tiempo
y luego deja de enviar y viceversa por ejemplo quedando el grafico de arriba.

Un

potenciometro (PWM, modificación de ancho de pulso) lo que hace es modificar el ciclo de trabajo
se tiene un ciclo de trabajo del 20% o sea 1V , el segundo un 50% o sea 2,5 V y el tercero un 80% o
sea 4 V asi se cambia la tensión al valor deseado y eso hace por ejemplo que cambie la
luminosidad de un led .
En la placa arduino no todos los pines digitales se pueden conectar al potenciómetro los que
pueden conectarse estan indicados con un símbolo ~

a) con potenciometro
para el pote se usa A0
14

int led = 3 ;
int brillo;
int pote = 0; // como es una entrada analógica no necesita definirlo en void setup

void setup () {
pinMode ( led, OUTPUT);
}
void loop () {
brillo = analogRead (pote)/4; // se indica que el brillo se regula con la entrada analogica del pote
analogWrite(led,brillo); // se indica que el led cambiara su brillo con el potenciometro
}

se usa analog porque debe tomar valores analógicos ya que son los que permiten variar en toda
su extension de un intervalo y así al variar la tensión varía la luminosidad del led, el digital solo
puede ir de un extremo a otro por ej 0 o 5V en cambio el analógico va de 0 a 5V pasando por todos
los valores intermedios , el valor que puede tomar en la placa arduino es de 0 a 255 donde 0 es
0V y 255 es 5V, por ejemplo si quiero trabajar con una tensión máxima de 2,5V tomare como valor
maximo 127 ya que 2,5 es la mitad de 5 y 127 de 255, hago un proporcional para cada Voltaje
las variables analógicas trabajan con valores de 0 a 1023, pero analog write trabaja con
valores de 0 a 255 esto hace que no se puede usar ese valor entonces para poder hacerlo se
divide por 4 el valor de analogRead que es lo que lee el potenciometro asi al hacer 1023 /4 =
255,75 entonces al trabajar con enteros se toma ese valor 255 asi al divido por 4 tendre la
variable dada por analog read dentro del rango de trabajo del analogWrite

b) sin potenciometro

int led = 3 ;
int brillo;

void setup () {
pinMode ( led, OUTPUT);
}
void loop () {
for ( brillo = 0 ; brillo < 256 ;brillo ++ ) {
analogWrite (led,brillo); // el led ira aumentando el brillo de brillo 0, el siguiente 1 asi hasta 255
delay (15);

for ( brillo = 255 ; brillo >= 0 ;brillo -- ) {

analogWrite (led,brillo); // el led ira disminuyendo el brillo de brillo 255, el siguiente 254 asi hasta
0
delay (15);
}
15

se usan dos for en este caso debido a que se quiere que aumente el brillo y despues cuando llegue
al maximo disminuya de lo contrario al llegar al maximo valor se apagaria y volveria a empezar de 0

For: permite repetir un bloque en base a una condición una determinada cantidad de veces.
Requiere de tres parametros el primero es el valor inicial de la variable por ejemplo 0 el segundo
parámetro es el valor verdadero que debe cumplir si esto se cumple entonces ejecuta la accion que
le indicamos entre llaves y el tercero nos indica en el siguiente bucle en cuento tiene que aumentar
la variable inicial por ejemplo en un led se pone
for (brillo =0 ; brillo <256; brillo ++)

1° parametro 2° parametro 3° parametro

valor del que parte valor que debe cumplir ( no puede ser mas de 5v) condicion

el comando for empieza por el valor del primer parametro analiza si se cumple la del segundo
parametro y si se cumple continua con lo que indica el tercer parametro sino sale , en el ejemplo
empieza de 0 V despues se fija si el valor es menor a 255 (5v ) y si es verdadero al primer valor le
aumenta 1

SENSOR ULTRASÓNICO

emite una

frecuencia de 400 khz , que al rebotar y devolver la onda de sonido permite indicar la distancia, es
un sensor activo porque tiene que estar conectado para poder usarse, tiene 4 pines Vcc y GND son
las conexiones de alimentación Trg es el pin al que se le envia una señal para el pulso ultrasonico y
16

echo recibe la señal de vuelta trg ( triger ) y echo van conectados a pines digitales mientras que
Vcc va a 5V

8) encender una luz de emergencia cuando un sensor detecte la cercania con un objeto
esquema de conexionado

cuando se trabaja con un sensor ultrasónico se deben definir las variables, estas en nuestro
ejemplo serán el led, el sensor ( que tiene dos conexiones digitaes trg y echo) y dos datos que se
deben considerar distancia y duracion de la señal

int TRIG = 10; // trigger en pin 10

int ECO = 9; // echo en pin 9
int LED = 3; // LED en pin 3
int DURACION;
int DISTANCIA;

despues se indica que es cada una ( entrada o salida)

void setup()
{
pinMode(TRIG, OUTPUT); // trigger como salida
pinMode(ECO, INPUT); // echo como entrada
pinMode(LED, OUTPUT); // LED como salida
Serial.begin(9600); // inicializacion de comunicacion serial a 9600 bps
17

en el void loop primero se le debe indicar al programa el tiempo en el cual el sensor debe emitir la
señal, estos tiempos varian de acuerdo al fabricante del sensor en el caso de los nuestros es 1 ms
por eso se debe indicar ese tiempo de encendido, por eso usamos digitalWrite ya que nos permite
encenderlo 1ms que emita la señal y luego apagarlo

void loop() {
digitalWrite(TRIG, HIGH); // encendemos el sensor
delay(1);
digitalWrite(TRIG, LOW); // lo apagamos

despues se debe tomar el tiempo que tarda en responder ya que de acuerdo a el sera la distancia
entonces ahi usamos la variable duración en esta se una la fcion pulseIn y trabaja con echo porque
es el pin que recibe la señal de vuelta y HIGH porque espera tensión alta, luego se determina con
ese tiempo de respuesta la distancia a la que se encuentra el objeto, para ello se usa la variable
distancia que sera el tiempo / 58.2 que es una contante del sensor ( dada por el fabricante)

por eso ponemos

DURACION = pulseIn(echo, HIGH); // indica el tiempo de respuesta

DISTANCIA = DURACION / 58.2; // distancia que recorre elsonido de vuelta
Serial.println(DISTANCIA);
delay(200); //se agrega para ver el valor sino sería muy rapida la medicion y no se
obsrvaria
if (distancia <= 20 && distancia >=0) { // indico que si el valor es mayor a 0 y menor a 20
digitalWrite(led, HIGH);
delay(distancia*10); // de esta manera a menor distancia mas rapido parpadea ponemos por 10
para observarlo
digitalWrite(led,LOW);
}
como no tenemos dispositivo de visualizacion se puede observar en el programa arduino la
distancia que detecta el sensor usando el comando serial, este se colocara como parámetro en void
setup colocando Serial.begin(9600) y en void loop Serial.println(distancia)

para encender el led se puede usar if por ej si detecta menos de 20 cm se enciende el led

programa completo

int TRIG = 10; // trigger en pin 10

int ECO = 9; // echo en pin 9
int LED = 3; // LED en pin 3
int DURACION;
int DISTANCIA;

void setup()
{
pinMode(TRIG, OUTPUT); // trigger como salida
pinMode(ECO, INPUT); // echo como entrada
pinMode(LED, OUTPUT); // LED como salida
Serial.begin(9600); // inicializacion de comunicacion serial a 9600 bps
18

void loop()
{

digitalWrite(TRIG, HIGH); // generacion del pulso a enviar

delay(1); // al pin conectado al trigger
digitalWrite(TRIG, LOW); // del sensor

DURACION = pulseIn(ECO, HIGH); // con funcion pulseIn se espera un pulso

// alto en Echo
DISTANCIA = DURACION / 58.2; // distancia medida en centimetros
Serial.println(DISTANCIA); // envio de valor de distancia por monitor serial
delay(200); // demora entre datos

if (DISTANCIA <= 20 && DISTANCIA >= 0){ // si distancia entre 0 y 20 cms.

digitalWrite(LED, HIGH); // enciende LED
delay(DISTANCIA * 10); // demora proporcional a la distancia
digitalWrite(LED, LOW); // apaga LED
}

9) Funcionamiento de servomotores AUTOMATICO

naranja: señal( se conecta al pin digital) , rojo vcc, negro gnd,

19

el servo permite un movimiento de giro de 180°, si se le envia una señal durante 20 ms y un pulso
de 1 ms indica 0° si se envia un pulso de 2 ms se le indica que gire 180° cualquier valor intermedio
da el resto de los angulos entre ellos
Cuando se trabaja con servomotores se debe alimentar en forma externa ya que la tension que
suministra el cable usb de la computadora no es suficiente para que funcione el servomotor.

Los valores deben ser de 7,5 a 12 V

y hasta 750 mA

para usar los servomotores arduino tiene una librería, esta librería es un conjunto de funciones que
se pueden usar en el codigo, para usarla se coloca

#include <Servo.h>
Servo servo1; // esto crea un objeto tambien puedo llamarlo por ej motor 1 entonces pongo
Servo motor1

luego ponemos el pin donde vamos a conectar el servo y el valor de pulso mínimo y máximo del
servo, estos valores si bien son 1 ms y 2 ms , no puedo ponerlo en esa unidad ya que se generaria
una redundancia con el valor del pin entonces se pone como 1000 y 2000 respectivamente ya que
se expresa en microsegundos

int pinservo = 2;
int pulsominimo = 1000; // equivale a 0 °
int pulsomaximo = 2000; // equivale a180°

para controlar el servo se usa la función attach, esta permite inicializar el servo , la funcion tiene tres
variables la primera el pin donde se conecta el servo, la segunda el valor de pulso minimo y la
tercera el valor de pulso maximo, quedando

void setup() {

servo1.attach(pinservo,pulsominimo,pulsomaximo);
}

en este caso se utiliza la función write para indicarle la posición en la que se debe ubicar el servo

void loop() {
servo1.write(0);
delay(5000);
servo1.write(180);
delay(5000);
}
20

el codigo queda entonces

#include <Servo.h>
Servo servo1; // esto crea un objeto tambien puedo llamarlo por ej motor 1 entonces pongo
Servo motor1
int pinservo = 2;
int pulsominimo = 1000; // equivale a 0 °
int pulsomaximo = 2000; // equivale a180°
void setup() {

servo1.attach(pinservo,pulsominimo,pulsomaximo);
}
void loop() {
servo1.write(0);
delay(5000);
servo1.write(180);
delay(5000);
}

si el angulo que se desplaza el servo no es de 180° se debe variar los valores de pulso maximo y
minimo hasta encontrar el adecuado para ese motor ( el valor es 700, 2350 )

motores funcionando con potenciometro

se agregara un potenciometro que nos va a permitir mover el servo, como el pote va a ir conectada
a salida analogica no es necesario definirlo pero si se va a definir una variable para que lea al
potenciometro ( valorpot) el angulo que tiene que moverse el servo y el valor inicial del pote o sea 0

#include <Servo.h>
Servo servo1;
int pinservo = 2;
int pulsominimo = 1000; // equivale a 0 °
int pulsomaximo = 2000; // equivale a180°
int valorpote;
int angulo;
int pote = 0;

void setup() {

servo1.attach(pinservo,pulsominimo,pulsomaximo);
}

en void loop se va a definir la forma como se usa el potenciometro para que haga mover el motor
el valor del pote se debe definir como una entrada analogica por eso al valorpote se la asocia con
analogRead.
21

Para el angulo se usa una funcion llamada map, en esta se convierte la señal analogica en un
rango de angulo valor analogico que lee el potenciometro sera 0 y 1023 y este se convierte en una
rango de 0 a 180 °, este resultado se asigna a la variable angulo y se coloca un delay para darle
tiempo al servo a llegar a su posicion cuanto mas pesado sea el objeto que mueva el servomotor se
debe aumentar este tiempo

void loop() {
valorpote = analogRead(pote);
angulo = map(valorpote,0,1023,0,180)
servo1.write(angulo);
delay(20);

el programa queda asi entonces

#include <Servo.h>
Servo servo1;
int pinservo = 2;
int pulsominimo = 1000; // equivale a 0 °
int pulsomaximo = 2000; // equivale a180°
int valorpote;
int angulo;
int pote = 0;

void setup() {

servo1.attach(pinservo,pulsominimo,pulsomaximo);
}
void loop() {
valorpote = analogRead(pote);
angulo = map(valorpote,0,1023,0,180);
servo1.write(angulo);
delay(20);

10) Varios Motores con varios potenciometros:

#include <Servo.h>
Servo servo1;
Servo servo2;
int pot1=A0;
int pot2=A1;
int valpot1;
int valpot2;
void setup()
{
servo1.attach(3);//pin donde se conecta el servo1
22

servo2.attach(4);//pin donde se conecta el servo2

servo1.write(0);//se indica la posicion inicial del servo
servo2.write(0);
}
void loop()
{
valpot1=analogRead(pot1);//valor que devuelve el servo1
valpot1=map(valpot1,0,1023,0,179);//el valor varia entre 0 y 180 grados el valor anlogico va desde
0 a 1023 digital es 0 a 180
servo1.write(valpot1);
valpot2=analogRead(pot2);//valor que devuelve el servo1
valpot2=map(valpot2,0,1023,0,179);//el valor varia entre 0 y 180 grados el valor anlogico va desde
0 a 1023 digital es 0 a 180
servo2.write(valpot2);
}

11) SENSOR TEMPERATURA Y HUMEDAD

23

CONEXIONADO

en algunos sensores aparece que se debe usar resistencia pull up o pull down esto significa que se
debe conectar al positivo de tension (pull up) o a masa ( gnd, pull down)

estos sensores permiten leer temperatura y/o humedad, se debe utilizar librería pero esta no vienen
descargadas con arduino por eso se debe descargar, para ello se va a programa, incluir librería y
gestionar librería
24

alli se busca el sensor deseado que sera dht ( adafruit ) y se instala con el arduino 1.0.5 se va
sketch y alli importar librería para poder descargarla, primero se debe descargarla en la compu
desde internet y luego se la instala

una vez hecho esto en cualquiera de los dos casos se vuelve a ingresar a sketch ( para 1.0.5, o a
programa en 1.8 ) y se importa la librería que dice DHT unified sensor y se comienza a trabajar

#include <DHT.h>
#include <DHT_U.h>

luego se incluyen las variables del sensor que seran el pin donde se conectan , la temperatura y la
humedad que se quiere leer

int sensor =2 ;
int temeratura;
int humedad;

luego se crea un objeto dht asociada a las funciones del sensor

DHT dht(sensor, DHT11);

se hace el setup para observar las mediciones con el monitor serial

void setup(){
25

Serial.begin(9600);
djt.begin();
}

se hace en el void loop para que lea el sensor temperatura y humedad

void loop() {
temperatura = dht.readTemperature(); // se le pide al sensor que lea la temperatura
humedad=dht.readHumidity(); // se le pide al sensor que lea la humedad
Serial.print(“temperatura: ”); // se pide que muestre la lectura de temperatura
Serial.print(temperatura);
Serial.print(“humedad: ”);
Serial.println(humedad); // con esto se hace un salto de linea
delay(500);
}

el codigo queda

#include <DHT.h>
#include <DHT_U.h>

int SENSOR = 2; // pin DATA de DHT11 a pin digital 2

int TEMPERATURA;
int HUMEDAD;

DHT dht(SENSOR, DHT11); // creacion del objeto, cambiar segundo parametro

// por DHT11 si se utiliza en lugar del DHT22
void setup(){
Serial.begin(9600); // inicializacion de monitor serial
dht.begin(); // inicializacion de sensor
}

void loop(){
TEMPERATURA = dht.readTemperature(); // obtencion de valor de temperatura
HUMEDAD = dht.readHumidity(); // obtencion de valor de humedad
Serial.print("Temperatura: "); // escritura en monitor serial de los valores
Serial.print(TEMPERATURA);
Serial.print(" Humedad: ");
Serial.println(HUMEDAD);
delay(500);
}

12) encender un led cuando la temperatura es superior a x °C

i#include <DHT.h>
#include <DHT_U.h>
26

int SENSOR = 2; // pin DATA de DHT11 a pin digital 2

int TEMPERATURA;
int HUMEDAD;
int led=3;
int led2=5;

DHT dht(SENSOR, DHT11); // creacion del objeto, cambiar segundo parametro

// por DHT11 si se utiliza en lugar del DHT22
void setup(){
Serial.begin(9600); // inicializacion de monitor serial
dht.begin(); // inicializacion de sensor
pinMode(led,OUTPUT);
pinMode(led2,OUTPUT);
}

void loop(){
TEMPERATURA = dht.readTemperature(); // obtencion de valor de temperatura
HUMEDAD = dht.readHumidity(); // obtencion de valor de humedad
float temperatura = analogRead(0);
float milivoltios = ( temperatura / 1023 ) * 5000;
temperatura = milivoltios / 10;
if (TEMPERATURA > 30 && TEMPERATURA < 40) {
digitalWrite(3, HIGH);
digitalWrite(5, LOW);
} else {
digitalWrite(3, LOW);
digitalWrite(5, HIGH);
Serial.print("Temperatura: "); // escritura en monitor serial de los valores
Serial.print(TEMPERATURA);
Serial.print(" Humedad: ");
Serial.println(HUMEDAD);
delay(500);
}
}
27

13) funcionamiento de un RELE

El relé

permite con una tensión de 5 V se puedan abrir circuitos con otras tensiones
Cuando la corriente circula por la bobina se genera un campo electromagnético que mueve el brazo
superior del relé se vincula con el terminal común, cuando no circula corriente el terminal común
esta en contacto con NC si se aplica tensión se genera un campo electromagnético se mueve el
brazo y el terminal común pasa a normal abierto este campo se genera con 5 V y al entrar en
contacto el terminal común con el normal abierto entonces se cierra el circuito.

Módulo Relé
dentro
del módulo
de relé se
tiene
un
28

octoacoplador y alli un led y un transistor, este transistor es fotosensible y funciona cuando el led se
enciende, entonces al circular corriente por el led , se enciende y hace funcionar al transistor, este
enciende el transistor NPN y hace funcionar el relé.
El octacoptador es un elemento de protección ya que como el relé es mecanico puede fallar si esto
pasa puede quemar el transistor pero nunca al led que no tiene contacto con el relé y si con la placa
arduino, entonces si se falla el relé no afecta al arduino.

Esquema de conexión
29

rojo = gnd verde = 5V negro = pin

se indica primero el pin del relé

en void setup se define como salida y en el void loop se enciende por 5 seg el relé
el relé se activa con un nivel bajo y se apaga con un nivel alto

int rele =2;

void setup() {
pinMode(rele, OUTPUT);
}
void loop() {
digitalWrite(rele, LOW);
delay(5000);
digitalWrite(rele, HIGH);
delay(5000);
}
14) encender un led usando un rele

int LedPin = 9;

void setup() {
30

pinMode(LedPin, OUTPUT); //modo salida

void loop() {

digitalWrite(LedPin, HIGH); // Enciende el pin 9

delay(500); // Espera medio segundo

digitalWrite(LedPin, LOW); // Apaga el pin 9

delay(500); // Espera medio segundo

14) programar la clave de una puerta con un TECLADO DE MEMBRANA

realizar la programación de una clave de una puerta

31

Cuando se apreta el botón se cierra el circuito

conexiones

código

cada vez que

se usa el
teclado este
primer grupo
de fila siempre
se pone
aca se

reemplaza byte en lugar de int , byte tiene una longitud de 8 bits , la mitad de int y permite
almacenar valores entre 0 y 255 mientras que int tiene 16 bits y permite almacenar valores desde
-32768 y 32768.
const es constante y esta le dice que el valor no puede ser modificado, o sea que si le damos un
valor 4 en el programa no se puede modificar luego ( trabajo en este programa con 4 filas)

array :

el array
es un
32

conjunto de valores a los que se puede acceder mediante un índice , en este caso si tomara un
array ( llamado MIARRAY) el tamaño se establece con el número entre corchetes por ej si tiene [6]
indica que hay 6 espacios para almacenar, cada valor debe estar asociado a un número de índice,
se suele asignar como i
índice inicial el valor 0, o sea el primer valor tiene índice 0 , el segundo valor índice 1 y así
sucesivamente
esto se asigna indicando
VALOR = MIARRAY[0]// VALOR = 1

#include <Keypad.h> // importa libreria Keypad

const byte FILAS = 4; // define numero de filas

const byte COLUMNAS = 4; // define numero de columnas

este bloque permite definir la distribución del teclado

char keys[FILAS][COLUMNAS] = { // define la distribucion de teclas

{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};

se define los pines que usaran las filas y columnas

byte pinesFilas[FILAS] = {9,8,7,6}; // pines correspondientes a las filas

byte pinesColumnas[COLUMNAS] = {5,4,3,2}; // pines correspondientes a las columnas

Keypad teclado = Keypad(makeKeymap(keys), pinesFilas, pinesColumnas, FILAS, COLUMNAS); //

crea objeto

HASTA ESTE BLOQUE SIEMPRE SE COPIA EXACTAMETE IGUAL CUANDO USE UN

TECLADO DE MEMBRANA

char significa carácter, esto permite ingresar un numero, una letra un asterisco etc y observarlo
se quiere hacer una clave de ingreso para ello se debe comparar la clave ingresada con una clave
maestra y si coinciden se abre la puerta, si bien la clave es de 6 digitos se le asigna 7 caracteres
porque uno será nulo
char TECLA; // almacena la tecla presionada
char CLAVE[7]; // almacena en un array 6 digitos ingresados
char CLAVE_MAESTRA[7] = "123456"; // almacena en un array la contraseña maestra
byte INDICE = 0; // indice inicial del array

se indica en el void setup que se va a visualizar lo que se introduzca en el teclado

void setup()
{
33

Serial.begin(9600); // inicializa comunicacion serie

}

void loop(){
TECLA = teclado.getKey(); // obtiene tecla presionada y asigna a variable
if (TECLA) // comprueba que se haya presionado una tecla
{
CLAVE[INDICE] = TECLA; // almacena en array la tecla presionada
INDICE++; // incrementa indice en uno, indica que el segundo valor va en el segundo índice
Serial.print(TECLA); // envia a monitor serial la tecla presionada
}

con la funcion if lo que hacemos es determinar, si ya hay 6 dígitos introducidos, entonces compara
la clave introducida con la maestra ( función stream compear (strcmp) si es la misma devolvera e
valor correcta, sino incorrecta
if(INDICE == 6) // si ya se almacenaron los 6 digitos
{
if(!strcmp(CLAVE, CLAVE_MAESTRA)) // compara clave ingresada con clave maestra
Serial.println(" Correcta"); // imprime en monitor serial que es correcta la clave
else
Serial.println(" Incorrecta"); // imprime en monitor serial que es incorrecta la clave

INDICE = 0;
}
}

codigo terminado

#include <Keypad.h> // importa libreria Keypad

const byte FILAS = 4; // define numero de filas
const byte COLUMNAS = 4; // define numero de columnas
char keys[FILAS][COLUMNAS] = { // define la distribucion de teclas
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};

byte pinesFilas[FILAS] = {9,8,7,6}; // pines correspondientes a las filas

byte pinesColumnas[COLUMNAS] = {5,4,3,2}; // pines correspondientes a las columnas

Keypad teclado = Keypad(makeKeymap(keys), pinesFilas, pinesColumnas, FILAS, COLUMNAS); //

crea objeto

char TECLA; // almacena la tecla presionada

char CLAVE[7]; // almacena en un array 6 digitos ingresados
char CLAVE_MAESTRA[7] = "123456"; // almacena en un array la contraseña maestra
byte INDICE = 0; // indice del array
byte PinLed = 10;
34

void setup()
{
Serial.begin(9600); // inicializa comunicacion serie
}

void loop(){
TECLA = teclado.getKey(); // obtiene tecla presionada y asigna a variable
if (TECLA) // comprueba que se haya presionado una tecla
{
CLAVE[INDICE] = TECLA; // almacena en array la tecla presionada
INDICE++; // incrementa indice en uno
Serial.print(TECLA); // envia a monitor serial la tecla presionada
}

if(INDICE == 6) // si ya se almacenaron los 6 digitos

{
if(!strcmp(CLAVE, CLAVE_MAESTRA)) // compara clave ingresada con clave maestra
Serial.println(" Correcta"); // imprime en monitor serial que es correcta la clave
else
Serial.println(" Incorrecta"); // imprime en monitor serial que es incorrecta la clave

INDICE = 0;
}
}

15) cuando se coloca la clave correcta se enciende un led

35

#include <Keypad.h> // importa libreria Keypad

const byte FILAS = 4; // define numero de filas
const byte COLUMNAS = 4; // define numero de columnas
char keys[FILAS][COLUMNAS] = { // define la distribucion de teclas
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
byte pinesFilas[FILAS] = {9,8,7,6}; // pines correspondientes a las filas
byte pinesColumnas[COLUMNAS] = {5,4,3,11}; // pines correspondientes a las columnas
byte pinled=10;

Keypad teclado = Keypad(makeKeymap(keys), pinesFilas, pinesColumnas, FILAS, COLUMNAS); //

crea objeto

char TECLA; // almacena la tecla presionada

char CLAVE[7]; // almacena en un array 6 digitos ingresados
char CLAVE_MAESTRA[7] = "222222"; // almacena en un array la contraseña maestra
byte INDICE = 0; // indice del array

void setup()
{
Serial.begin(9600); // inicializa comunicacion serie
pinMode(pinled,OUTPUT);
}

void loop(){
TECLA = teclado.getKey(); // obtiene tecla presionada y asigna a variable
if (TECLA) // comprueba que se haya presionado una tecla
{
CLAVE[INDICE] = TECLA; // almacena en array la tecla presionada
INDICE++; // incrementa indice en uno
Serial.print(TECLA); // envia a monitor serial la tecla presionada
}
if(INDICE == 6) // si ya se almacenaron los 6 digitos
{
if(!strcmp(CLAVE, CLAVE_MAESTRA)) // compara clave ingresada con clave maestra
Serial.println(" Correcta"); // imprime en monitor serial que es correcta la clave
else
Serial.println(" Incorrecta"); // imprime en monitor serial que es incorrecta la clave
36

INDICE = 0;
}
if(!strcmp(CLAVE, CLAVE_MAESTRA))
{
digitalWrite(pinled,HIGH); // Enciende luz

}
}

16) si se introduce la clave correcta se enciende un led verde sino uno rojo

#include <Keypad.h>
// importa libreria Keypad
const byte FILAS = 4;
// define numero de filas
const byte COLUMNAS = 4; // define numero de columnas
char keys[FILAS][COLUMNAS] = { // define la distribucion de teclas
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
byte pinesFilas[FILAS] = {9,8,7,6}; // pines correspondientes a las filas
byte pinesColumnas[COLUMNAS] = {5,4,3,2}; // pines correspondientes a las columnas
byte pinled=10;
37

byte pinled2=11;

Keypad teclado = Keypad(makeKeymap(keys), pinesFilas, pinesColumnas, FILAS, COLUMNAS); //

crea objeto

char TECLA; // almacena la tecla presionada

char CLAVE[7]; // almacena en un array 6 digitos ingresados
char CLAVE_MAESTRA[7] = "222222"; // almacena en un array la contraseña maestra
byte INDICE = 0; // indice del array

void setup(){
Serial.begin(9600);
pinMode(pinled,OUTPUT);
pinMode(pinled2,OUTPUT);
}

void loop(){
TECLA = teclado.getKey();

if (TECLA != NO_KEY){
Serial.println(TECLA);
CLAVE[INDICE]= TECLA;
INDICE++;
}
if (INDICE==6){
byte check =0;
for(int i=0;i<6;i++){
Serial.print(CLAVE[i]);
if (CLAVE[i]==CLAVE_MAESTRA[i]){
check++;
}
}

if (check== 6) {
digitalWrite(pinled, HIGH);
digitalWrite(pinled2, LOW);
Serial.println("GREEN");
}else{
digitalWrite(pinled2, HIGH);
digitalWrite(pinled, LOW);
Serial.println("RED");
}
INDICE=0;
}
}

MODULO LCD
38

41

#include <LiquidCrystal.h> // importa librería

SE DEBE DEFINIR LOS PINES QUE SE VAN A USAR EN EL LCD

LiquidCrystal lcd(7, 6, 5, 4, 3, 2); // pines RS, E, D4, D5, D6, D7 de modulo 1602A

SE DEBE INICIALIZAR EL LCD EN EL VOID SETUP PARA ELLO LE INDICO EL NUMERO DE

COLUMNAS Y FILS QUE TIENE
void setup() {
lcd.begin(16, 2); // inicializa a display de 16 columnas y 2 lineas
}

SE INDICA EN QUE FILA Y EN QUE COLUMNA SE COMIENZA A ESCRIBIR , LUEGO SE PUEDE

INDICAR EL TEXTO QUE VOY A ESCRIBIR, SI SE QUIERE ESCRIBIR EN LA SEGUNDA LINEA
SE DEBE UBICAR EL CURSOR EN LA COLUMNA 0, FILA 1 . LA FUNCION MILLIS HACE QUE
NO SEA ESTÁTICO O SEA SE PUEDE HACER QUE EL TEXTO APAREZCA POR UN TIEMPO Y
DESAPAREZCA Y LUEGO SE COLOCA LA SEGUNDA INSTRUCCIÓN O FRASE
void loop() {
lcd.setCursor(0, 0); // ubica cursor en columna 0, linea 0
lcd.print("Hola, han pasado"); // escribe el texto en pantalla
lcd.setCursor(0, 1); // ubica cursor en columna 0, linea 1
lcd.print(millis() / 1000); // escribe valor en segundos devuelto por funcion millis()
lcd.print(" seg."); // imprime a continuacion abreviatura de segundos
}

SENSOR DE MOVIMIENTO PIR

39

Emite una radiación infraroja que permite detectar el movimiento, es pasivo ya que solo recibe señal
y no emite , permite detectar ojjetos a 6 m e distancia

Funcionamiento de un relé mediante un sensor pir

programa:
40

primero se define el pin donde se conecta el sensor y el relé y una variable para almacenar el valor
leido de señal de sensor que la llamamos ESTADO, para indicar si su estado es encendido o
apagado, se pone 0 ya que se presume que el sensor no ha leido nada todavia
int PIR = 2; // señal de PIR a pin 2
int RELE = 3; // IN de rele a pin 3
int ESTADO = 0; // almacena estado de señal

se define entrada y salida se coloca un tiempo para estabilizar el sensr dado por el fabricante
void setup(){
pinMode(PIR, INPUT); // pin 2 como entrada
pinMode(RELE, OUTPUT); // pin 3 como salida
delay(20000); // demora para estabilizar el sensor
}

se define las ordenes para que cumpla la funcion, aca se obtiene la lectura del sensor si este esta
recibiendo señal ( HIGH) activa el relé, ( recordar que actúa en LOW), entonces hacemos que SI el
sensor detecta movimiento el relé se encienda, SINO el relé se apaga, se coloca un tiempo de 4 seg
para que no se perjudique al relé ya que es mecánico y se puede dañar
void loop(){

ESTADO = digitalRead(PIR); // lectura de estado de señal

if (ESTADO == HIGH){ // si la señal esta en alto indicando movimiento
digitalWrite(RELE, LOW); // activa modulo de rele con nivel bajo
delay(4000); // demora de 4 segundos
} else {
digitalWrite(RELE, HIGH); // apaga modulo rele
}
}

el programa queda

int PIR = 2; // señal de PIR a pin 2

int RELE = 3; // IN de rele a pin 3
int ESTADO = 0; // almacena estado de señal

void setup(){
pinMode(PIR, INPUT); // pin 2 como entrada
pinMode(RELE, OUTPUT); // pin 3 como salida
delay(20000); // demora para estabilizar el sensor
}

void loop(){

ESTADO = digitalRead(PIR); // lectura de estado de señal

if (ESTADO == HIGH){ // si la señal esta en alto indicando movimiento
digitalWrite(RELE, LOW); // activa modulo de rele con nivel bajo
delay(4000); // demora de 4 segundos
} else {
41

digitalWrite(RELE, HIGH); // apaga modulo rele

}
}

ejemplo