Curso de

Arduino
Descripcion
Este curso pretende dar a conocer los mecanismos de programacion de la placa Arduino, sus
principales caracteristicas y usos y aplicaciones.
Ya que el objetivo principal de Arduino es interactuar con el mundo fisico, se incluyen en
este curso los conocimientos y recursos necesarios para actuar en el mundo real. Ademas, se
impartiran unas minimas nociones de electronica que son necesarias para trabajar con
seguridad con los componentes electronicos y realizar correctamente todas las practicas.
Objetivos
Tras finalizar el curso, los alumnos -aun sin tener conocimientos previos ni de electronica ni
de programacion- contaran con las habilidades, recursos y conocimientos necesarios para
poder planificar, disenar, prototipar y construir por su propia cuenta circuitos con Arduino
de una complejidad moderada.
1. ^Que es Arduino?
2. Caracteristicas de Arduino.
3. Diferentes tipos de Arduino.
4. Conceptos basicos de electronica, ley de Ohm y la analogia del agua.
5. Presentation del Arduino Mega, descripcion de componentes del kit basico
6. Fritzing.
7. Software de Arduino.
8. Lenguaje Arduino.
9. Practical: Hola mundo
10. Practica 2: Encendido y apagado con un Boton pulsador
11. Practica 3: Entrada Analogica y Salida PWM
12. Practica 4: Salidas PWM
13. Practica 5: Monitoreando una Senal Digital
14. Practica 6: Buzzer( zumbador )
15. Practica 7: Uso de una foto-resistencia como sensor de luz
16. Practica 8: Leer de temperatura
17. Practica 9: Encender Led desde Pagina Web
18. Practica10: Almacenar Temperatura en MYSQL
19. Practica 11: Sensor Ultrasonidos HC-SR04 para Medir Distancia
20. Practica 12: Sensor Ultrasonidos HC-SR04 para estacionar un vehiculo
Material: canon, mesas de trabajo, laptop

Instructor: Alejandro Guzman Zazueta

a_zazuetag@hotmail.com

1. ^Que es Arduino?
Arduino es una marca de microcontroladores mundialmente conocida por los amantes de la
electronica, la programacion y la robotica. Es un proyecto Open Source que pone a
disposition de sus usuarios una amplia gama de dispositivos basados en el microcontrolador
AtMega. Es posible comprar una placa Arduino armada o bien conseguir las piezas para uno
mismo desarrollar sus propios dispositivos.
Arduino Mega, cuyas caracteristicas presentare a continuation.

El Arduino Mega es probablemente el microcontrolador mas capaz de la familia Arduino.

Posee 54 pines digitales que funcionan como entrada/salida; 16 entradas analogas, un cristal
oscilador de 16 MHz, una conexion USB, un boton de reset y una entrada para la
alimentation de la placa.
La comunicacion entre la computadora y arduino se produce a traves del puerto serie, sin
embargo posee un convertidor usb-serie, por lo que solo se necesita conectar el dispositivo a
la computadora utilizando un cable USB como el que utilizan las impresoras.

2. Caracteristicas del Arduino Mega

