ESCUELA NACIONAL SUPERIOR AUTNOMA DE BELLAS ARTES DEL PER

SEMINARIO DE ARTES ELECTRNICAS

PROGRAMAS EJEMPLO ARDUINO
PROGRAMA 01
TEMAS:
FUNCIONES:

SALIDA DIGITAL
pinMode(), digitalWrite(), delay()

Se tiene conectado al Arduino UNO un

led por medio del pin de entrada y salida
digital D3 tal como se muestra en el
circuito.
Desarrollar un programa que haga
parpadear el led indefinidamente, de tal
manera que permanezca 500ms
encendido y 500ms apagado.

1K
D3

ARDUINO UNO

SOLUCIN
/******************************************************************/
/******************************************************************/
/*****
ESCUELA NACIONAL DE BELLAS ARTES DEL PER
*****/
/*****
SEMINARIO DE ARTES ELECTRNICAS
*****/
/******************************************************************/
/*****
Plataforma: Arduino UNO
*****/
/*****
Programa:
P01_LedParpadeo.ino
*****/
/*****
Autor:
Arduino
*****/
/*****
https://www.arduino.cc/en/Tutorial/Blink
*****/
/*****
Revisin:
Rolando Snchez
*****/
/*****
Fecha:
Julio 2015
*****/
/******************************************************************/
/*****
Descripcin: Se tiene un led conectado a la patita *****/
/***** 3 del mdulo Arduino, este led parpadea permaneciendo *****/
/***** 500ms encendido y 500ms apagado.
*****/
/******************************************************************/
/******************************************************************/
// LAS FUNCIONES EN setup() SE EJECUTAN UNA SOLA VEZ AL INICIO
void setup() {
pinMode(3, OUTPUT);
// Configuramos el pin 3 como salida.
}
// LAS FUNCIONES EN loop() SE EJECUTAN CONSTANTEMENTE EN UN LAZO.
void loop() {
digitalWrite(3, HIGH);
// Encendemos el led.
delay(500);
// Esperamos durante 500ms.
digitalWrite(3, LOW);
// Apagamos el led.
delay(500);
// Esperamos durante 500ms.
}
/******************************************************************/
/*****
FIN DEL PROGRAMA
*****/
/******************************************************************/

PROGRAMA 02
TEMAS:
FUNCIONES:

ENTRADA DIGITAL
digitalRead()

Tenemos conectado al Arduino UNO un led (en el pin de entrada y salida digital D3) y un pulsador
(pin D5) tal como se muestra en el grfico.
5V

10K
D5

1K
D3

P0

ARDUINO UNO
Se pide desarrollar un programa que encienda el led mientras el pulsador est sin presionar y
haga parpadear el led (100ms encendido y 300ms apagado) mientras el pulsador est siendo
presionado.

SOLUCIN
/******************************************************************/
/******************************************************************/
/*****
ESCUELA NACIONAL DE BELLAS ARTES DEL PER
*****/
/*****
SEMINARIO DE ARTES ELECTRNICAS
*****/
/******************************************************************/
/*****
Plataforma: Arduino UNO
*****/
/*****
Programa:
P02_PulsadorLed.ino
*****/
/*****
Autor:
Rolando Snchez
*****/
/*****
Fecha:
Julio 2015
*****/
/******************************************************************/
/*****
Descripcin: Se tienen conectado al Arduino un led *****/
/***** (pin D3) y un pulsador (pin D5). Cuando el pulsador
*****/
/***** est sin preionar el led est encendido y cuando est *****/
/***** presionado el led parpadea: 100ms encendido y 300ms
*****/
/***** apagado.
*****/
/******************************************************************/
/******************************************************************/
int pulsador;

// definimos la variable 'pulsador'

void setup() {
pinMode(3, OUTPUT);
pinMode(3, INPUT);
}

// Configuramos el pin 3 como salida.

// Pin 5 configurado como entrada.

