TALLER ARDUINO I/2019

Brian Hurtado Mercado

PRACTICA 2
ENCENDER LED CON UN PULSADOR
MIENTRAS EL PULSADOR ESTA PRESIONADO, EL LED ESTA ON
AL SOLTAR EL PULSADOR, EL LED ESTARA OFF

int pulsador = 2; //PIN DONDE ESTA EL PULSADOR

int led = 13; //PIN DONDE ESTA EL LED

void setup()
{
pinMode (pulsador, INPUT); //PULSADOR COMO ENTRADA
pinMode (led, OUTPUT); // LED COMO SALIDA

void loop()
{
if (digitalRead (pulsador)==HIGH) //CONDICIONAL PARA SABER EL ESTADO DEL
PULSADOR

{
//PULSADOR PRESIONADO
digitalWrite (led, HIGH);
}
else
{
//PULSADOR NO PRESIONADO
digitalWrite (led, LOW);
}
}

PRACTICA 3
DOS PULSADORES ON-OFF

int pulsador1 = 2;
int pulsador2 = 3;
int led = 13;

void setup() {
pinMode (led, OUTPUT);
pinMode (pulsador1, INPUT);
pinMode (pulsador2, INPUT);

void loop() {

if (digitalRead (pulsador1)==HIGH)
{
digitalWrite (led, HIGH);
}
 else if (digitalRead (pulsador2)==HIGH)
{
digitalWrite (led, LOW);
}

PRACTICA 4
PUERTO SERIAL. ENTRADA ANALÓGICA CON POTENCIOMETRO

void setup()
{
Serial.begin(9600); //Inicia comunicación serial

void loop()
{
//Guardar en una variable el valor de la lectura análoga
int valor = analogRead(A0);
Serial.println(valor); //Imprime el valor por la consola
delay(100); //Retardo de 100ms para ver los datos de la consola
}

PRACTICA 5
PUERTO SERIAL: CONTROL ON-OFF DE LED CON POTENCIOMETRO
void setup()
{
Serial.begin(9600); //Inicia comunicación serial
pinMode(13,OUTPUT); //Configurar el pin 13 como una salida
}

void loop()
{ // Cuando este energizado el Arduino
//Guardar en una variable el valor de la lectura análoga
int valor = analogRead(A0);
Serial.println(valor); //Imprime el valor por la consola
//Si el valor es mayor o igual a 500
if (valor >= 500)
{
digitalWrite(13,HIGH); //Enciende el LED en el pin 13
}
//Si el valor es menor a 500
else
{
digitalWrite(13,LOW); //Apaga el LED en el pin 13
}
delay(100); //Retardo de 100ms para ver los datos de la consola
}
PRACTICA 6
SALIDA ANALOGICA: VARIACION DE BRILLO DE LED POR PWM
int brillo = 0; //variable de brillo que inicia en 0
float variacion = 10; // variable de incremento configurada de 10 en 10
int led = 9; // pin donde está el led, salida

void setup()
{
pinMode (led, OUTPUT); // el led se configura como salida

void loop()
{
analogWrite (led, brillo); //Escritura análoga PWM, en el led
pogo el valor de brillo
brillo = brillo + variacion; // incrementa la variable de brillo de 5 en 5

if (brillo == 0|| brillo == 255) //si el brillo es 0 o 255

variacion = -variacion; //la variacion se vuelve negativa.
delay (2000);
}

PRACTICA 7
SALIDA ANALOGICA: FOTOCELDA Y VARIACION DE BRILLO LED
//variables

int fotopin=A0; // Seleccionar el pin de sensor

int ledpin=9; // Seleccionar el pin para el LED
int val=0; // Variable para almacenar el valor que viene del sensor

void setup()
{
Serial.begin (9600);
pinMode(ledpin,OUTPUT); // Declarar la ledpin como una salida
Serial.begin(9600); // Para establecer la velocidad de transmisión de
9600
}
void loop()
{

val=analogRead(fotopin); // Leer el valor del sensor

Serial.println(val);

analogWrite(ledpin,val);

delay(200);
}
PRACTICA 8
SALIDA ANALOGICA: FOTOCELDA Y ARRAY
//primero nombramos variables

int leds[]={9,10,11}; //ARRAY o arreglos, el 9 es la posición cer0, 10 es pos uno, y 11

es posición dos. Esto evita que el código sea muy largo.
int tiempo=10; // variable tiempo de 50 milisegundos
int b=0; // variable de propósito general
int foto=A1; // puerto ANALOGO 1 (A1 DEL ARDUINO), AHI VA A ESTAR LA
FOTOCELDA
int medida=0; //variable medida que inicia en cero
int luzled=0; // variable luz led que inicia en cero

void setup()
{
Serial.begin(9600); //inicializa el puerto serial
for(b=0; b<3; b++)
{
pinMode(leds[b], OUTPUT); //Aquí actuarán las tres posiciones del array. Esto evita
que hagamos pinMode para cada led, lo cual sería largo.
} //"si es la posición cero, se incrementa. y llega a la primera y
luego a a la segunda. al final las tres posiciones (tres leds) están como salida

void loop()
{
medida = analogRead(foto); //En "medida" se guardaran los datos de "foto". y
quien es foto? Es A1.
Serial.println(medida); // monitor serie imprime "medida" (valores de foto ó
A1. IMPRIME Y SALTA UNA LINEA
luzled = 255-(medida/4); //intensidad de la luz del led. Recuerden que el
arduino en A1. Recibe valores de 0 a 1023 (10 bits)
Serial.println(luzled); //pero en las salidas PWM, solo tiene valores hasta
255 de salida (8bits)
for(b=0; b<3; b++) // por tanto hacemos un artificio matematico simple
255-(1023/4) = 0 (miren el video de PWM)

{
analogWrite(leds[b], luzled); //los tres leds (tres posiciones de 0=9, 1=10 y
2=11) se activan de acuerdo a la señal q les llega de FOTO
delay (tiempo);

}
PRACTICA 9
LCD 16X2: IMPRIMIR MENSAJES EN LA PANTALLA DISPLAY

#include <LiquidCrystal.h> // Incluye la Libreria LiquidCrystal

LiquidCrystal lcd(1, 2, 4, 5, 6, 7); // Crea un Objeto LC. Parametros: (rs, enable, d4, d5, d6,
d7)
void setup() {
lcd.begin(16,2); // Inicializa la interface para el LCD screen, and determina sus dimensiones
(ancho y alto) del display
}
void loop() {
lcd.print(" HOLA MUNDO!"); // Imprime "LCD Tutorial" sobre el LCD
delay(3000); // 3 segundos de espera
lcd.setCursor(0,1); // Seteamos la ubicacion texto 0 linea 1 que sera escrita sobre el LCD

lcd.print(" ARDUINO"); //Nótese que los espacios en blanco ocupan espacios.

delay(4000);
lcd.clear(); // Limpia la pantalla
delay(1500);

lcd.print(" Briantski");
delay(3000);
lcd.clear();

PRACTICA 10
SCROLL LCD 16X2: DESPLAZAMIENTO DE TEXTO DE DERECHA A IZQUIERA
/*
Scroll sobre LCD
DESPLAZAMIENTO DE TEXTO DE DERECHA A IZQUIERA
Nuevas funciones= lcd.autoscroll (realiza el desplazamiento del texto)
*/

#include <LiquidCrystal.h> // Incluye la Libreria LiquidCrystal

LiquidCrystal lcd(1, 2, 4, 5, 6, 7); //Crea un Objeto LC. Parametros: (rs, enable, d4, d5, d6,
d7)

void setup(){
lcd.begin(16,2); // Inicializa la interface para el LCD screen, and determina sus dimensiones
(ancho y alto) del display
lcd.clear(); // Limpia la pantalla
lcd.setCursor(1,0); // setea el cursor a la columna 1, fila 0
lcd.print(" Este texto se mueve xD"); // ingresamos nuestro texto
lcd.setCursor(1,1); // setea el cursor a la columna 1, fila 1
lcd.print(" y este tambien"); //ingresamos nuestro texto
}

void loop()
{
lcd.setCursor(16,1); // setea el cursor fuera del conteo del display
lcd.autoscroll(); // Setea el display para scroll automatico
lcd.print(" "); // imprime un character en blanco
delay(500); // setea el tiempo del desplazamiento del caracter

}
PRACTICA 11
ULTRASONIDO: VISUALIZACIÓN EN MONITOR SERIAL LA DISTANCIA

long distancia;
long tiempo;
void setup(){
Serial.begin(9600);
pinMode(11, OUTPUT); //Configuracion del pin 9 como salida: Trigger - Disparo
pinMode(12, INPUT); //Configuracion del pin 8 como entrada: Recibira el Echo
}

void loop(){
digitalWrite(11,LOW); //Para darle estabilización al sensor
delayMicroseconds(5); //Tiempo de 5 micro segundos
digitalWrite(11, HIGH); //Enviamos el pulso ultrasónico para activar el sensor
delayMicroseconds(10); //Con una duracion de 10 micro segundos
tiempo=pulseIn(12, HIGH); //Función para medir la longitud del pulso entrante, mide el tiempo
transcurrido de ida y vuelta
distancia= int(0.017*tiempo); //Fórmula para calcular la distancia obteniendo un valor entero
//Monitorización en centímetros por el monitor serial
Serial.println("Distancia "); //Imprimimos "Distancia" sobre el Monitor Serial
Serial.println(distancia); //Mostramos el Valor de la distancia real sobre el Monitor Serial
Serial.println("cm"); //Imprimimos " cm" sobre el Monitor Serial
delay(1000); //Cada que Tiempo se imprimira el valor de la distancia
}

PRACTICA 12
ULTRASONIDO: SENSOR DE DISTANCIA CON LEDS
// ULTRASONICO Y LEDS
//DISTANCIAS MAYORES A 40CM: SE ENCIENDE LED VERDE
//DISTANCIAS MAYOR A 20CM Y MENOR O IGUAL A 40CM: SE ENCIENDE LED NARANJA
//DISTANCIAS MENORES O IGUAL A 20CM: SE ENCIENDE LED ROJO
int ledrojo=6;
int lednaranja=7;
int ledverde=8;
long distancia;
long tiempo;
int led;
void setup(){
Serial.begin(9600);
pinMode(11, OUTPUT);
pinMode(12, INPUT);
pinMode(ledrojo, OUTPUT);
pinMode(lednaranja, OUTPUT);
pinMode(ledverde, OUTPUT);
}

void loop(){
digitalWrite(11 ,LOW);
delayMicroseconds(10);
digitalWrite(11, HIGH);
delayMicroseconds(10);
tiempo=pulseIn(12, HIGH);
distancia= int(0.017*tiempo);
if (distancia>40){
led=1;
digitalWrite(lednaranja,LOW);
digitalWrite(ledrojo,LOW);
}
if (distancia<=40&&distancia>20){
led=2;
digitalWrite(ledverde,LOW);
digitalWrite(ledrojo,LOW);
 }
if (distancia<=20){
led=3;
digitalWrite(ledverde,LOW);
digitalWrite(lednaranja,LOW);
}
switch(led){
case 1:
digitalWrite(ledverde,HIGH);
break;
case 2:
digitalWrite(lednaranja,HIGH);
break;
case 3:
digitalWrite(ledrojo,HIGH);
break;
}
delay(50);

PRACTICA 13
ULTRASONIDO y LCD: IMPRIMIR LA DISTANCIA EN LA PANTALLA DISPLAY

#include <LiquidCrystal.h> // includes the LiquidCrystal Library

LiquidCrystal lcd(1, 2, 4, 5, 6, 7); // Creates an LCD object. Parameters: (rs, enable, d4,
d5, d6, d7)
const int trigPin = 9;
const int echoPin = 10;
long duration;
int distanceCm, distanceInch;
void setup() {
lcd.begin(16,2); // Initializes the interface to the LCD screen, and specifies the
dimensions (width and height) of the display
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
}
void loop() {
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH);
distanceCm= duration*0.034/2;
distanceInch = duration*0.0133/2;
lcd.setCursor(0,0); // Sets the location at which subsequent text written to the LCD will
be displayed
lcd.print("Distancia: "); // Prints string "Distance" on the LCD
lcd.print(distanceCm); // Prints the distance value from the sensor
lcd.print(" cm");
delay(10);
lcd.setCursor(0,1);
lcd.print("Distancia: ");
lcd.print(distanceInch);
lcd.print(" pul");
delay(10);
}
PRACTICA 14
SERVOMOTOR: RECORRIDO DE POSICIÓN DEL SERVOMOTOR
EL SERVOMOTOR DEBE HACER UN RECORRIDO DESDE 0° HASTA 180° Y VICEVERSA
#include <Servo.h>

Servo myservo; // create servo object to control a servo

// twelve servo objects can be created on most boards

int pos = 0; // variable to store the servo position

void setup() {
myservo.attach(9); // attaches the servo on pin 9 to the servo object
}

void loop() {
for (pos = 0; pos <= 180; pos += 1) { // goes from 0 degrees to 180 degrees
// in steps of 1 degree
myservo.write(pos); // tell servo to go to position in variable 'pos'
delay(15); // waits 15ms for the servo to reach the position
}
for (pos = 180; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees
myservo.write(pos); // tell servo to go to position in variable 'pos'
delay(15); // waits 15ms for the servo to reach the position
}
}

PRACTICA 15
SERVOMOTOR: CONTROL MEDIANTE POTENCIÓMETRO
#include <Servo.h>

Servo myservo; // create servo object to control a servo

int potpin = 0; // analog pin used to connect the potentiometer

int val; // variable to read the value from the analog pin

void setup() {
myservo.attach(9); // attaches the servo on pin 9 to the servo object
}

void loop() {
val = analogRead(potpin); // reads the value of the potentiometer (value between 0
and 1023)
val = map(val, 0, 1023, 0, 180); // scale it to use it with the servo (value between 0
and 180)
myservo.write(val); // sets the servo position according to the scaled value
delay(15); // waits for the servo to get there
}
PRACTICA 16
SERVOMOTOR: CONTROL MEDIANTE PULSADORES
PRACTICA 17
SERVOMOTOR Y ULTRASONICO: SIMULAR UNA PUERTA CORREDIZA O TRANCA QUE SE ACTIVA CON LA
PRESENCIA DEL USUARIO
#include <Servo.h>
#define Pecho 11
#define Ptrig 12
long duracion, distancia;
int ledrojo= 6;
int ledverde= 7;

// Declaramos la variable para controlar el servo

Servo servoMotor;

void setup() {
// Iniciamos el monitor serie para mostrar el resultado
Serial.begin(9600);
pinMode(ledrojo, OUTPUT);
pinMode(ledverde, OUTPUT);

// Iniciamos el servo para que empiece a trabajar con el pin 9

servoMotor.attach(9);
servoMotor.write(0);

//ultrasonico
pinMode (Pecho, INPUT);
pinMode (Ptrig, OUTPUT);
}

void loop() {
digitalWrite(Ptrig, LOW);
delayMicroseconds(2);
digitalWrite(Ptrig, HIGH);
delayMicroseconds(10);
digitalWrite(Ptrig, LOW);

duracion = pulseIn(Pecho, HIGH);

distancia = (duracion/2)/29;
Serial.print(distancia);
Serial.println("cm");
if ((distancia >5 ) or (distancia<0))
{
servoMotor.write(0);
digitalWrite(ledrojo, HIGH);
digitalWrite(ledverde, LOW);
// Esperamos
delay(500);

}
else
{
// Desplazamos a la posición 180º
servoMotor.write(90);
digitalWrite(ledverde, HIGH);
digitalWrite(ledrojo, LOW);
// Esperamos
delay(3500);
}

}
PRACTICA 18
SERVOMOTOR Y LCD: VISUALIZACION DE LOS ANGULOS DEL SERVOMOTOR EN UNA PANTALLA LCD

//SERVO Y LCD
#include <Servo.h>
#include <LiquidCrystal.h>
LiquidCrystal lcd (1, 2, 4, 5, 6, 7);
Servo miServo; //creacion del objeto Servo para Accceder al missmo

int pot_pin=0; //pin del potenciometro

int servo_pin=9; // pin del control del Servo
int val; //variable donde almacenamos el valor del pot
int val2; //Variable auxiliar para calculos con el valor del pot

void setup() {
lcd.begin(16,2); //inicializacion del LCD
miServo.attach(servo_pin); //inicializacion de servo en el pin designado
}

void loop()
{
lcd.setCursor(0,0); //posiciona el cursor en la primera fila primera columna
lcd.print ("Posicion:");

val=analogRead (pot_pin); //lee el valor del po (entre 0 y 1023)

val2 = map(val,0,1023,0,179); //Escalado del valor del por pa usarlo con el servo
(valor entre 0 y 180)
miServo.write (val2); //aplica el valor calculado al servo
delay (15); //tiempo para esperar q el servo aplica los cambios
indicados

if (val2<100)//mejora la visualizacionde los valores en la lcd poniendo 0 delante

de los valores menores que 100
{
lcd.setCursor(0,1);
lcd.write ("0"); //escribimos el "0" por delante
lcd.setCursor (1,1);
lcd.print(val2); //escribimos el valor que le pasamos al servo en
pantalla
lcd.setCursor (3,1);
lcd.write ((char)223);//escribe despues de la centena el simbol "°"
}
else
{
lcd.setCursor (0,1);
lcd.print(val2); //escribimos el valor que le pasamos al servo e
}
}
PRACTICA 19
PLX DAQ: ADQUISICIÓN DE DATOS CON EXCEL Y GRAFICOS

float pinoPotenciometro = 0; // variavel que define a porta do potenciometro.

int linha = 0; // variavel que se refere as linhas do excel
int LABEL = 1;
int valor = 0; // variavel que guarda o valor lido do potenciometro
void setup(){
Serial.begin(9600); // inicialização da comunicação serial
Serial.println("CLEARDATA"); // Reset da comunicação serial
Serial.println("LABEL,Hora,valor,linha"); // Nomeia as colunas
}

void loop(){

valor = analogRead(pinoPotenciometro); // faz a leitura do potenciometro e guarda o

valor em val.
linha++; // incrementa a linha do excel para que a leitura pule de linha em linha

Serial.print("DATA,TIME,"); //inicia a impressão de dados, sempre iniciando

Serial.print(valor);
Serial.print(",");
Serial.println(linha);

if (linha > 100) //laço para limitar a quantidade de dados

{
linha = 0;
Serial.println("ROW,SET,2"); // alimentação das linhas com os dados sempre iniciando
}
delay(200); // espera 200 milisegundos

PRACTICA 20
MEMORIA EEPROM: REGISTRO DE POSICICIONES DE UN SERVOMOTOR
//------------------------Guardar Posiciones de SERVOMOTOR------------------------
//-------------------Posiciones generadas por un potenciómetro--------------------

#include <Servo.h>
#include <EEPROM.h>
#define Max 1023 //Valor máximo del potenciómetro
#define Min 0 //Valor mínimo del potenciómetro
int Grabar = 2; //Pulsador conectado al pin digital 2
int Reproducir = 5; //Pulsador conectado al pin digital 5
int Resetear = 6; //Pulsador conectado al pin digital 6
int servoPin = 9; //Servomotor conectado al pin digital 9
int POT = A7; //Potenciómetro conectado al pin análogo 7
int ledPin = 13; //LED conectado al pin digital 13
int addr;
Servo myServo;

void setup() {
Serial.begin(9600);
pinMode(Grabar, INPUT); digitalWrite(Grabar, HIGH);
pinMode(Reproducir, INPUT); digitalWrite(Reproducir, HIGH);
 pinMode(Resetear, INPUT); digitalWrite(Resetear, HIGH);
pinMode(ledPin, OUTPUT);
pinMode(POT, INPUT);
myServo.attach(servoPin);
}

void loop()
{

if(digitalRead(Reproducir) == HIGH)
{
int valorPOT = analogRead(POT);
int angulo = map(valorPOT,0,1023,0,180);
myServo.write(angulo);
}

if(digitalRead(Resetear) == LOW)
{
Serial.println("Borrando EEPROM, espere...");
for(addr=0; addr<=512; addr++){ EEPROM.write(addr, 255); }
addr = 0;
Serial.println("EEPROM borrada");
}

if (digitalRead(Grabar)==LOW)
{
delay(100);
grabaServo(servoPin, POT);
}

if (digitalRead(Reproducir)==LOW)
{
delay(400);
ejecutaServo(servoPin, Reproducir);
}
}

//--------Ejecuta posiciones almacenadas en la memoria-------------

void ejecutaServo(int servoPin, int botonPin) {
addr = 0;
Serial.println("Activando Servo");
myServo.attach(servoPin);
while (digitalRead(botonPin))
{
int dato = EEPROM.read(addr);
Serial.print("Lee EE: "); Serial.print(dato);
if (dato == 255) break;
dato = map(dato, 0, 254, 0, 180);
Serial.print(" -> "); Serial.println(dato);
myServo.write(dato);
delay(1500);
addr++;
if (addr == 512) break;
}
Serial.println(" y termina");
delay(300);
}

//--------------Almacena posiciones en la memoria----------------

 void grabaServo(int servoPin, int analogPin) {
Serial.println("Grabando posicion");
digitalWrite(ledPin, HIGH);
int dato = analogRead(POT);
Serial.print("Valor analogico: "); Serial.print(dato);
if (dato < Min) dato = Min; if (dato > Max) dato = Max;
dato = map(dato, Min, Max, 0, 254);
Serial.print(" -> "); Serial.println(dato);
EEPROM.write(addr, dato);
addr++;
digitalWrite(ledPin, LOW);
Serial.println("Grabada posicion");
delay(300);
}