Microcontrolador: ATmega2560
Voltaje Operativo: 5V
------------Voltaje de Entrada: 7-12V
Voltaje de Entrada (li'mites): 6-20V
Pines digitales de Entrada/Salida: 54 (de los cuales 15 proveen salida PWM)
Pines analogos de entrada: 16 Corriente DC por cada
Pin Entrada/Salida: 40 mA Corriente DC entregada
en el Pin 3.3 V: 50 mA Memoria Flash: 256 KB (8KB
usados por el bootloader)
SRAM: 8KB
EEPROM: 4KB
Clock Speed: 16 MHz
Alimentacion

Arduino Mega puede ser alimentado mediante el puerto USB o con una fuente externa de
poder. La alimentacion es seleccionada de manera automatica.
Cuando se trabaja con una fuente externa de poder se debe utilizar un convertidor AC/DC y
regular dicho voltaje en el rango operativo de la placa. De igual manera se puede alimentar
el micro mediante el uso de baterias. Preferiblemente el voltaje debe estar en el rango de los

7V hasta los 12 V.
Arduino Mega posee algunos pines para la alimentacion del circuito aparte del adaptador
para la alimentacion:
VIN: A traves de este pin es posible proporcionar alimentacion a la placa.
5V: Podemos obtener un voltaje de 5V y una corriente de 40mA desde este pin.
3.3V: Podemos obtener un voltaje de 3.3 V y una corriente de 50mA desde este pin.
GND: El ground (0V) de la placa.
Arduino puede ser programado de una manera muy facil utilizando el lenguaje propio de
Arduino junto con la interfaz Arduino IDE.

Diferentes tipos de Arduino

Esta es la ultima revision de la placa Arduino USB basica. Se conecta al ordenador con un
Uno

Nano

cable USB estandar y contiene todo lo necesario para programar la placa. Se puede ampliar
con gran variedad de shields. Tiene un ATmega328, tambien consta de 14 pines de
entrada/salida de los cuales 6 se pueden usar como salidas PWM, 6 entradas analOgicas, un
velocidad de reloj de 16 MHz y un conector 1CPS.
Una placa compacta disenada para usar directamente en placas de desarrollo, el Nano se
conecta al ordenador con un cable Mini-B USB. Basado en el ATmega328 (Arduino Nano
3.0) o ATmega168 (Arduino Nano 2.x) que se usa conectandola a una protoboard. Tiene mas
o menos la misma funcionalidad que el ArduinoDuemilanove, pero con una presentaciOn
diferente. No posee conector para alimentaciOn externa, y funciona con un cable USB MiniB en vez del cable estandar.

Mega

Mas grande y potente placa Arduino, compatible con los shields de Duemilanove, Diecimila
y Uno. Basada en ATmeg1280. Tiene 54 entradas/salidas digitales (de las cuales 14
proporcionan salida PWM), 16 entradas digitales, 4 UARTS (puertos serie por hardware),
un reloj de 16MHz, conexion USB, entrada de corriente, conector ICSP y boton de reset.
Contiene todo lo necesario para hacer funcionar el microcontrolador; simplemente conectalo
al ordenador con el cable USB o alimentalo con un trasformador o bateria para empezar.
LilyPad

LilyPad - Disenado para aplicaciones sobre prendas, esta placa puede ser cosida a la ropa y
es de color purpura y con un diseno con estilo. Esta basado en el ATmega 168 V (de menor
consumo que la version ATmega168) o el ATmega328V.

Fio

Disenada para aplicaciones inalambricas. Incluye un zocalo para XBee, un conector para
baterias LiPo y electrOnica para cargar baterias. Basada en el ATmega328P. Tiene 14 pines
de E/S digitales (de los cuales 6 pueden usarse como salidas PWM), 8 entradas analOgicas,
un resonador en placa, un botOn de reinicio (reset), y agujeros para montar conectores de
pines. Tiene conexiones para una bateria de polimero de Litio e incluye un circuito de carga
a traves de USB. En el reverso de la placa tiene disponible un zocalo para mOdulos XBee.
Esta disenado para aplicaciones inalambricas.

Mini

La placa Arduino mas pequena. Funciona perfectamente en una placa de desarrollo o en

aplicaciones donde el espacio es primordial. Se conecta al ordenador usando el adaptador
Mini USB. Basada en el ATmegal68, cuenta con 14 entradas/salidas digitales (de las cuales
6 pueden ser usadas como salidas PWM ), 8 entradas analOgicas y un reloj de 16 MHZ.
Puede ser programada con el adaptador Mini USB u otros adaptadores USB o RS232 a TTL
serial.
Advertencia: No Alimente el Arduino mini con mas de 9 voltios, o conecte la alimentaciOn
al reves: probablemente acabara con el.

Pro Mini

Como la Pro, la Pro Mini esta disenada para usuarios avanzados que requieren de bajo coste,
menor tamano y dispuestos a un poco de trabajo extra.
Es una placa con un microcontrolador ATmega168. Tiene 14 E/S digitales (6 de las cuales se
puedes utilizar como salidas PWM), 6 entradas analogicas, un resonador interno, boton de
RESET y agujeros para el montaje de tiras de pines. Se le puede montar una tira de 6 pines
para la conexion a un cable FTD1 o a una placa adaptadora de la casa Sparkfun para dotarla
de comunicacion USB y alimentaciOn.
La Arduino Mini Pro esta destinada a instalaciones semi-permanentes en objetos o
demostraciones. La placa viene sin conectores montados, permitiendo el uso de varios tipos
de conectores o soldado directo de cables segun las necesidades de cada proyecto en
particular. La distribucion de los pines es compatible con la Arduino Mini.

3. Conceptos basicos de electronica.

Ver video
Arduino basico T03AB - Conceptos fundamentales de electronica.mp4
Ver video
Conceptos basicos de electronica, ley de Ohm y la analogia del
agua.mp4 Ver video
Description de componentes del kit basico

4. Presentacion del Arduino Mega

Presentacion Arduino Mega - www.BricoGeek.com.flv

5. Fritzing
Fritzing es una iniciativa de software libre para apoyar a disenadores, artistas,
investigadores y aficionados para trabajar de manera creativa con la electronica
interactiva.

Esencialmente es un software de automatization de diseno electronico con una interfaz

dinamica. El software cuenta con un sitio web en el que esta involucrada una gran
comunidad con el proposito de compartir experiencias y fomentar la participation de
novatos y expertos alrededor del mundo de la electronica.
El desarrollo de esta herramienta permite a los usuarios documentar sus prototipos,
compartirlos con los demas, ensenar electronica en el salon de clases, y crear un diseno para
la fabrication de circuitos impresos de manera profesional, en pocas palabras desde cero
hasta
la
manufactura.
Si eres un estudiante de electronica, experto o simplemente te llama la atencion el diseno de
circuitos, esta es la herramienta para desarrollar tus proyectos y poder compartirlos con el
mundo.

6. Software de Arduino.
El programa se implementara haciendo uso del entorno de programacion propia de
Arduino y se transferira empleando un cable USB. No es preciso utilizar una fuente de
alimentacion externa, ya que el propio cable USB la proporciona, para la realization de
algunos de los experimentos practicos si que sera necesario disponer de una fuente de
alimentacion externa ya que la alimentacion proporcionada por el USB puede no ser
suficiente. El voltaje de la fuente puede estar entre 6 y 25 voltios.
Para programar la placa es necesario descargar de la pagina web de Arduino el entorno
de desarrollo (IDE). Se dispone de versiones para Windows y para MAC, asi como las
fuentes para compilarlas en LINUX.
Instalacion:
Tener la version mas reciente de JAVA: https://www.java.com/es/download/
Descargar el IDE de ARDUINO: http://arduino.cc/en/Main/Software
Conectar la Placa ARDUINO a la PC y Windows se encargara de Instalar los
Drivers, En Vista, Windows 7,8 y 8.1 los Drivers deben descargarse e instalarse
automaticamente.
En la siguiente figura se muestra el aspecto del entorno de programacion:

Lo primero que tenemos que hacer para comenzar a trabajar con el entorno de
desarrollo de arduino es configurar las comunicaciones entre la placa Arduino y la PC.
Para ello deberemos abrir en el menu Herramientas la opcion Puerto Serial. En esta
opcion deberemos seleccionar el puerto serie al que esta conectada nuestra placa
Arduino. En Windows, si desconocemos el puerto al que esta conectado nuestra placa
podemos descubrirlo a traves del administrador de dispositivos (Puertos COM
&LPT/USB Serial Port). Igualmente deberemos seleccionar el tipo de placa que
tenemos, a siguiente figura ilustra como hacerlo.

El primer paso para comprobar que todo lo que hemos hecho hasta ahora esta bien y
familiarizarnos con la interfaz de desarrollo, es abrir uno de los ejemplos. Se
recomienda abrir el ejemplo Blink. Para ello debemos acceder a traves del menu
Archivo -> Ejemplos -> 02.Digital ->BlinkWithOutDelay.
El ejemplo lo unico que hace es parpadear un LED que esta colocado en el pin numero
13 de la placa. Vamos a ver que hay que hacer para subir el programa a la placa
Arduino. Primero probaremos que el codigo fuente es el correcto. Para ello pulsamos el
boton de verification de codigo que tiene un circulo con una palomita, es el primer
icono en la barra de herramientas, ver siguiente figura:

Durante la carga del programa, en la placa USB, se encenderan los LED que indican que
se estan enviando y recibiendo information por el puerto serie TX/RX. Si todo se ha
realizado correctamente debe aparecer el mensaje Carga Terminada. Ahora tan solo
queda esperar unos segundos para comprobar que todo ha salido bien. Si el LED
colocado en el pin 13 de la placa se enciende y se apaga cada segundo entoces ha salido
bien.

Curso de
Arduino
7. Lenguaje Arduino.
El lenguaje de programacion que maneja ARDUINO esta basado en C/C++, los programas
que realicemos se componen de tres partes principales:
1. Estructuras.
2. Valores (Variables y Constantes).
3. Funciones.
La estructura basica esta compuesta en dos partes:
Setup() Constituye la preparation del programa, en ella declaramos las variables y es
la primer sentencia que ejecuta el programa. Esta funcion solo es ejecutada una sola
vez y la empleamos para configurar los pinMode() e iniciar la comunicacion.
Loop() Es la ejecucion, la cual es ejecutado continuamente (leyendo las entradas de
la placa, salidas, etc.).
Cada instruction termina con un ; y los comentarios son con // o un bloque de
comentarios con /*...*/.
FUNCIONES: Son bloques de codigo identificado por un nombre y es ejecutado cuando la
funcion es llamada.
VARIABLES: Una variable debe ser declarada y opcionalmente asignada a un determinado
valor. La variable puede ser de diferente tipo de dato (int, float, long).
Esta variable puede ser especificada antes de Setup() o dentro de un Bucle como un for().
El sitio en el que se declara la variable determina el ambito de la misma.
TIPO DE DATOS
boolean (booleano)
char (caracter)
byte
int (entero)
unsignedint (entero sin signo)
long (entero 32b)
unsignedlong (entero 32b sin signo)
float (en coma flotante)
double (en coma flotante de 32b)
string (cadena de caracteres)
array (cadena)
void (vacio)
ESTRUCTURAS DE CONTROL
if (comparador si-entonces)
if...else (comparador si...sino)
for (bucle con contador)
switch case (comparador multiple)
while (bucle por comparacion booleana)

Instructor: Alejandro Guzman Zazueta

a_zazuetag@hotmail.com

do... while (bucle por comparacion booleana)

break (salida de bloque de codigo)
continue (continuacion en bloque de codigo)
return (devuelve valor a programa)

CONSTANTES
HIGH | LOW
INPUT|OUTPUT
true | false
Constantes Numericas
OPERADORES ARITMETICOS
= (asignacion)
+ (suma)
- (resta)
* (multiplicacion)
/ (division)
% (resto)
OPERADORES COMPARATIVOS
== (igual a)
!= (distinto de)
< (menor que)
> (mayor que)
<= (menor o igual que)
>= (mayor o igual que)
OPERADORES BOOLEANOS
&& (y)
II (o)
! (negacion)
OPERADORES DE COMPOSICION
++ (incrementa)
-- (decrementa)
+= (composicion suma)
-= (composicion resta)
*= (composicion multiplicacion)
/= (composicion division)
CONVERSION
char()
byte()
int()
long()
float()

A continuation se muestran las diferentes funciones que podemos utilizar dentro del
lenguaje de programacion ARDUINO.
E/S Digitales
pinMode()
digitalW rite()
digitalRead()
E/S Analogicas
analogRead()
analogWrite() - PWM (modulation por ancho de pulso)
E/S Avanzadas
tone()
noTone()
shiftOut()
pulseln()
Tiempo
millis()
micros()
delay()
delayMicroseconds()
Matematicas
min() (minimo)
max() (maximo)
abs() (valor absoluto)
constrain() (limita)
map() (cambia valor de rango)
pow() (eleva a un numero)
sq() (eleva al cuadrado)
sqrt() (raiz cuadrada)
Trigonometria
sin() (seno)
cos()(coseno)
tan() (tangente)
Numeros Aleatorios
randomSeed()
random()
Comunicacion
Serial

Ahora que ya conocemos todos los elementos asi como sus conceptos basicos de la
programacion ARDUINO pasemos a poner en practica lo aprendido con los siguientes
ejemplos basicos para empezar a programar sobre nuestra placa.

Curso de
Arduino
Practical: Hola mundo
Este primer proyecto Arduino consiste en aprender a activar una salida digital de nuestra
placa Arduino a la que conectaremos mediante una resistencia, un diodo LED que
parpadeara en intervalos de un segundo.

Materiales:

Una resistencia de 220 Q (Rojo, rojo, cafe, dorado)

Un diodo LED
Una protoboard

Diagrama:

Instructor: Alejandro Guzman Zazueta

a_zazuetag@hotmail.com

A continuation vamos a crear el codigo correspondiente en nuestro ARDUINO para nuestra

practica quedaria de la siguiente manera: void setup(){

pinMode(12, OUTPUT); // Pin 12 como Salida.

}

//AhoEa le decimos qua haceE con esa salida.

void loop ()
{ digitalUrite(12, HIGH);
delay(lOOO);
digitalWrite(12, LOW);
delay(lOOO);

// Pone la salida 12 a OH //
Espena un segundo // Pone la
salida 12 a OFF // Espena un
segundo

*Se puede variar el numero de milisegundos para comprobar que se recarga el

programa.

El siguiente paso es verificar que nuestro programa no contenga errores para ello
presionamos el boton si nuestro proyecto esta correcto nos aparecera el sig. Mensaje:

Compilacion terminada

Tamano binario del Sketch: 1.076 bytes (de un maximo de 32.256 bytes)
22

Interactua el codigo con el proyecto fisico presionando el boton

Ahora si podemos mandar nuestro codigo a nuestra tarjeta
ver como

Arduino Uno on COM4

ARDUINO para

Ahora si podremos observar como nuestro LED enciende y apaga con retraso de 1
Segundo.

Problema a solucionar: Utilizando los conocimientos de esta practica desarrollar un

semaforo, el cual tenga la siguiente duracion:

Verde 25 segundos
Amarillo 5 Segundos
Rojo 10 Segundos

Practica 2:Encendido y apagado con un Boton pulsador

En este tutorial de Arduino, vamos a aprender a configurar una entrada digital a la que
conectaremos un pulsador y, con lo aprendido sobre el LED en el anterior tutorial, nos
permitira controlar el encendido y apagado del diodo.

Materiales:

1 protoboard.
1 diodo LED.
2 resistencias 220Q.
1 pulsador.

Diagrama:

A continuation crearemos el codigo correspondiente de esta practica para lo cual quedaria

de la siguiente manera.

Verificamos que nuestro proyecto no contenga errores y finalizamos cargando el codigo a

nuestra placa ARDUINO.

} } Variables estaticas