void loop() {
// Leemos el estado del pin 5
pulsador = digitalRead(5);
// Si el pulsador no est presionado se lee HIGH
if(pulsador==HIGH){
// Encendemos el led
digitalWrite(3, HIGH);
}

// Si el pulsador est presionado se lee LOW

if(pulsador==LOW){
// Hacemos parpadear al led
digitalWrite(3, HIGH);
delay(100);
digitalWrite(3, LOW);
delay(300);
}
}
/******************************************************************/
/*****
FIN DEL PROGRAMA
*****/
/******************************************************************/

PROGRAMA 03
TEMAS:
FUNCIONES:

ENTRADA ANALGICA SENSOR DE LUZ MONITOR SERIE

analogRead()

Se tiene conectado al Arduino una fotorresistencia (sensor de luz) a uno de sus pines de entrada
analgica, se quiere visualizar el valor de la entrada analgica en una computadora personal.
5V

10K
A0

D0
D1

ARDUINO UNO

SOLUCIN 01
Ejecutar el siguiente programa en Arduino.
/******************************************************************/
/******************************************************************/
/*****
ESCUELA NACIONAL DE BELLAS ARTES DEL PER
*****/
/*****
SEMINARIO DE ARTES ELECTRNICAS
*****/
/******************************************************************/
/*****
Plataforma: Arduino UNO
*****/
/*****
Programa:
P03a_AnalogTst.ino
*****/
/*****
Autor:
Arduino
*****/
/*****
https://www.arduino.cc/en/Tutorial/AnalogReadSerial *****/
/*****
Revisin:
Rolando Snchez
*****/
/*****
Fecha:
Agosto 2015
*****/
/******************************************************************/
/*****
Descripcin: Lee la seal analgica en el pin A0
*****/
/***** e imprime el valor digitalizado en el monitor serial. *****/
/******************************************************************/
/******************************************************************/
// Definimos la variable "entradaAnlg"
int entradaAnlg;
void setup() {
// Inicializamos comunicacin serial
Serial.begin(9600);
}
void loop() {
// Leemos la entrada analgica A0:
entradaAnlg = analogRead(A0);
// Imprimimos el resultado en el monitor serial
Serial.println(entradaAnlg);
delay(100);
}
/******************************************************************/
/*****
FIN DEL PROGRAMA
*****/
/******************************************************************/

Para ver los valores que transmite Arduino debemos ejecutar el terminal serial. Para esto ingrese
a Herramientas y d clic sobre Monitor Serie:

Debe aparecer una ventana donde se muestra el valor digitalizado de la entrada analgica:

Como se ve cuanto ms luz le llega al sensor el valor digitalizado disminuye.

SOLUCIN 02
Ejecutar el siguiente programa en Arduino:
/******************************************************************/
/******************************************************************/
/*****
ESCUELA NACIONAL DE BELLAS ARTES DEL PER
*****/
/*****
SEMINARIO DE ARTES ELECTRNICAS
*****/
/******************************************************************/
/*****
Plataforma: Arduino UNO
*****/
/*****
Programa:
P03_AnalogTst.ino
*****/
/*****
Autor:
Rolando Snchez
*****/
/*****
Fecha:
Agosto 2015
*****/
/******************************************************************/
/*****
Descripcin: Lee la seal analgica en el pin A0
*****/
/***** y transmite el valor digitalizado por el puerto
*****/
/***** serial.
*****/
/***** En la PC debe ejecutarse el programa AnalogTst.pde
*****/
/***** escrito en processing.
*****/
/******************************************************************/
/******************************************************************/
// Definicin de variables
int entradaANLG, datoLOW, datoHIGH;
void setup() {
// Inicializamos la comunicacin serial.
Serial.begin(9600);
}
void loop() {
// Leemos la entrada analgica
entradaANLG = analogRead(A0);
// Separamos el valor digitalizado en dos bytes
datoLOW = entradaANLG&255;
datoHIGH = entradaANLG/256;
// Transmitimos por el puerto serial los dos bytes
Serial.write(datoLOW);
Serial.write(datoHIGH);
// Retardo para estabilizar
delay(100);
}
/******************************************************************/
/*****
FIN DEL PROGRAMA
*****/
/******************************************************************/

