Arduino (IoT): Simple Tutorial de Parlantes y Melodias

Arduino IoT Arduino (IoT): Simple Tutorial de Infrarojo (IR) Receptor/Transmisor by Santiapps Marcio Valenzuela
Arduino IoT Arduino (IoT): Simple Tutorial de Infrarojo (IR) Receptor/Transmisor

Arduino (IoT): Simple Tutorial de Parlantes y Melodias Arduino

 

En tutorial aprendemos que los sonidos no son mas que energía y esa energía la podemos reproducir usando energía eléctrica en una Arduino.  El tutorial es sencillo y muy interesante porque, que mejor melodía que…bueno preparen el tutorial y escuchemos!  Será una muy buena sorpresa.

 

Conexiones

Arduino (IoT) Simple Tutorial Parlantes y Melodias by Santiapps Marcio Valenzuela
Arduino (IoT) Simple Tutorial Parlantes y Melodias

La conexión del cable rojo es al pin 8, que usamos como salida de la Arduino.

Codigo

El codigo sera en dos partes.  La primera parte es notas.h que básicamente solo define las notas.  La segunda parte es el código que usa esas notas.  Aquí esta notas.h:

#define	C0 16.35
#define	Db0	17.32
#define	D0	18.35
#define	Eb0	19.45
#define	E0	20.60
#define	F0	21.83
#define	Gb0	23.12
#define	G0	24.50
#define	Ab0	25.96
#define	LA0	27.50
#define	Bb0	29.14
#define	B0	30.87
#define	C1	32.70
#define	Db1	34.65
#define	D1	36.71
#define	Eb1	38.89
#define	E1	41.20
#define	F1	43.65
#define	Gb1	46.25
#define	G1	49.00
#define	Ab1	51.91
#define	LA1	55.00
#define	Bb1	58.27
#define	B1	61.74
#define	C2	65.41
#define	Db2	69.30
#define	D2	73.42
#define	Eb2	77.78
#define	E2	82.41
#define	F2	87.31
#define	Gb2	92.50
#define	G2	98.00
#define	Ab2	103.83
#define	LA2	110.00
#define	Bb2	116.54
#define	B2	123.47
#define	C3	130.81
#define	Db3	138.59
#define	D3	146.83
#define	Eb3	155.56
#define	E3	164.81
#define	F3	174.61
#define	Gb3	185.00
#define	G3	196.00
#define	Ab3	207.65
#define	LA3	220.00
#define	Bb3	233.08
#define	B3	246.94
#define	C4	261.63
#define	Db4	277.18
#define	D4	293.66
#define	Eb4	311.13
#define	E4	329.63
#define	F4	349.23
#define	Gb4	369.99
#define	G4	392.00
#define	Ab4	415.30
#define	LA4	440.00
#define	Bb4	466.16
#define	B4	493.88
#define	C5	523.25
#define	Db5	554.37
#define	D5	587.33
#define	Eb5	622.25
#define	E5	659.26
#define	F5	698.46
#define	Gb5	739.99
#define	G5	783.99
#define	Ab5	830.61
#define	LA5	880.00
#define	Bb5	932.33
#define	B5	987.77
#define	C6	1046.50
#define	Db6	1108.73
#define	D6	1174.66
#define	Eb6	1244.51
#define	E6	1318.51
#define	F6	1396.91
#define	Gb6	1479.98
#define	G6	1567.98
#define	Ab6	1661.22
#define	LA6	1760.00
#define	Bb6	1864.66
#define	B6	1975.53
#define	C7	2093.00
#define	Db7	2217.46
#define	D7	2349.32
#define	Eb7	2489.02
#define	E7	2637.02
#define	F7	2793.83
#define	Gb7	2959.96
#define	G7	3135.96
#define	Ab7	3322.44
#define	LA7	3520.01
#define	Bb7	3729.31
#define	B7	3951.07
#define	C8	4186.01
#define	Db8	4434.92
#define	D8	4698.64
#define	Eb8	4978.03
// DURATION OF THE NOTES 
#define BPM 120    //  you can change this value changing all the others
#define H 2*Q //half 2/4
#define Q 60000/BPM //quarter 1/4 
#define E Q/2   //eighth 1/8
#define S Q/4 // sixteenth 1/16
#define W 4*Q // whole 4/4