mt- pinEoton = Z ;

f j Declarants la variable pin dal Bo tan

int pinLed = 1 Z ;

// Declaramos la variable pin del Led

// Variables dinanicas
int estadoBoton =0;

// Variable para estado del boton

void setup () {
// Inicializa el pin del LED coao salida: pinMode (pinLed,
OUTPUT);
H Inicializa el pin del boton como entrada:
pinMode(pinBoton, INPUT);
}

void loop() {
// Lee el valor del pin del boton y lo almacena // en la variable
estadoBoton

estadoBoton = digitalRead(pinBoton);

// Chequea si el boton esta pulsado: if

(estadoBoton == HIGH) {
// Si es asi, enciende el LED:
digitalWrite(pinLed, HIGH);
}

else {
i i Si no, lo mantiene apagado:
digitalWrite(pinLed, LOW);
}

Verificamos que nuestro proyecto no contenga errores y finalizamos cargando el codigo a

nuestra placa ARDUINO.
Al final de la practica podemos observar que el boton crea el paso de corriente al mandar un
valor de estado 1 y abre el circuito para omitir el paso al mandar un valor de estado 0.
Recordemos que
LOW = 0
HIGH = 1
Por lo tanto ahora sabemos como poder manejar el comportamiento de un boton para
realizar ciertas funciones dentro de ARDUINO.

Problema a soliicionar: Utilizando los conocimientos de esta practica desarrollar un

semaforo, el cual tenga la siguiente duracion:
Verde 25 segundos
Amarillo 5 Segundos
Rojo 10 Segundos
Incluir un boton de cruce, el cual cuando se presione cambie la secuencia y lo ponga en
r j
o o.

Practica 3: Entrada Analogica y Salida PWM

En este nuevo proyecto vamos a aprender utilizar las entradas analogicas de nuestro
ARDUINO para utilizarla en dos ejemplos, primero variaremos la frecuencia de parpadeo
de un diodo LED con un potenciometro conectado a una entrada analogica y luego
utilizaremos el mismo circuito para realizar una modulation del ancho de un pulso en una
salida digital (PWM).

Materiales:

Un diodo led.
Una resistencia 220 KQ.
Un Potenciometro 10KQ.
Una Protoboard.

En este proyecto vamos a realizar dos ejemplos con un mismo circuito, la diferencia entre
ellos la observaremos es el apartado de programacion, en cuanto a hardware tenemos la
novedad de este proyecto en el uso de un potenciometro combinado con una entrada
analogica, asi que primero aclararemos unos conceptos.
^Que es un POTENCIOMETRO?
Un potenciometro es una resistencia variable, podemos elegir el valor que puede tomar. De
esta forma, controlamos la intensidad de corriente que fluye por un circuito si este esta
conectado en paralelo, asf como la diferencia de potencial si esta conectado en serie.

El potenciometro dispone de tres patillas: entre las dos de sus extremos existe siempre un
valor fijo de resistencia, y entre cualquiera de los dos extremos y la patilla central tenemos una
parte de ese valor. Es decir, la resistencia maxima que ofrece el potenciometro entre sus dos
extremos no es mas que la suma de las resistencias entre un extremo y la patilla central.

simbolo electrico

Debemos colocar uno de los extremos a masa (-), otro a +Vcc y nuestra patilla central sera
nuestra tension de salida regulable, esta salida sera la que conectemos a ARDUINO y que
variara de 0v a 5v dependiendo de la position de nuestro potenciometro.

Entradas Analdgicas

En cuanto a la salida, colocaremos la ya conocida configuration de LED mas resistencia,

pero deberemos tener algo en cuenta, para el primer ejemplo nos daria igual la salida digital
a elegir, pero para el segundo es necesario que seleccionemos una salida con PWM, las
salidas seran del pin 1 a la 13como se puede ver en la siguiente imagen:

^QUE ES EL PWM?
A menudo necesitaremos algo mas que una senal de 0 o 1 en nuestros proyectos, para variar
la velocidad de giro de un motor, para variar la intensidad con la que luce un diodo, para
transmitir los grados de giro de un servo, etc.
Para todo esto, y mucho mas, nos servira el PWM, que emula una senal analogica a partir de
una senal digital.
Las siglas PWM vienen de Pulse Width Modulation, o Modulacion de Ancho de Pulso.
Lo que hace este tipo de senal es emitir, en lugar de una senal continua en nuestra salida,
emite una serie de pulsos que podremos variar su duracion pero con una frecuencia
constante de aproximadamente 490Hz, de manera que la tension promedio resultante, es
directamente proporcional a la duracion de estos dentro del rango de nuestro periodo, es
decir, cuanto mas juntos esten esos pulsos de +5v, mayor sera la tension promedio de
nuestra salida, y cuanto mas distantes sean estos, menor sera dicha tension:

Diagrama:

A continuacion crearemos el codigo correspondiente para la realizacion de esta practica lo

cual quedaria de la siguiente manera:

Al momento de cargar el programa podemos variar la frecuencia de encendido del Led

moviendo la perilla del potenciometro.
En este codigo utilizamos la instruccion:
analogRead(pinSensor);
Esta instruccion nos permite leer cualquier sensor que conectemos al pin analogico
establecido en pinSensor, por defecto, Arduino nos realizara una conversion analogicodigital para toda senal (40mA maximo) de 0v a 5v con una resolution de 10 bit, lo que nos
da 2 a la 10 (1024) valores de referencia para nuestro programa, siendo 0 en 0v y 1023 en
+5v.

Practica 4: Salidas PWM

Sin variar el circuito, vamos a introducir un nuevo codigo para realizar un ejemplo
diferente, en este proyecto, nuestro diodo LED variara su intensidad lummica en funcion del
valor que este aportando el potenciometro a nuestra entrada analogica, esto es el llamado
efecto fading (desvanecimiento), puede observarse que se ha elegido la salida numero 9, ya
que esta si que es compatible con la opcion PWM.
Diagrama

A continuation introducimos el siguiente codigo:

Para este ejercicio se debe tener en cuenta lo siguiente:

Los niveles de entrada son de 0 a 1023 del potenciometro.

Los niveles de salida, deben ser de 0 a 255

Como podemos observar utilizamos una nueva instruccion:

analogWrite(pinLed, valorSensor / 4);
El rango de salida de esta instruccion varia de 0 a 255, siendo 0 = 0v y 255 = 5v, por lo que
es tan sencillo como introducir un valor determinado para la tension de salida que nosotros
queramos conseguir, si quisieramos conseguir 2,5v el valor a asignar seria 127.
Asi que lo unico que debemos hacer es transformar mediante una simple operation
matematica la senal tomada en nuestro potenciometro para adaptarla a nuestra salida PWM.

Para monitorear las lecturas del potenciometro podemos utilizar el puerto serie, a
continuation se muestra el codigo:

Para abrir el monitor serial, se muestra la siguiente ventana:

Problema a solucionar: Utilizando los conocimientos de esta practica hacer que se vayan
encendiendo 5LEDs, de uno en uno a medida que variamos la resistencia interna del
potenciometro.
Los componentes que vamos a utilizar en este caso seran:

5 LEDs (el color no es significativo)

5 resistencias de 220Q (una para cada LED)

1 potenciometro 50kQ

Hacer el programa en arduino para controlar esto.

Practica 5: Monitoreando una Senal Digital

Asi como hicimos en la practica anterior, tambien podemos monitorear senales DIGITALES.
A veces tambien sera util monitorear una senal digital, como un interruptor. En este ejercicio
vamos a trabajar con uno de los botones/switches para desplegar en nuestro monitor serial
una entrada digital. Para eso vamos a conectar a nuestro Arduino un Boton a una de las
entradas digitales.

Materiales:

Una protoboard
Una resistencia 200Q
Un Boton

Diagrama:

A continuation se muestra el codigo, mostrando el estado del boton en el monitor serial:

Practica 6: Buzzer( zumbador )

Antes de empezar debemos de conocer lo que es un Buzzer o conocido tambien como
Zumbador, el cual es un transductor electro acustico que produce un sonido o zumbido
continuo o intermitente de un mismo tono, es usado como mecanismo de senalizacion o aviso,
son utilizados en multiples sistemas como en autos o en electrodomesticos.

Materiales:

Un Buzzer
Una Protoboard

Buzzer:

En esta practica aprenderemos a mandar un pulso o Zumbido a nuestro Buzzer cada

determinado tiempo.

Diagrama:

Una vez creado el diagrama proseguimos a insertar el codigo a nuestro Arduino el cual es el
Siguiente:

int buzzer = 8;
void setup ()
{

pinHode (buzzer, OUTPUT); // sets the pin as output

void loop()
{

d i gi t a l C Tii t e ( b u z z e r,1 2 3 ) ; / / e m i t e s o n l d o d e l a y ( S O O ) ;
/ / e 3 p e r a m e d i o s e c u n d o d i gi t a l U r i t e ( b u z z e r, L O W ) ; / / d e j a d e
e m i t i r d e l a y ( 5 0 0 ) ; / / e s p e r a m e d i o s e gu t i d o
}

Practica 6.1: Aplicando Tonos

En esta practica aprenderemos a crear tonos y usando la comunicacion SERIAL podremos
reproducir los tonos as! como su orden en que se escucharan, Recordemos que el Buzzer
puede tanto ser un Zumbador como puede reproducir sonidos que se encuentran en rango de
los 8 bits.

Materiales:

Un Buzzer
Una Protoboard
5 Resistencias de 220Q
5 LEDS

Diagrama:

fritting

Una vez terminado el diagrama procedemos a crear nuestro codigo en Arduino de la

siguiente manera:

/ D E C L AR A C I O N D E P I N
E O C I N A int pinBuzzer = 8;
/ / D E C L A R A M O S L O S P I N E S D E N T R O D E U N AP R E G L O PAR A L O S L E D S
int ledPin[]={2,3,4,5,6};\

/7PONEMOS EL B7TE DE ENTRADA EN 0 int inYte=0;

void setup() {

//Airimos el puento de comunicacion con una velocidad de 9600

S e r i a l . b e gi n ( 9 6 0 0 ) ;
//Declaramos los pines de entrada de LEDS y de la EOCINA
i=0; i<5;i++){ p i n M o d e ( l e d P i n [ i ] , O U T P U T ) ;
p i n K o d e ( p i n B u z z e r, O U T P U T ) ;

1
}

void loop() {
if (Serial.available() >0) {
inByte = Serial.read();
if(inByte==1 a1){
digitalWrite(ledPin[0], HIGH);

tone(pinBuzzen,50C);
delay(200);
n o Ton e ( p i n B u z z e r ) ;

digital!rite (ledPin[0], LOU);

}

or(int

else If(inByte=='b 1){

d i gi t a l W ri t e ( l e d P i n [ l ] , H I G H ) ;

tone(pinBussen,10D0);
d e l a y ( 2 0 0 ) ; n o Ton e ( p i n B u z z e t ) ;

digitalUrite(ledPinfl], LOU);

}
else if(inByte==1c1){
digitalWtite(ledPin[2], HIGH);
t o n e ( p i n B u z z e E , 1 5 0 0 ) ; delay(200);
n o Ton e ( p i n B u z z e t ) ;
digitalWtite(ledPin[2], LOW); }

else if(inByte== 1 d 1 ){
d i gi t a l W t i t e ( l e d P i n [ 3 ] , H I G H ) ;
tone(pinBuzzet,2000); delay(200);
n o Ton e ( p i n B u z z e t ) ;
d i gi t a l W t i t e ( l e d P i n [ 3 ] , L O W ) ; } e l s e
if(inEyte==1e1){

digitalUrite(ledPin[4], HIGH);
tone(pinBuzzet,2500); delay(200);

noTone(pinBuzser) ;
d i gi t a l W t i t e ( l e d P i n [ 4 ] , L O W ) ;
}

Serial. print (char (inEyte) );

0
Al finalizar de crear nuestro codigo lo siguiente sera introducir las letras que hemos
programado, las cuales cada letra tendra un determinado TONO el cual se encuentre dentro
del RANGO permitido.

Y asi es como podemos crear tonos dentro de nuestra Arduino usando un Buzzer.

Practica 7: Uso de una fotoresistencia como sensor de luz

La Practica realiza un montaje con una placa Arduino Mega y un sensor LDR (Light
Dependent Resistor o resistencia dependiente de la luz) detectando un nivel de luz a partir
del cual se conecta un diodo LED. Este circuito se puede utilizar como un interruptor
crepuscular.

Materiales:

Dos resistencias de 220 Q (Rojo, rojo, cafe, dorado)

Un diodo LED
Una protoboard
Un sensor LDR

Diagrama:

Antes de empezar debemos conocer el componente nuevo que vamos a integrar a nuestra
Practica que es Sensor LDR.

i Que es ?
Un LDR (Light Dependent Resistor) es una resistencia que varia su valor en funcion de la luz
recibida, cuanta mas luz recibe, menor es su resistencia.
Para la conexion de un LDR a nuestro Arduino debemos hacer el divisor de tension, de donde
sacaremos la senal para conectar a nuestra entrada analogica.

Una vez creado el diagrama proseguimos a insertar el codigo a nuestro Arduino el cual es el
Siguiente:

Practica 8: Leer de temperatura

El LM35 es un sensor de temperatura con una precision calibrada de 1C. Su rango de
medicion abarca desde -55C hasta 150C. La salida es lineal y cada grado centigrado
equivale a 10mV.
Sus Terminales

Pi
n

Funcion

Description

Vcc

Alimentacion (5V)

OUT

Salida. Devuelve lo que el sensor a

captado

GND

Conectado a tierra.

2
3

Como vemos, el sensor consta solo de 3 patillas, dos de alimentaciOn y otra que nos entrega
la lectura tomada. Lo hace de forma lineal, cada grado que sube la temperatura son 10mV
mas en esta salida. Importante de frente al sensor el voltaje va de lado izquierdo.

Materiales:

Un Sensor de temperatura LM35

Un Protoboard
Dos Led
Dos Resistencias de 220Q

Diagrama:

Importante teniendo el sensor de temperatura de frente (el frente del sensor es la parte chata,
con los pines para abajo), el pin izquierdo es el polo positivo.

El codigo se muestra a continuation:

Practica 9: Encender Led desde Pagina Web

En esta practica se trata de encender y apagar un LED a traves de Internet y, para ello, vamos
a utilizar el Shield Ethernet Arduino. Seran necesarios unos conocimientos basicos de HTML,
simplemente para poder hacer la pagina Web a nuestro gusto. A traves de esta pagina Web,
podremos encender y apagar nuestra bombilla cuando queramos. Desde el ordenador, iPad,
tablet, o cualquier dispositivo con conexion WI-FI.

Arduino Shield Ethernet

Caracteristicas de ethernet shield:

La Arduino Ethernet Shield permite a una placa Arduino conectarse a una red
(internet), provee de una pila de red IP capaz de soportar TCP y UDP.
El shield provee un conector ethernet estandar RJ45.
La ethernet shield dispone de unos conectores que permiten conectar a su vez otras
placas encima y apilarlas sobre la placa Arduino.
Nuestro shield se puede conectar como un servidor, un cliente o de ambas formas
alternando una con otra.

La shield contiene un numero de LEDs para information:

PWR: indica que la placa y la shield estan alimentadas

LINK: indica la presencia de un enlace de red y parpadea cuando la shield envia o
recibe datos.
FULLD: indica que la conexion de red es full duplex.
100M: indica la presencia de una conexion de red de 100 Mb/s (de forma opuesta a
una de 10Mb/s).

RX: parpadea cuando la shield recibe datos.

TX: parpadea cuando la shield envia datos.
COLL: parpadea cuando se detectan colisiones en la red.

Arduino usa los pines digitales 10, 11, 12, y 13 (SPI) para comunicarse con la ethernet
shield. Estos pines no pueden ser usados para entradas/salidas genericos.

Materiales:
1 protoboard.
1 diodo LED.
1 resistencia 220Q.
1 Arduino 1
Shield Ethernet

Diagrama: Utilizaremos el diagrama del hola mundo

Lo que vamos a crear con el Ethernet Shield, es un servidor Web, el cual nos proporcionara el
codigo HTML para poder verlo en nuestro navegador y poder, asi, interactuar con el.
En este caso no vamos a utilizar la red Internet sino que lo haremos a nivel local en lo que se
denomina una red LAN (Red de Area Local). Para acceder a la pagina Web que creemos,
deberemos acceder con una direccion IP perteneciente a nuestra red.
La red asignara una ip a nuestro shield al momento de conectarlo mediante el cable Ethernet,
para verificarlo podemos hacerlo desde el Comando del sistema con la instruction IPCONFIG
o desde las configuraciones del router.
Cargaremos el siguiente sketch para esto necesitaremos la IP que le fue asignada al Shiled y
su direccion MAC, en este Caso la IP sera 192.168.1.6 y la MAC que utilizaremos sera una
Universal 0xDE,0xAD,0xBE,0xEF,0xFE,0xED pero tambien se podra utilizar la MAC que ya
viene asignada al shield.

#include <SPI.h>
^include <Ethernet.h> // Incluye la libreria Ethernet
// Esta libreria Reaiiza la conexion de nuestro shield cocao cliente o servidor
//Declaracion de la direcciones MAC e IP. Tambien del puerto SO
byte mac[]={0xDE,0xAD,0xEE,0xEF,0xFE,0xED}; //MAC Universal IPAddress
ip(192,168,1,6); //IP asignada por la red al ARduino EthernetServer
servidor(80); //puerto del servidor, por default es el 80 int PIE _LED=8;
//Variable Lea String readString=3tring(30) ;
String state=String(3); //variable de estado
void

setup() {

Ethernet.begin(mac, i p ) ; //Inicializamos con las direcciones asignadas

servidor.begin(); // iniciamos como servidor al Arduino
pinMode(PIN_LED,OUTPUT); //declaramos la variable LED como salida
digitalUrite(PIN_LED,L0U) ; // Inicializamos la variable LED en LOU
state= r r 0FF r r ; //Inicializamos la variable con el estado en OFF
}

void loop() {
E the rne tC1ient c1iente = s e rvido
r.avai1ab1e(); if(cliente) { //Cliente conectado
b o o 1 e an 1ine aenb1anc o=true;
while(cliente.connected()) { //Leemos peticion HTTP caracter a caracter
if(cliente.available()) { char c=cliente.read(); if(readstring.length()<30) {
readstring.concat(c);//Almacenar los caracteres en la variable readString
}

if(c=='\n'
1 ine aenb 1 anc o) { //Si la peticion HTTP ha finalizado
int LED = r e adS tr ing. index 0 f (" LED= r r );
if (readString. substring(LED,LED+5)
== r r LED=T r r ) {
digitalUrite(PIN_LED,HIGH); state="0N r r ;
}

else if (readString. substring (LED, LED+5)

== r r LED=F r r ) { di gi talUr i te (P IN_LED, L OIJ);
state= r r 0FF r r ;
}

//Cabecera HTTP estandar

cliente. println ("HTTP/l. 1 200 0Krr); cliente.pEintln(''Content-Type: text/html"); cliente.printlnO; //Pagina eb an HTML
cliente.println("<html>"); cliente. println(,r<head>"); cliente.println("<title>LED 0N/0FF</title>rr);
cliente.println("</head>");
cliente.println(,r<bodY widtb=100% height=100%>");
cliente.println(,r<center>r');
cliente.println("<hl>Led 0N/0FF</hl>");
cliente.pEint( r, <br><br>") ;
cliente.print("Estado del LED:
cliente.print(state);
cliente. p r int ("<b rXb rxb rXb r>rr);
cliente.println("<input type=submit value=0 style=uidth:200px;height:75px onClick=location.href='./?LED=T\;
cliente.println("Cinput type=subiiiit value=0FF style=width:200px;height:75px onClick=location.href=' ./?LED=F\ '>");
cliente. println("</center>,r);
cliente. println("</body>,r);
cliente.println("</html>");
cliente.3top ();
//Cierro conexion con el cliente reads tr:ng=rrrr;
}
}
}

}
}

La pagina queda como a continuation se muestra:

El codigo de la pagina web se muestra a continuation:

#include <SPI.h>
#include <Ethernet.h>
// Enter a MAC address and IP address for your controller below. //
The IP address will be dependent on your local network: byte mac[]
= {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; IPAddress
ip(192,168,1,66);
EthernetServer server(80); int PIN_LED=8;
String readString=String(30);
String state=String(3); void setup(){
Ethernet.begin(mac, ip);
server.begin();
pinMode(PIN_LED,OUTPUT);
digitalWrite(PIN_LED,LOW);

state="OFF";
}
void loop(){
EthernetClient client = server.available(); if (client) {
booleancurrentLineIsBlank = true; while (client.connected()) { if (client.available())j char
c=client.read(); if (readString.length()<30){ readString.concat(c);
}
if (c=='\n' &&currentLineIsBlank){
int LED = readString.indexOf("LED=");
if (readString.substring(LED,LED+5)=="LED=T"){
digitalWrite(PIN_LED,HIGH);
state="ON";
i
else if (readString.substring(LED,LED+5)=="LED=F"){
digitalWrite(PIN_LED,LOW);
state="OFF";
}
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println();
client.println("<html>");
client.println("<head>");
client.println("<title>LED ON/OFF </title>");
client.println("</head>");
client.println("<body width=100% height=100%>"); client.printin("<center>M);
client.println("<h1>Led ON/OFF</h1>");
client.println("<br><br>");
client.println("Estado del LED:");
client.println(" br br br><br>");
client.println("<input
type=submit
value=ON
sty l e=wi dth:200px;height;75px
onClick=location.href='./?LED=T\'>");
client.println("< input
type=submit
value=OFF
style=width:200px;height:75px
onClick=location.href='./?LED=F\'>");
M
M
client.printin( </center> );
client.println("</body>");
client.printin(M</htmi>M); client.stop();
readString="";

i
}
i
}

PracticalO: Almacenar Temperatura en MYSQL

En la siguiente practica se leera una temperatura utilizando el sensor LM35 y esta se
almacenara en una tabla en MYSQl.
Se debera contar con un servidor web, de preferencia utilizar XAMPP, el cual incluye el MYSQL.

A continuation se muestra la estructura de la tabla que almacenara las temperaturas en una

base de datos llamada Arduino:
Create Table Temperatura( idTemp Int Not Null Auto_Increment,
Valor numeric(8,2),
Fecha Datetime,
Constraint pktemp Primary key (idTemp)
)
La pagina de PHP que insertara las temperaturas en MYSQL se llama prueba.php y enseguida se muestra el
codigo:
<?php
$temp = htmlspecialchars($_GET["temp"],ENT_QUOTES);
mysql_connect('localhost','root','hola');
mysql_select_db('arduino');
mysql_query("insert into temperatura(valor,fecha) values ($temp,NOW())");
mysql_close();
?>
La ubicacion de esta pagina sera en htdocs/arduino

Materiales:

Un Sensor de temperatura LM35

Un Protoboard

Diagrama:

Al ignal que en el ejercicio anterior utilizaremos el Ethernet shield y deberemos detectar las
direcciones IP, asignadas tanto al shield como al servidor web, para hacer referenda a estas
desde la programacion de Arduino.
El cOdigo de Arduino se muestra a continuaciOn:

|pinclude <SFI.h>
include <Ethernet.h>
b y t e m a c [ ] = { O x D E , O x AD , O x B E , O x E F, O x F E , O x E D } ; b yt e i p [ ] =
{ 1 9 2 , 1 6 8 , 1 , 6 6 } ; 11 I P As i gn a d a a l Ar d u i n o b y t e s e r v e r [ ] = { 1 9 2 , 1 6 8 , 1 , 6 4 } ;
/ / I P del servidor web
EthernetClient client;
i n t . a n a l o g_ p i n = 0 ; 11 P i n p a r a e l s e n s o r d e Tem p e r a t u r a AO i n t . t e m p ;
void setup(){
S e r i a l . b e gi n ( 9 6 0 0 ) ;
E t h e r n e t . b e gi n ( m a c , i p ) ; / / I n i c i a l i z a l a d i r e c c i o n d e l s h i e l d
}

void loop(){
t e m p = a n a l o gR e a d ( a n a l o
g_pin);
temp=5.0*temp*100/1024;

//Lee el valor del sensor de temperatura 11

Calcula la temperatura de centigrados

Serial.print(temp);
Serial.printin(" oC rr);
Serial.println("Conectando..."); if(client.connect(server, 8 0 ) ) {
client.print("GET /arduino/prueba.php?temp="); c1ient.p
rint(temp); client.println(" HTTP/1.0"); client.println();
Serial.p rintin("C one c tado);
}else{
Serial.println("Error de Conexion");
}

if(client.connected()){} else {
Serial.p rintln["D e s c one c tado");
}

client.stop(); client.flush(); delay(5000);

Para ejecutarlo, solo hay que cargar el programa en el arduino y enseguida empezara a
insertar en la base de datos las temperaturas.

Practica 11: Sensor Ultrasonidos HC-SR04 para Medir

Distancia
El sensor de ultrasonidos se enmarca dentro de los sensores para medir distancias o superar
obstaculos, entre otras posibles funciones.
En este caso vamos a utilizarlo para la medicion de distancias. Esto lo consigue enviando un
ultrasonido (inaudible para el oido humano por su alta frecuencia) a traves de uno de la pareja
de cilindros que compone el sensor (un transductor) y espera a que dicho sonido rebote sobre
un objeto y vuelva, retorno captado por el otro cilindro.

Este sensor en concreto tiene un rango de distancias sensible entre 3cm y 3m con una
precision de 3mm.

^Que recibimos en el sensor? El tiempo que transcurre entre el envm y la recepcion del
ultrasonido.

^Como vamos a traducir dicho tiempo en distancia? Aprovechando que la velocidad de

dicho ultrasonido en el aire es de valor 340 m/s, o 0,034 cm/microseg (ya que trabajaremos
con centimetros y microsegundos). Para calcular la distancia, recordaremos que v=d/t
(definition de velocidad: distancia recorrida en un determinado tiempo).
De la formula anterior despejamos d, obteniendo d=v * t, siendo v la constante anteriormente
citada y t el valor devuelto por el sensor a la placa Arduino.
Tambien habra que dividir el resultado entre 2 dado que el tiempo recibido es el tiempo de ida y
vuelta.

Aplicaciones y ventajas
Debido a sus caracteristicas, podemos encontrar sensores de ultrasonidos en aplicaciones
como:
Medicion de nivel - en tanques que contienen diferentes productos en forma liquida-.
Control de colisiones en sistemas de aparcamiento.
Control de position en campos como robotica, industria del plastico, etc.
Control de llenado de tanques.
Las principales ventajas de estos sensores son:
No necesitan contacto fisico para poder detectar objetos.
Buena relation calidad-precio
En comparacion con otras tecnologias, los dispositivos basados en ultrasonidos son
compactos y livianos.

Materiales:
1 Sensor ultrasonidos HC-SR04
1 Arduino Mega

Diagrama:

fritting

El sensor consta de 4 pines: "VCC". Conecte el pin VCC a la salida de 5V de la placa, el pin
"Trig" conectarlo al pin ~9 digital de la placa encargado de enviar el pulso ultrasonico, el pin
"Echo" al pin 8 digital que recibira el eco de dicho pulso y por ultimo el pin "GND" a tierra.

Codigo de Arduino
Long distancia;
long tiempo;
void setup(){
Serial.begin (9600);
pinMode(9, OUTPUT); /*activacion del pin 9 como salida: para el pulso
ultrasonico*/
pinMode(8, INPUT); /*activacion del pin 8 como entrada:
tiempo del
rebote del ultrasonido*/
}
void loop (){
digitalWrite(9,LOW); /* Por cuestion de estabilizacion del sensor*/
delayMicroseconds(5);
digitalWrite(9, HIGH); /* envio del pulso ultrasonico*/
delayMicroseconds(10);
tiempo=pulseIn(8, HIGH); /* Funcion para medir la longitud del pulso
entrante. Mide el tiempo que transcurrido entre el envio
del pulso ultrasonico y cuando el sensor recibe el rebote, es decir:
desde que el pin 12 empieza a recibir el rebote, HIGH, hasta que deja de
hacerlo, LOW, la longitud del pulso entrante*/ distancia=
int(0.017*tiempo); /*formula para calcular la distancia obteniendo un
valor entero*/
/*Monitorizacion en centimetros por el monitor serial*/
Serial .printlni'"Distancia ");
Serial.println(distancia);
Serial.println(" cm");
delay(1000);
}

Practica 12: Sensor Ultrasonidos HC-SR04 para

estacionar un vehfculo
Realizaremos un completo sistema de alarma en funcion de la distancia, que por ejemplo
podria usarse como un sensor de aparcamiento o de obstaculos en un vehiculo. Para ello
anadimos 2 componentes al sistema: el LED (2) y el buzzer. El esquema se muestra a
continuation:

Materiales:
1
2

1 Sensor ultrasonidos HC-SR04

Arduino Mega
Led (Uno Rojo y otro Verde)
2 Resistencias de 220Q.
1 protoboard.

Diagrama:

Cuando un objeto se acerque a una distancia que consideremos peligrosa haremos sonar el
buzzer y encenderemos un LED rojo, cuando no haya obstaculos cerca encenderemos un
LED verde. El sistema por lo tanto tiene tanto indicadores visuales como acusticos.
Como antes, definimos primero que pines de Arduino utilizamos y como los conectamos
con los diferentes dispositivos. Respecto a la primera parte se anaden los Leds rojo y verde,
que conectaremos en los pines de Arduino 6 y 5 respectivamente, y un buzzer que
conectaremos con el pin 4.

//Proqramacion de un sensor de aparcamiento con alarma visual y acustica

Int
Int
Int
Int
Int

Pin_echo = 13;
Pin_trig = 12;
Pinrojo=6;
Pinverde=5;
buzzer=4;

voidsetupW {
Serial.begin (9600);
pinMode(Pinverde,OUTPUT); //Definimos los pines
pinMode(Pinrojo, OUTPUT);
pinMode(buzzer,OUTPUT); pinMode(Pin_trig,
OUTPUT); pinMode(Pin_echo, INPUT);
}
voidloop'i {
intduracion, cm;
digitalWrite(Pin_trig, LOW); delayMicroseconds
(2); digitalWrite(Pin_trig, HIGH);
delayMicroseconds (10); digitalWrite(Pin_trig,
LOW); duracion = pulseIn(Pin_echo, HIGH); cm =
duracion / 29 / 2;
Serial .printWDistancia:");
Serial.printiom);
Serial.printlni" cm");
if(cm>20)
//20 cm es la distancia de
emergencia
{
digitalWritefPinverde, HIGH);
//En caso que un objeto este lejos,
pintamos el LED verde
digitalWrite(Pinrojo, LOW);
digitalWrite(buzzer, LOW);
}
else if(cm<20)
{
digitalWriteiPinverde, LOW); //Si el objeto esta muy cerca, hacemos
sonar la alarma buzzer y el LED rojo
digitalWrite(Pinrojo, HIGH);
digitalWrite(buzzer, HIGH);
}
delay(500);
}