Y en la PC debe ejecutarse este programa en Processing

/******************************************************************/
/******************************************************************/
/*****
ESCUELA NACIONAL DE BELLAS ARTES DEL PER
*****/
/*****
SEMINARIO DE ARTES ELECTRNICAS
*****/
/******************************************************************/
/*****
Lenguaje:
Processing
*****/
/*****
Programa:
AnalogTst.pde
*****/
/*****
Autor:
Rolando Snchez
*****/
/*****
Fecha:
Agosto 2015
*****/
/******************************************************************/
/*****
Descripcin: Muestra grficamente el valor de la
*****/
/***** seal analgica digitalizada que es transmitida por
*****/
/***** un Arduino utilizando el puerto serial.
*****/
/***** La PC debe estar conectada por el puerto serial a un *****/
/***** Arduino donde se debe estar ejecutando el programa:
*****/
/***** P03_AnalogTst.ino.
*****/

/******************************************************************/
/******************************************************************/
// Importamos librerias y declaramos variables globales
import processing.serial.*;
Serial ptoSerial;
PFont fuente;
int datoRx, datoPrint;
boolean hayDato=false;
boolean datoLOW=false;
boolean primerDato=true;
int antX=0;
int antY=0;
int X=21;
// Configuramos el sistema
void setup(){
println(Serial.list());
ptoSerial = new Serial(this, Serial.list()[0], 9600);
fuente = loadFont("CourierNewPS-BoldMT-48.vlw");
textFont(fuente, 16);
size(800, 600);
colorMode(HSB, 360, 100, 100);
dibujaOsciloscopio();
}
// Bucle infinito
void draw(){
// Si hay dato recibido por el puerto serial
if(ptoSerial.available() > 0){
datoRx = ptoSerial.read();
if(datoLOW==false){ // Primero se recibe el byte bajo
datoPrint=datoRx;
datoLOW=true;
}
else{
// y luego se recibe el byte alto
datoPrint=datoPrint+256*datoRx;
datoLOW=false;
hayDato=true;
}
}
// Si se tiene el dato completo (dos bytes) dibujarlo en el osciloscopio
if(hayDato){
if(primerDato){
dibujaOsciloscopio();
stroke(0, 0, 99);
strokeWeight(2);
X=22;
antX=21;
antY= 580 - datoPrint*560/1050;
primerDato=false;
}
else{
line(antX, antY, X, 580 - datoPrint*560/1050);
antX=X;
antY=580 - datoPrint*560/1050;
X++;
if(X==780) primerDato=true;
}
hayDato=false;
}
}

// Funcin que dibuja la pantalla del osciloscopio

void dibujaOsciloscopio(){
int y;
background(120, 60, 40);
// fondo verde oscuro
noFill();
strokeWeight(1);
stroke(120, 90, 90);
// lneas verde claro
rect(20, 20, 760, 560);
for(int i=0; i<=10; i++){
y=580-560*100*i/1050;
line(20, y, 780, y);
text(i*100, 10, y-5);
}
}
/******************************************************************/
/*****
FIN DEL PROGRAMA
*****/
/******************************************************************/

Ejecute el programa Processing, copie el cdigo y d clic sobre el comando Play (flecha)

Este programa nos muestra la misma variable que vimos en la solucin anterior pero de manera
grfica. En el grfico podemos ver los valores que nos entrega el sensor conforme le incida luz.

La imagen mostrada es el resultado de hacer pruebas cuando incide la luz directamente en el

sensor, cuando le llega sombra y cuando est en total oscuridad.

PROGRAMA 04
TEMAS:

ESTRUCTURA CONDICIONAL IF.. ELSE IF .. ELSE