La segunda parte seria melodia.ino:

#include "notas.h"
void setup() {     
pinMode(8, OUTPUT);   
pinMode(9, OUTPUT);       
digitalWrite(9,LOW);

}

// the loop routine runs over and over again forever:
void loop() {
  //tone(pin, note, duration)
    tone(8,LA3,Q); 
    delay(1+Q); //delay duration should always be 1 ms more than the note in order to separate them.
    tone(8,LA3,Q);
    delay(1+Q);
    tone(8,LA3,Q);
    delay(1+Q);
    tone(8,F3,E+S);
    delay(1+E+S);
    tone(8,C4,S);
    delay(1+S);
    
    tone(8,LA3,Q);
    delay(1+Q);
    tone(8,F3,E+S);
    delay(1+E+S);
    tone(8,C4,S);
    delay(1+S);
    tone(8,LA3,H);
    delay(1+H);
    
    tone(8,E4,Q); 
    delay(1+Q); 
    tone(8,E4,Q);
    delay(1+Q);
    tone(8,E4,Q);
    delay(1+Q);
    tone(8,F4,E+S);
    delay(1+E+S);
    tone(8,C4,S);
    delay(1+S);
    
    tone(8,Ab3,Q);
    delay(1+Q);
    tone(8,F3,E+S);
    delay(1+E+S);
    tone(8,C4,S);
    delay(1+S);
    tone(8,LA3,H);
    delay(1+H);
    
    tone(8,LA4,Q);
    delay(1+Q);
    tone(8,LA3,E+S);
    delay(1+E+S);
    tone(8,LA3,S);
    delay(1+S);
    tone(8,LA4,Q);
    delay(1+Q);
    tone(8,Ab4,E+S);
    delay(1+E+S);
    tone(8,G4,S);
    delay(1+S);
    
    tone(8,Gb4,S);
    delay(1+S);
    tone(8,E4,S);
    delay(1+S);
    tone(8,F4,E);
    delay(1+E);
    delay(1+E);//PAUSE
    tone(8,Bb3,E);
    delay(1+E);
    tone(8,Eb4,Q);
    delay(1+Q);
    tone(8,D4,E+S);
    delay(1+E+S);
    tone(8,Db4,S);
    delay(1+S);
    
    tone(8,C4,S);
    delay(1+S);
    tone(8,B3,S);
    delay(1+S);
    tone(8,C4,E);
    delay(1+E);
    delay(1+E);//PAUSE QUASI FINE RIGA
    tone(8,F3,E);
    delay(1+E);
    tone(8,Ab3,Q);
    delay(1+Q);
    tone(8,F3,E+S);
    delay(1+E+S);
    tone(8,LA3,S);
    delay(1+S);
    
    tone(8,C4,Q);
    delay(1+Q);
     tone(8,LA3,E+S);
    delay(1+E+S);
    tone(8,C4,S);
    delay(1+S);
    tone(8,E4,H);
    delay(1+H);
    
     tone(8,LA4,Q);
    delay(1+Q);
    tone(8,LA3,E+S);
    delay(1+E+S);
    tone(8,LA3,S);
    delay(1+S);
    tone(8,LA4,Q);
    delay(1+Q);
    tone(8,Ab4,E+S);
    delay(1+E+S);
    tone(8,G4,S);
    delay(1+S);
    
    tone(8,Gb4,S);
    delay(1+S);
    tone(8,E4,S);
    delay(1+S);
    tone(8,F4,E);
    delay(1+E);
    delay(1+E);//PAUSE
    tone(8,Bb3,E);
    delay(1+E);
    tone(8,Eb4,Q);
    delay(1+Q);
    tone(8,D4,E+S);
    delay(1+E+S);
    tone(8,Db4,S);
    delay(1+S);
    
    tone(8,C4,S);
    delay(1+S);
    tone(8,B3,S);
    delay(1+S);
    tone(8,C4,E);
    delay(1+E);
    delay(1+E);
    tone(8,F3,E);
    delay(1+E);
    tone(8,Ab3,Q);
    delay(1+Q);
    tone(8,F3,E+S);
    delay(1+E+S);
    tone(8,C4,S);
    delay(1+S);
    
    tone(8,LA3,Q);
    delay(1+Q);
     tone(8,F3,E+S);
    delay(1+E+S);
    tone(8,C4,S);
    delay(1+S);
    tone(8,LA3,H);
    delay(1+H);
    
    delay(2*H);
    
}

