Pro Gs Arduino
16
ESCUELA NACIONAL SUPERIOR AUTÓNOMA DE BELLAS ARTES DEL PERÚ SEMINARIO DE ARTES ELECTRÓNICAS PROGRAMAS EJEMPLO ARDUINO PROGRAMA 01 TEMAS: SALIDA DIGITAL FUNCIONES: 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. ARDUINO UNO D3 1K SOLUCIÓN /******************************************************************/ /******************************************************************/ /***** ESCUELA NACIONAL DE BELLAS ARTES DEL PERÚ *****/ /***** SEMINARIO DE ARTES ELECTRÓNICAS *****/ /******************************************************************/ /***** Plataforma: Arduino UNO *****/ /***** Programa: P01_LedParpadeo.ino *****/ /***** Autor: Arduino *****/ /***** https://www.arduino.cc/en/Tutorial/Blink *****/ /***** Revisión: Rolando Sánchez *****/ /***** Fecha: Julio 2015 *****/ /******************************************************************/ /***** Descripción: Se tiene un led conectado a la patita *****/ /***** 3 del módulo 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 *****/ /******************************************************************/
-
Upload
eirenen-jesed-mateo-montejo -
Category
Documents
-
view
223 -
download
0
description
programación para arduino uno
Transcript of Pro Gs Arduino
ESCUELA NACIONAL SUPERIOR AUTÓNOMA DE BELLAS ARTES DEL PERÚ SEMINARIO DE ARTES ELECTRÓNICAS
PROGRAMAS EJEMPLO ARDUINO
PROGRAMA 01 TEMAS: SALIDA DIGITAL FUNCIONES: 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.
ARDUINO UNO
D31K
SOLUCIÓN
/******************************************************************/
/******************************************************************/
/***** ESCUELA NACIONAL DE BELLAS ARTES DEL PERÚ *****/
/***** SEMINARIO DE ARTES ELECTRÓNICAS *****/
/******************************************************************/
/***** Plataforma: Arduino UNO *****/
/***** Programa: P01_LedParpadeo.ino *****/
/***** Autor: Arduino *****/
/***** https://www.arduino.cc/en/Tutorial/Blink *****/
/***** Revisión: Rolando Sánchez *****/
/***** Fecha: Julio 2015 *****/
/******************************************************************/
/***** Descripción: Se tiene un led conectado a la patita *****/
/***** 3 del módulo 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: ENTRADA DIGITAL
FUNCIONES: 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 gráfico.
P0
5V
ARDUINO UNO
D31K
D5
10K
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. SOLUCIÓN
/******************************************************************/
/******************************************************************/
/***** ESCUELA NACIONAL DE BELLAS ARTES DEL PERÚ *****/
/***** SEMINARIO DE ARTES ELECTRÓNICAS *****/
/******************************************************************/
/***** Plataforma: Arduino UNO *****/
/***** Programa: P02_PulsadorLed.ino *****/
/***** Autor: Rolando Sánchez *****/
/***** Fecha: Julio 2015 *****/
/******************************************************************/
/***** Descripción: 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); // Configuramos el pin 3 como salida.
pinMode(3, INPUT); // 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: ENTRADA ANALÓGICA – SENSOR DE LUZ – MONITOR SERIE FUNCIONES: analogRead() Se tiene conectado al Arduino una fotorresistencia (sensor de luz) a uno de sus pines de entrada analógica, se quiere visualizar el valor de la entrada analógica en una computadora personal.
5V
ARDUINO UNO
A0 D0
D1
10K
SOLUCIÓN 01 Ejecutar el siguiente programa en Arduino.
/******************************************************************/
/******************************************************************/
/***** ESCUELA NACIONAL DE BELLAS ARTES DEL PERÚ *****/
/***** SEMINARIO DE ARTES ELECTRÓNICAS *****/
/******************************************************************/
/***** Plataforma: Arduino UNO *****/
/***** Programa: P03a_AnalogTst.ino *****/
/***** Autor: Arduino *****/
/***** https://www.arduino.cc/en/Tutorial/AnalogReadSerial *****/
/***** Revisión: Rolando Sánchez *****/
/***** Fecha: Agosto 2015 *****/
/******************************************************************/
/***** Descripción: Lee la señal analógica en el pin A0 *****/
/***** e imprime el valor digitalizado en el monitor serial. *****/
/******************************************************************/
/******************************************************************/
// Definimos la variable "entradaAnlg"
int entradaAnlg;
void setup() {
// Inicializamos comunicación serial
Serial.begin(9600);
}
void loop() {
// Leemos la entrada analógica 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 analógica:
Como se ve cuanto más luz le llega al sensor el valor digitalizado disminuye.
SOLUCIÓN 02 Ejecutar el siguiente programa en Arduino:
/******************************************************************/
/******************************************************************/
/***** ESCUELA NACIONAL DE BELLAS ARTES DEL PERÚ *****/
/***** SEMINARIO DE ARTES ELECTRÓNICAS *****/
/******************************************************************/
/***** Plataforma: Arduino UNO *****/
/***** Programa: P03_AnalogTst.ino *****/
/***** Autor: Rolando Sánchez *****/
/***** Fecha: Agosto 2015 *****/
/******************************************************************/
/***** Descripción: Lee la señal analógica 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. *****/
/******************************************************************/
/******************************************************************/
// Definición de variables
int entradaANLG, datoLOW, datoHIGH;
void setup() {
// Inicializamos la comunicación serial.
Serial.begin(9600);
}
void loop() {
// Leemos la entrada analógica
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 ELECTRÓNICAS *****/
/******************************************************************/
/***** Lenguaje: Processing *****/
/***** Programa: AnalogTst.pde *****/
/***** Autor: Rolando Sánchez *****/
/***** Fecha: Agosto 2015 *****/
/******************************************************************/
/***** Descripción: Muestra gráficamente el valor de la *****/
/***** señal analógica 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;
}
}
// Función que dibuja la pantalla del osciloscopio
void dibujaOsciloscopio(){
int y;
background(120, 60, 40); // fondo verde oscuro
noFill();
strokeWeight(1);
stroke(120, 90, 90); // líneas 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 código y dé clic sobre el comando Play (flecha)
Este programa nos muestra la misma variable que vimos en la solución anterior pero de manera gráfica. En el gráfico 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 gráfico:
5V
ARDUINO UNO
A0 D5
D4
10K
1K
1K
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. SOLUCIÓN Para la solución de este problema usemos los resultados del ejercicio anterior. Podemos dividir el gráfico en tres zonas: luz, penumbra y oscuridad; y podemos tomar los valores 300 como el límite entre luz y penumbra, y 760 como el límite entre penumbra y oscuridad.
/******************************************************************/
/******************************************************************/
/***** ESCUELA NACIONAL DE BELLAS ARTES DEL PERÚ *****/
/***** SEMINARIO DE ARTES ELECTRÓNICAS *****/
/******************************************************************/
/***** Plataforma: Arduino UNO *****/
/***** Programa: P04_LedLuz.ino *****/
/***** Autor: Rolando Sánchez *****/
/***** Fecha: Setiembre 2015 *****/
/******************************************************************/
/***** Descripción: 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 límite entre luz y penumbra, y 760 *****/
/***** como límite 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 analógica 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: PARLANTE FUNCIONES: tone(), noTone() Se tiene la siguiente conexión. Se quiere desarrollar un programa que emita el sonido de una alarma por el parlante.
ARDUINO UNO
D2
5V
1K
2N3904
+-
SOLUCIÓN
/******************************************************************/
/******************************************************************/
/***** ESCUELA NACIONAL DE BELLAS ARTES DEL PERÚ *****/
/***** SEMINARIO DE ARTES ELECTRÓNICAS *****/
/******************************************************************/
/***** Plataforma: Arduino UNO *****/
/***** Programa: P05_Spk.ino *****/
/***** Autor: Rolando Sánchez *****/
/***** Fecha: Setiembre 2015 *****/
/******************************************************************/
/***** Descripción: 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 ningún sonido
noTone(pinSPK);
delay(100);
}
/******************************************************************/
/***** FIN DEL PROGRAMA *****/
/******************************************************************/
PROGRAMA 06 TEMAS: SENSOR DE DISTANCIA FUNCIONES: 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 centímetros, entre dicho sensor y cualquier objeto que tenga al frente.
ARDUINO UNO
HC-SR04
Vcc
Trig
Echo
Gnd
5V
D7D8
D0
D1
SOLUCIÓN
/******************************************************************/
/******************************************************************/
/***** ESCUELA NACIONAL DE BELLAS ARTES DEL PERÚ *****/
/***** SEMINARIO DE ARTES ELECTRÓNICAS *****/
/******************************************************************/
/***** Plataforma: Arduino UNO *****/
/***** Programa: P06_SnsrDist.ino *****/
/***** Autor: Rolando Sánchez *****/
/***** Fecha: Setiembre 2015 *****/
/******************************************************************/
/***** Descripción: Se conecta al Arduino un sensor de *****/
/***** distancia de ultrasonido HC-SR04. Este programa cal- *****/
/***** cula la distancia del sensor a algún objeto y la *****/
/***** transmite por el puerto serial en centímetros. *****/
/***** 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 función 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);
}
/******************************************************************/
/***** Función: distHCSR04(). *****/
/******************************************************************/
/***** Entrada: Ninguna *****/
/***** Salida: Distancia en cm entre el sensor y un objeto.*****/
/***** 0: Si no hay objeto en el rango [5cm, 300cm]*****/
/***** Descripción: La función controla al sensor HC-SR04. *****/
/***** Calcula la distancia en centímetros entre el sensor *****/
/***** y algún 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: APLIACACIÓN 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 algún objeto se acerca al sensor a una distancia de 30cm o menos.
ARDUINO UNO
D2
5V
1K
2N3904
+-
HC-SR04
Vcc
Trig
Echo
Gnd
5V
D7D8
SOLUCIÓN
/******************************************************************/
/******************************************************************/
/***** ESCUELA NACIONAL DE BELLAS ARTES DEL PERÚ *****/
/***** SEMINARIO DE ARTES ELECTRÓNICAS *****/
/******************************************************************/
/***** Plataforma: Arduino UNO *****/
/***** Programa: P07_DistSpk.ino *****/
/***** Autor: Rolando Sánchez *****/
/***** Fecha: Setiembre 2015 *****/
/******************************************************************/
/***** Descripción: 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 que se conectan al sensor HC-SR04
#define pinTrig 7 // Trigger lo conectamos a D7
#define pinEcho 8 // Echo lo coenectamos a D8
#define pinSpk 2 // 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 función distHCSR04() devuelve el valor de la distancia en cm.
distancia = distHCSR04();
if(distancia!=0){ // Si hay un objeto en el rango de medición
if(distancia<30){ // Si el objeto esta a menos de 30cm
tone(pinSpk, 300); // Emitir alarma
delay(100);
tone(pinSpk, 1300);
delay(300);
noTone(pinSpk);
delay(200);
}
else noTone(pinSpk); // Caso contrario apagar parlante
}
else noTone(pinSpk); // Caso contrario apagar parlante.
}
/******************************************************************/
/***** Función: distHCSR04(). *****/
/******************************************************************/
/***** Entrada: Ninguna *****/
/***** Salida: Distancia en cm entre el sensor y un objeto.*****/
/***** 0: Si no hay objeto en el rango [5cm, 300cm]*****/
/***** Descripción: La función controla al sensor HC-SR04. *****/
/***** Calcula la distancia en centímetros entre el sensor *****/
/***** y algún 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 *****/
/******************************************************************/