Se conecta al Arduino UNO un sensor de luz y dos leds (L1 y L2), como se ve en el grfico:
5V

10K

A0

1K

D5
1K
D4

ARDUINO UNO

L1

L2

Desarrollar un programa que cumpla con los siguientes requerimientos: si el sensor detecta luz
debe parpadear el led L1 mientras el led L2 debe estar apagado, si se detecta penumbra los dos
leds deben estar encendidos, y si se detecta oscuridad los leds deben parpadear
alternadamente: cuando L1 est encendido L2 debe estar apagado y viceversa.
SOLUCIN
Para la solucin de este problema usemos los resultados del ejercicio anterior. Podemos dividir
el grfico en tres zonas: luz, penumbra y oscuridad; y podemos tomar los valores 300 como el
lmite entre luz y penumbra, y 760 como el lmite entre penumbra y oscuridad.

/******************************************************************/
/******************************************************************/
/*****
ESCUELA NACIONAL DE BELLAS ARTES DEL PER
*****/
/*****
SEMINARIO DE ARTES ELECTRNICAS
*****/
/******************************************************************/
/*****
Plataforma: Arduino UNO
*****/
/*****
Programa:
P04_LedLuz.ino
*****/
/*****
Autor:
Rolando Snchez
*****/
/*****
Fecha:
Setiembre 2015
*****/
/******************************************************************/
/*****
Descripcin: Se tiene conectado un sensor de luz
*****/
/***** (A0) y dos leds: L1 (D4) y L2(D5). Cuando el sensor
*****/
/***** detecta luz parpadea L1 y se apaga L2, si detecta pe- *****/
/***** numbra ambos leds se encienden y cuando detecta oscu- *****/
/***** ridad ambos leds parpadean alternadamente: L1 encen- *****/
/***** dido L2 apagado y viceversa.
*****/
/***** Se toma 300 como lmite entre luz y penumbra, y 760
*****/
/***** como lmite entre penumbra y oscuridad.
*****/
/******************************************************************/
/******************************************************************/
// Definimos etiquetas para los leds conectados en D4 y D5
#define pinL1 4
#define pinL2 5
// Declaramos variables
int sensorLuz;
void setup() {
// Configuramos pines digitales
pinMode(pinL1, OUTPUT);
pinMode(pinL2, OUTPUT);
}
void loop() {
// Leemos la entrada analgica A0 en sensorLuz:
sensorLuz = analogRead(A0);
if(sensorLuz<=300){
// Si hay LUZ
digitalWrite(pinL2, LOW);
//
apagamos L2
digitalWrite(pinL1, HIGH); //
parpadea L1
delay(200);
digitalWrite(pinL1, LOW);
delay(200);
}
else if((sensorLuz>300)&&(sensorLuz<760)){
digitalWrite(pinL1, HIGH); // Caso contrario, si hay PENUMBRA
digitalWrite(pinL2, HIGH); //
encendemos L1 y L2
}
else{
digitalWrite(pinL1, LOW);
// Caso contrario
digitalWrite(pinL2, HIGH); //
parpadear L1 y L2
delay(300);
digitalWrite(pinL1, HIGH);
digitalWrite(pinL2, LOW);
delay(300);
}
delay(50);
}
/******************************************************************/
/*****
FIN DEL PROGRAMA
*****/
/******************************************************************/

PROGRAMA 05
TEMAS:
FUNCIONES:

PARLANTE
tone(), noTone()

Se tiene la siguiente conexin. Se quiere desarrollar un programa que emita el sonido de una
alarma por el parlante.
5V

+
D2

1K
2N3904

ARDUINO UNO