Al final se ve así:

Arduino (IoT) Simple Tutorial Parlantes y Melodias (Star Wars) by Santiapps Marcio Valenzuela
Arduino (IoT) Simple Tutorial Parlantes y Melodias (Star Wars)

Arduino (IoT): Simple Tutorial LCD

Arduino Honduras Santiapps Marcio Valenzuela

Tutorial LCD

Ya sabemos accionar luces y motores.  Ahora veamos como visualizar informacion en una pantalla LCD que es una tarea muy común para mostrar informacion obtenida de sensores.

Requisitos:

  1. Computadora (mac)
  2. Arduino MEGA (u otra variante Arduino) o incluso Arduino clone, Edison, Raspberry…  Este tutorial en particular usa una Arduino MEGA.
  3. Pantalla LCD
  4. Breadboard
  5. Arduino IDE (https://www.arduino.cc/en/Main/Software)

Una pantalla LCD es un componente un poco mas complicado.  Como pueden ver ya viene montado sobre una tarjeta de circuitos.  Pero no es de asustarse, una tarjeta de circuitos lo único que es, es una conexión de varios componentes de manera fija.  Es mas, en los tutoriales anteriores que hicimos interconexiones usando la breadboard, todos esos cables y resistores y diodos son exactamente eso.  La diferencia es que en una breadboard se ensaya y cuando ya se tiene un circuito bien probado, para no tener todos esos cables colgando, se reduce todo en tamaño y se fijan los cables a una tarjeta de circuitos.

En este caso la pantalla es sencilla (hay mas complicadas) pero lo mas importante es que tiene 16 pines que podemos ver en la esquina inferior derecha.  Estan nombrados:

– VSS, VDD, VO: VDD (+), VSS (-) & V0 (contraste)

– RS, RW, E: RS (registro), RW (Read/Write) & E (enable)

– D0 – D7: D0-D3 (no data), D4-D7 (data)

– A & K: A (backlight) & K (backlight GND)

Arduino LCD Tutorial Santiapps Marcio Valenzuela
Arduino LCD

Las conexiones aquí se vuelven un poco mas complicadas asi que prepárense.  Si hay una conexión mas sencilla ahora utilizando un protocolo llamado I2C pero siempre es bueno empezar por lo tradicional y crecer desde allí.

Arduino LCD Tutorial Santiapps Marcio Valenzuela
Arduino LCD

Se mira complicado pero no lo es.  Vamos por partes:

  • Primero alimentamos la breadboard con 5V de la MEGA (cable rojo superior izquierdo) y con el GND (cable negro en el centro de la imagen).  Esto es VSS y VDD.
  • Luego un cable azul pequeño en el breadboard conecta al 3er pin en el LCD denominado V0.  Este dijimos que es el contraste.  Es común que las LCDs tenga un controlados de contraste ya que dependiendo de la luz ambiental se puede ver mejor si se ajusta el mismo.  Esto se hace variando la corriente al LCD y ya sabemos que para variar la corriente con un dial, un pot es ideal.
  • Ahora viene un cable rojo vino del pin 12 de la MEGA (RS), un cable negro al GND (R/W) y un cable blanco al pin 11 de la MEGA (E).
  • Luego los pines D0-D3 están libres en este caso.
  • Siguen los 4 pines de datos que se conectan a los pines 2-5 del LCD. (NOTA: usar 4 pines es equivalente a usar el LCD en modo 4-bits y usar los 8 pines es usarlo en modo 8-bits)
  • Finalmente tenemos un resistor al 5V en el backlight (A) y el GND al backlight GND (K).

La alimentacion de VSS y VDD no necesita explicación, es la fuente de poder para la LCD.  La alimentación para el backlight, A & K, tampoco.  Los 4 pines de data es donde enviaremos la data y los 4 pines vacíos pues no hay nada que explicar.  El pin V0 al pot es para regular el contraste.

Lo único que requiere explicación es RS, RW y E.

RS determina si la LCD esta en modo instrucción o caracteres.  En modo instrucción la LCD responde a comandos como limpiar el display o mover el cursor.  A diferencia del modo caracteres que dice a la LCD que reciba data tipo alfanumerica o de símbolos.  Si el RS esta a voltaje bajo o GND, esta en modo instrucción.  Si esta a voltaje alto o 5V esta en modo caracteres.

RW es similar y la distincion radica entre modo de lectura del display (READ) o modo de escritura al display (WRITE).  Read es poco comun pero existe.  Nosotros principalmente estaremos usando el modo write.

Finalmente, E, habilita y deshabilita los dos RS y RW.  Es decir, cuando E tiene voltaje bajo, RS y RW no importan, la LCD no recibe data.  Cuando E recibe voltaje alto entonces lee datos entrantes.

Bueno suficiente explicación, ahora veamos la conexión:

Arduino LCD Tutorial Santiapps Marcio Valenzuela
Arduino LCD Tutorial Santiapps Marcio Valenzuela

Parece complejo pero es tan sencillo como el diagrama que vimos arriba con algunas modificaciones.

De derecha a izquierda

El primer par rojo/negro (err: en la imagen falta el cable negro) es el que alimenta de la MEGA.  El segundo par rojo/negro que sale hacia la esquina inferior derecha son los que alimentan el pot.  El tercer par rojo/negro son los que entran directamente al LCD en sus pines VDD/VSS.  Luego viene el cable verde en la LCD que va al wiper del pot.  Le sigue el cable verde (RS) al pin 12, cable negro(RW) a GND comun y otro cable verde(E) al pin 11.  A continuacion los 4 pines vacios seguidos de los 4 pines (D4-D7) con cables de data.  Finalmente esta el ultimo par rojo/negro a los pines A/K respectivamente.  En resumen deberiamos tener:

LCD -> MEGA -> Breadboard -> Color de Cable –> Otro

VSS –> GND —>  SI ————-> Negro

VDD –> 5V ——> SI ————–> Rojo

V0 ——————> NO ————> Verde —————> Wiper del Pot

RS —–> 12 ——> NO ————> Verde

RW —-> GND —> SI ————–> Negro

E ——-> 11 ——> NO ————> Verde

D0-D3

D4-D7 -> 5-2 ————————-> 5&4 naranja, 3&2 amarillos

A ——-> 5V ——-> SI ————-> Rojo

K ——-> GND —-> SI ————-> Negro

Finalmente el codigo:

//#include // Esta no la usaremos, es para LCDs con una conexión distinta pero mas avanzada
#include
// initializamos el objeto LiquidCrystal, similar como el Servo
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup() {
// Nuestro LCD es 16 cols x 2 filas
lcd.begin(16, 2);
// Imprimimos al LCD
lcd.print("Hola Arduino HN!");
}
void loop() {
// Cada loop reseteamos el cursor a col0, linea1
// linea 1 es la 2da fila porque linea 0 es la primera
lcd.setCursor(0, 1);
// Imprimimos segundos desde reinicio...
lcd.print(millis() / 2000);
delay(1000);
}

Y ahora el resultado final…bueno, al menos el mio…

Arduino LCD Tutorial Santiapps Marcio Valenzuela
Arduino LCD
Arduino LCD Tutorial Santiapps Marcio Valenzuela
Arduino LCD

Ok, repasando lo que aprendimos:

  • Aprendimos a usar componentes con varios pines.
  • Tenemos una manera mas amigable para visualizar la data de un proyecto en una pantalla.

Ahora podemos relacionar esto al uso de una pantalla mas sofisticada como una TFT para ver mas datos o incluso TFT touchscreen que nos permite una interacción intuitiva entre el usuario y la data.

En el proximo tutorial aprenderemos a leer data de un sensor.  La idea es comenzar a trabajar con componentes mas sofisticados y con libraries para ir conectándolos de manera que podamos incorporar a nuestro proyecto de datos, la comunicación de esos datos.