SOLUCIN
/******************************************************************/
/******************************************************************/
/*****
ESCUELA NACIONAL DE BELLAS ARTES DEL PER
*****/
/*****
SEMINARIO DE ARTES ELECTRNICAS
*****/
/******************************************************************/
/*****
Plataforma: Arduino UNO
*****/
/*****
Programa:
P05_Spk.ino
*****/
/*****
Autor:
Rolando Snchez
*****/
/*****
Fecha:
Setiembre 2015
*****/
/******************************************************************/
/*****
Descripcin: Se tienen conectado un parlante al
*****/
/***** Arduino por el pin D2. El programa emite una alarma
*****/
/***** por este parlante.
*****/
/******************************************************************/
/******************************************************************/
#define pinSPK 2
void setup() {
// Configuramos el pin como salida
pinMode(pinSPK, OUTPUT);
}
void loop() {
// Se emite sonido a una frecuencia baja: 500Hz
tone(pinSPK, 500);
delay(200);
// Se emite un sonido de frecuencia alta: 1000Hz
tone(pinSPK, 1000);
delay(300);
// No se emite ningn sonido
noTone(pinSPK);
delay(100);
}
/******************************************************************/
/*****
FIN DEL PROGRAMA
*****/
/******************************************************************/

PROGRAMA 06
TEMAS:
FUNCIONES:

SENSOR DE DISTANCIA
distHCSR04()

Se tiene conectado al Arduino UNO un sensor de distancia HC-SR04, se quiere desarrollar un

programa que muestre en una computadora la distancia, en centmetros, entre dicho sensor y
cualquier objeto que tenga al frente.

5V
HC-SR04
Vcc
Trig
Echo
Gnd

D7
D8

D0
D1

ARDUINO UNO

SOLUCIN
/******************************************************************/
/******************************************************************/
/*****
ESCUELA NACIONAL DE BELLAS ARTES DEL PER
*****/
/*****
SEMINARIO DE ARTES ELECTRNICAS
*****/
/******************************************************************/
/*****
Plataforma: Arduino UNO
*****/
/*****
Programa:
P06_SnsrDist.ino
*****/
/*****
Autor:
Rolando Snchez
*****/
/*****
Fecha:
Setiembre 2015
*****/
/******************************************************************/
/*****
Descripcin: Se conecta al Arduino un sensor de
*****/
/***** distancia de ultrasonido HC-SR04. Este programa cal- *****/
/***** cula la distancia del sensor a algn objeto y la
*****/
/***** transmite por el puerto serial en centmetros.
*****/
/***** Se muestra en el Monitor Serie de Arduino.
*****/
/******************************************************************/
/******************************************************************/
// Definimos los pines que se conectan al sensor HC-SR04
#define pinTrig 7
// Trigger lo conectamos a D7
#define pinEcho 8
// Echo lo coenectamos a D8
// Declaramos variables:
unsigned int distancia;
void setup() {
Serial.begin(9600);
pinMode(pinTrig, OUTPUT); // Configuramos Triger como SALIDA
pinMode(pinEcho, INPUT); // y Echo como ENTRADA.
}
void loop() {
// La funcin distHCSR04() devuelve el valor de la distancia en cm.
distancia = distHCSR04();

// Transmitimos los datos para mostrar la distancia en el Monitor.

Serial.print('<');
Serial.print(distancia);
Serial.print("cm>");
delay(500);
}
/******************************************************************/
/***** Funcin: distHCSR04().
*****/
/******************************************************************/
/***** Entrada: Ninguna
*****/
/***** Salida:
Distancia en cm entre el sensor y un objeto.*****/
/*****
0: Si no hay objeto en el rango [5cm, 300cm]*****/
/***** Descripcin: La funcin controla al sensor HC-SR04. *****/
/***** Calcula la distancia en centmetros entre el sensor
*****/
/***** y algn objeto que est al frente.
*****/
/***** Rango de funcionamiento: 5cm - 300cm
*****/
/******************************************************************/
unsigned int distHCSR04(){
unsigned int dist_cm;
digitalWrite(pinTrig, HIGH);
delayMicroseconds(10);
digitalWrite(pinTrig, LOW);
dist_cm = pulseIn(pinEcho, HIGH);
dist_cm = dist_cm/58.2;
if((dist_cm<5)||(dist_cm>300)) dist_cm=0;
return dist_cm;
}
/******************************************************************/
/*****
FIN DEL PROGRAMA
*****/
/******************************************************************/

Debe ejecutar el Monitor Serie de Arduino para visualizar los datos:

Como se ve en el ejemplo, se tiene un objeto que se acerca al sensor desde 32cm hasta 15cm.

PROGRAMA 07
TEMAS:

APLIACACIN DEL SENSOR DE DISTANCIA

Se tiene conectado al Arduino UNO un sensor de distancia y un parlante. Desarrollar un

programa que haga que el parlante emita una alarma cuando algn objeto se acerca al sensor a
una distancia de 30cm o menos.
5V

5V
HC-SR04
Vcc
Trig
Echo
Gnd

+
-

D7
D8
D2

1K
2N3904

ARDUINO UNO

SOLUCIN
/******************************************************************/
/******************************************************************/
/*****
ESCUELA NACIONAL DE BELLAS ARTES DEL PER
*****/
/*****
SEMINARIO DE ARTES ELECTRNICAS
*****/
/******************************************************************/
/*****
Plataforma: Arduino UNO
*****/
/*****
Programa:
P07_DistSpk.ino
*****/
/*****
Autor:
Rolando Snchez
*****/
/*****
Fecha:
Setiembre 2015
*****/
/******************************************************************/
/*****
Descripcin: Se conecta al Arduino un sensor de
*****/
/***** distancia de ultrasonido HC-SR04 y un parlante.
*****/
/***** Si un objeto se acerca al sensor a una distancia de
*****/
/***** 30cm o menos se debe emitir una alarma por el par*****/
/***** lante.
*****/
/******************************************************************/
/******************************************************************/
// Definimos los pines
#define pinTrig 7
//
#define pinEcho 8
//
#define pinSpk 2
//

que se conectan al sensor HC-SR04

Trigger lo conectamos a D7
Echo lo coenectamos a D8
El parlante est conectado a D2

// Declaramos variables:
unsigned int distancia;
void setup() {
pinMode(pinTrig, OUTPUT); // Configuramos Triger como SALIDA
pinMode(pinEcho, INPUT); // y Echo como ENTRADA.
pinMode(pinSpk, OUTPUT); // pin conectado al parlante SALIDA
}
void loop() {
// La funcin distHCSR04() devuelve el valor de la distancia en cm.
distancia = distHCSR04();

if(distancia!=0){
if(distancia<30){
tone(pinSpk, 300);
delay(100);
tone(pinSpk, 1300);
delay(300);
noTone(pinSpk);
delay(200);
}
else noTone(pinSpk);
}
else noTone(pinSpk);

// Si hay un objeto en el rango de medicin

//
Si el objeto esta a menos de 30cm
//
Emitir alarma

//

Caso contrario apagar parlante

// Caso contrario apagar parlante.

}
/******************************************************************/
/***** Funcin: distHCSR04().
*****/
/******************************************************************/
/***** Entrada: Ninguna
*****/
/***** Salida:
Distancia en cm entre el sensor y un objeto.*****/
/*****
0: Si no hay objeto en el rango [5cm, 300cm]*****/
/***** Descripcin: La funcin controla al sensor HC-SR04. *****/
/***** Calcula la distancia en centmetros entre el sensor
*****/
/***** y algn objeto que est al frente.
*****/
/***** Rango de funcionamiento: 5cm - 300cm
*****/
/******************************************************************/
unsigned int distHCSR04(){
unsigned int dist_cm;
digitalWrite(pinTrig, HIGH);
delayMicroseconds(10);
digitalWrite(pinTrig, LOW);
dist_cm = pulseIn(pinEcho, HIGH);
dist_cm = dist_cm/58.2;
if((dist_cm<5)||(dist_cm>300)) dist_cm=0;
return dist_cm;
}
/******************************************************************/
/*****
FIN DEL PROGRAMA
*****/
/******************************************************************/