Archivo de la categoría: Componentes

Módulo de teclado sensible al tacto TTP229

Este teclado de 16 teclas se conecta utilizando una conexión I2C (2-Wire), aunque en el chip sensor capacitivo TTP229 tiene implementada la opción de conectar solamente 8 teclas, que tienen salida directa en los pines del módulo. Son los pines marcados como OUT1 a OUT8. Las líneas marcadas SDO y SCL pertenecen a la interfaz I2C.

Características

■ Fácil de usar, calibración automática
■ LED de encendido
■ Funciona en modo 8 o 16 canales.
■ La salida puede ser configurada como activa alta o baja
■ Simple para reemplazar salidas de llaves mecánicas
■ La salida se puede conectar directamente a los pines de entrada del microcontrolador

Especificaciones

■ Voltaje de funcionamiento: 2V-5,5V
■ Tiempo de calibración de inicio: 0,5 seg.
■ Tamaño de la plaqueta: 49,3 x 64,5mm

Este módulo es una buena alternativa para reemplazar teclados mecánicos, ya que es durable, fácil de instalar (es totalmente plano), se puede proteger con una membrana en ambientes de atmósfera corrosiva, y proporciona más durabilidad en condiciones de trabajo continuado.

Puentes que definen las opciones

(Ver las opciones definibles en la tabla abajo)

EJEMPLO:

Diagrama de pines del circuito integrado TTP229

El teclado se puede configurar tanto para usar con 8 teclas como con 16. Para el primer caso, parece poco razonable usar sólo la mitad, ya que en realidad se venden módulos directamente con sólo 8 teclas, y también con 4 y hasta con una sola.

En todo caso, la división de funciones, y la multiplicidad de opciones que se pueden elegir usando una serie de puentes en la plaqueta aportan amplia funcionalidad y una buena adaptación para distintos usos.

Cuando se elige la opción de 16 teclas, se los lee por medio de una interfaz serie de 2 vías, llamada comúnmente 2-Wire en el mundo Arduino, o I2C.

Una vez conectado el hardware y descargando el código al Arduino, al pulsar los teclas se pueden observar los resultados en el Monitor Serie del IDE Arduino.

Diagrama en bloques del circuito integrado TTP229

Diagrama del módulo de teclado TTP229

PROGRAMAS DE PRUEBA

Conexión directa de las salidas de 8 teclas

Si en alguna ocasión se necesita utilizar sólo la serie de teclas del 1 a 8, la configuración y la lectura por programa es más sencilla y simple de entender. La conexión involucra 8 pines del conector del módulo de teclado al Arduino, y dos más de ellas para alimentación +5 y GND.

Esta forma de uso tiene la desventaja de que ocupa muchas entradas digitales (que nunca sobran), aunque la ventaja es que no necesariamente se debe usar un Arduino u otro microcontrolador para recibir datos desde el módulo si se lo usa con esta configuración. Podría servir para introducir órdenes de teclado en un circuito puramente digital, sin procesador ni programa.

Diagrama de conexiones con Arduino

Código simple para 8 teclas

/* Código simple para 8 teclas */


void setup() {
  pinMode(2, INPUT); // Tecla 1
  pinMode(3, INPUT); // Tecla 2
  pinMode(4, INPUT); // Tecla 3
  pinMode(5, INPUT); // Tecla 4
  pinMode(6, INPUT); // Tecla 5
  pinMode(7, INPUT); // Tecla 6
  pinMode(8, INPUT); // Tecla 7
  pinMode(9, INPUT); // Tecla 8
  Serial.begin(9600);
}
 
void loop(){
   // ¿ tecla presionada ?
   for (byte i = 2; i < 10; i++) {
   if (digitalRead(i)) 
      { 
        Serial.print("Tecla "); 
        Serial.println(i-1);
        break; 
      }
   }
   delay(200);
    // Si se deja presionada la tecla, repite el mensaje cada 200 milisegundos
}

/* Código simple para 8 teclas */

void setup() {

pinMode(2, INPUT); // Tecla 1

pinMode(3, INPUT); // Tecla 2

pinMode(4, INPUT); // Tecla 3

pinMode(5, INPUT); // Tecla 4

pinMode(6, INPUT); // Tecla 5

pinMode(7, INPUT); // Tecla 6

pinMode(8, INPUT); // Tecla 7

pinMode(9, INPUT); // Tecla 8

Serial.begin(9600);

}

void loop(){

// ¿ tecla presionada ?

for (byte i = 2; i < 10; i++) {

if (digitalRead(i))

{

Serial.print("Tecla ");

Serial.println(i-1);

break;

}

delay(200);

// Si se deja presionada la tecla, repite el mensaje cada 200 milisegundos

}

Resultado en Monitor Serie

Conexión para leer las 16 teclas

Para leer los teclas del 1 a 16 se debe hacer a través de la interfaz serie I2C o 2-Wire del Arduino, utilizando SCL y SDO, y con dos pines digitales que uno elija y el programa adecuado, que en general es muy simple.

Conexión entre el Arduino y el teclado para el ejemplo de 16 teclas por I2C

Cablear como se muestra a continuación y además hacer un puente en el módulo del teclado para configurarlo para funcionar con 16 teclas, sobre los puntos marcados “TP2”, que se muestran abajo en naranja.

Esto se hace soldando un alambrecito que una estos 2 terminales.

Diagrama de la conexión con Arduino

Código para la lectura de 16 teclas

// Define los pines digitales para Clock y Dato
#define pinSCL 8
#define pinSDO 9
 
byte Tecla; // guarda el numero de tecla activada
 
void setup() {
Serial.begin(9600); // inicializa la interfaz serie

pinMode(pinSCL, OUTPUT); // pin Clock (SCL) salida
pinMode(pinSDO, INPUT); // pin Dato (SDO) entrada
}
 
void loop() {

// leer el estado del teclado
Tecla = leerteclas();

// si se toca una tecla lo muestra en Monitor Serie
  if (Tecla) {
    Serial.print("Tecla -> ");
    Serial.println(Tecla);
  }

// esperar un poco para no
// sobrecargar el puerto serie
delay(200);
}

// funcion que lee el estado del teclado
byte leerteclas(void) {

byte contador;
byte estadoTecla = 0;

   // enviar 16 pulsos de clock (uno para cada tecla)
   // y leer el estado del pin de dato en cada pulso
  for(contador = 1; contador <= 16; contador++) {

   digitalWrite(pinSCL, LOW); // clock a BAJO
 
   // si el pin de dato esta BAJO (el teclado tiene modo de
   // salida en activo BAJO)registra el número de tecla
   if (!digitalRead(pinSDO)) estadoTecla = contador;

   digitalWrite(pinSCL, HIGH); // clock a ALTO
  }

return estadoTecla;
}

// Define los pines digitales para Clock y Dato

#define pinSCL 8

#define pinSDO 9

byte Tecla; // guarda el numero de tecla activada

void setup() {

Serial.begin(9600); // inicializa la interfaz serie

pinMode(pinSCL, OUTPUT); // pin Clock (SCL) salida

pinMode(pinSDO, INPUT); // pin Dato (SDO) entrada

}

void loop() {

// leer el estado del teclado

Tecla = leerteclas();

// si se toca una tecla lo muestra en Monitor Serie

if (Tecla) {

Serial.print("Tecla -> ");

Serial.println(Tecla);

}

// esperar un poco para no

// sobrecargar el puerto serie

delay(200);

}

// funcion que lee el estado del teclado

byte leerteclas(void) {

byte contador;

byte estadoTecla = 0;

// enviar 16 pulsos de clock (uno para cada tecla)

// y leer el estado del pin de dato en cada pulso

for(contador = 1; contador <= 16; contador++) {

digitalWrite(pinSCL, LOW); // clock a BAJO

// si el pin de dato esta BAJO (el teclado tiene modo de

// salida en activo BAJO)registra el número de tecla

if (!digitalRead(pinSDO)) estadoTecla = contador;

digitalWrite(pinSCL, HIGH); // clock a ALTO

}

return estadoTecla;

}

Resultado en Monitor Serie

Lectura de 16 teclas con posibilidad de pulsar más de una a la vez

Como en cada caso en que se habilitan 16 teclas, la comunicación con el microcontrolador se realiza por medio del protocolo I2C. Cada tecla está asociada a un bit en un entero sin signo de dos bytes.

Estos son algunos ejemplos:

La tecla 1 aparecerá como 0000 0000 0000 0001
La tecla 2 aparecerá como 0000 0000 0000 0010
La tecla 3 aparecerá como 0000 0000 0000 0100
… …
La tecla 9 aparecerá como 0000 0001 0000 0000
La tecla 12 aparecerá como 0000 1000 0000 0000
La tecla 16 aparecerá como 1000 0000 0000 0000

Cuando se tocan dos o más teclas, el entero asociado contendrá dos bits o más en 1. Por ejemplo, si se pulsan la tecla 1 y la 16 al mismo tiempo, el entero asociado será 1000 0000 0000 0001

Conexiones:

Los pines TP0 a TP4 en el teclado se deben conectar (hacer un puente) como en la figura siguiente:

Diagrama de conexión con el Arduino:

Código para 16 teclas – multitecla – interfaz 2-wire:

/*  
 *   16 teclas - multitecla - interfaz 2-wire
 */
int SCLPin = A5;
int SDOPin = A4;
unsigned int DATO = 0;
unsigned int viejo_DATO = 0;

void setup()
{
  Serial.begin(9600);
  pinMode(SCLPin , OUTPUT);
}

unsigned int ttp229()
{
  unsigned int DATO = 0;
  pinMode(SDOPin , OUTPUT);
  digitalWrite(SDOPin, HIGH);
  delayMicroseconds(93);
  digitalWrite(SDOPin, LOW);
  delayMicroseconds(10);
  pinMode(SDOPin , INPUT);
  for (int i = 0; i < 16; i++)
  {
    digitalWrite(SCLPin, HIGH);
    delayMicroseconds(1);
    digitalWrite(SCLPin, LOW);
    DATO |= digitalRead(SDOPin) << i;
  }
  delay(2);
  return DATO&0xFFFF;
}

void loop()
{
  DATO = ttp229();
  if (DATO != viejo_DATO)
  {
    Serial.println(DATO, BIN);
    viejo_DATO = DATO;
    delay(200);
  }
}

* 16 teclas - multitecla - interfaz 2-wire

int SCLPin = A5;

int SDOPin = A4;

unsigned int DATO = 0;

unsigned int viejo_DATO = 0;

void setup()

{

Serial.begin(9600);

pinMode(SCLPin , OUTPUT);

}

unsigned int ttp229()

{

unsigned int DATO = 0;

pinMode(SDOPin , OUTPUT);

digitalWrite(SDOPin, HIGH);

delayMicroseconds(93);

digitalWrite(SDOPin, LOW);

delayMicroseconds(10);

pinMode(SDOPin , INPUT);

for (int i = 0; i < 16; i++)

{

digitalWrite(SCLPin, HIGH);

delayMicroseconds(1);

digitalWrite(SCLPin, LOW);

DATO |= digitalRead(SDOPin) << i;

}

delay(2);

return DATO&0xFFFF;

}

void loop()

{

DATO = ttp229();

if (DATO != viejo_DATO)

{

Serial.println(DATO, BIN);

viejo_DATO = DATO;

delay(200);

}

En la Terminal Serie del IDE de Arduino se verá lo que sigue al pulsar las teclas desde 1 a 16 (Nota: debido a la manera en que la función Serial.println maneja las variables, el Monitor Serie no muestra los ceros a la izquierda del entero de 16 bits):

Para este ejemplo: PDFs de ayuda (en inglés) desde el siguiente enlace:
http://osoyoo.com/driver/TTP229.rar

Se puede descargar el programa INO (con textos en inglés) desde el siguiente enlace:
http://osoyoo.com/wp-content/uploads/2016/07/TTP229_all.rar

LSM6DSOX: acelerómetro y giroscopio con aprendizaje automático incorporado

1 respuesta

STMicroelectronics acaba de lanzar su último circuito integrado sensor, el LSM6DSOX, que proporciona datos del sensor sobre la aceleración y la orientación. Además, también puede procesar estos datos mediante aprendizaje automático sin ninguna entrada externa del microcontrolador.

El LSM6DSOX es un encapsulado SiP (sistema empaquetado en un chip) de 2,5 mm x 3 mm x 0,83 mm.

Un SiP es un sistema o subsistema electrónico funcional que incluye dos o más matrices semiconductoras heterogéneas (a menudo de nodos de tecnología diferentes optimizados para sus funcionalidades individuales), generalmente con componentes pasivos. La forma física del SiP es un módulo y, dependiendo de la aplicación final, el módulo podría incluir un chip lógico, memoria, dispositivos pasivos integrados (IPD), filtros de RF, sensores, disipadores de calor, antenas, conectores y/o chip de potencia.

La creciente complejidad de los dispositivos de gama baja está dando lugar a una nueva forma de procesamiento de datos. En lugar de que un controlador principal realice todo el trabajo pesado, los periféricos conectados pueden tener controladores integrados y DPS que pueden preprocesar sus propios datos antes de pasar al controlador principal, que puede descargar el trabajo del controlador principal, lo que ahorra energía. Un ejemplo de esto es el LSM6DSOX, el último módulo inercial de ST que tiene capacidades de aprendizaje automático.

El LSM6DSOX

El LSM6DSOX es un acelerómetro 3D y un giroscopio 3D siempre encendidos. Se puede acceder al sensor a través de SPI e I2C, así como al último estándar de la industria, I3C. El sensor es compatible con Android para la integración con sistemas Android (como tablets y teléfonos).

También incorpora detección significativa de movimiento y detección de inclinación. El movimiento de inclinación incorporado en el sensor es capaz de desencadenar eventos durante los cambios de inclinación. Por ejemplo, un evento puede activarse cuando un usuario tiene su teléfono en el bolsillo y se levanta después de haberse sentado. Esta detección de inclinación se realiza todo en hardware sin la necesidad de un controlador, lo que puede reducir en gran medida el trabajo de potencia y descarga de un procesador.

Núcleo de aprendizaje automático en el LSM6DSOX

Sin embargo, la verdadera magia detrás del LSM6DSOX es el sistema interno de aprendizaje automático. El núcleo de aprendizaje automático, realizado mediante una serie de condiciones «si-luego-si no», permite la identificación de tareas específicas, como caminar, correr y conducir, que son programables por el usuario.

Con hasta 256 nodos disponibles, el núcleo de aprendizaje automático puede ejecutar hasta ocho flujos simultáneamente y cada flujo puede generar hasta 16 resultados. El sensor también puede tener en cuenta sensores externos con el uso de un núcleo de sensores (Sense Hub), por donde otros sensores pueden enviar sus datos al LSM6DSOX.

Conexión de sensores externos al LSM6DSOX

«El aprendizaje automático ya se usa para el reconocimiento rápido y eficiente de patrones en redes sociales, modelos financieros o manejo autónomo», dijo Andrea Onetti, vicepresidente de analógicos, MEMS y sensores del Grupo STMicro. «El sensor de movimiento LSM6DSOX integra capacidades de aprendizaje automático para mejorar el seguimiento de la actividad en teléfonos inteligentes y dispositivos portátiles».

Especificaciones:

Cápsula de 2,5 mm x 3 mm x 0,83 mm
Consumo de energía de 0,55 mA.
FIFO (First In First Out = acrónimo que significa «primero en entrar, primero en salir») de hasta 9KB
±2 / ±4 / ±8 / ±16 g escala completa
±125 / ±250 / ±500 / ±1000 / ±2000 dps (degrees per second, grados por segundo) escala completa

La integración de controladores pequeños y de baja potencia en los periféricos da paso a un cambio en la forma en que se diseña el hardware. Al descargar la mayor cantidad de trabajo posible de un procesador principal (que puede no ser el hardware con mayor ahorro de energía), los dispositivos podrían ver un mayor rendimiento con datos preprocesados y una mayor duración de la batería.

Módulo de emisor piezoeléctrico pasivo KY-006 (Kit de sensores Keyes 6)

1 respuesta

Este módulo zumbador piezoeléctrico Keyes KY-006 puede producir una gama de tonos de sonido dependiendo de la frecuencia de entrada.

Especificaciones:

El módulo KY-006 consiste en un emisor piezoeléctrico de sonido pasivo, que puede reproducir tonos entre 1,5 a 2,5 kHz al encenderlo y apagarlo en diferentes frecuencias usando retardos o PWM.

■ Voltaje de funcionamiento: 1,5 ~ 15V DC
■ Rango de generación de tonos: 1,5 ~ 2.5kHz
■ Dimensiones: 18,5 mm x 15 mm

Diagrama de conexión:

La entrada de señal (S) se conecta al pin digital 9 en el Arduino y masa (indicado por –) a GND. El pin medio no se utiliza.

/*
 * Módulo de emisor piezoeléctrico pasivo KY-006
 */
int emisor = 2; // definir el pin digital del Arduino

void setup() {
   pinMode(emisor, OUTPUT); // definir el pin como salida 
}

void loop() {
 for (int i = 0; i < 80; i++) { // emitir un sonido
   digitalWrite(emisor, HIGH); // salida en ALTO
   delay(1); // espera 1 ms
   digitalWrite(emisor, LOW); // salida en BAJO
   delay(1);
   }
  delay(50);
  for (int j = 0; j < 100; j++) { // otro sonido
   digitalWrite(emisor, HIGH); // salida en ALTO
   delay(2); // espera 2 ms
   digitalWrite(emisor, LOW); // salida en BAJO
   delay(2); // espera 2 ms
   }
   delay(100);
}

* Módulo de emisor piezoeléctrico pasivo KY-006

int emisor = 2; // definir el pin digital del Arduino

void setup() {

pinMode(emisor, OUTPUT); // definir el pin como salida

}

void loop() {

for (int i = 0; i < 80; i++) { // emitir un sonido

digitalWrite(emisor, HIGH); // salida en ALTO

delay(1); // espera 1 ms

digitalWrite(emisor, LOW); // salida en BAJO

delay(1);

}

delay(50);

for (int j = 0; j < 100; j++) { // otro sonido

digitalWrite(emisor, HIGH); // salida en ALTO

delay(2); // espera 2 ms

digitalWrite(emisor, LOW); // salida en BAJO

delay(2); // espera 2 ms

}

delay(100);

}

Uso del piezoeléctrico con la función tone()

Descripción:

La función tone() genera una onda cuadrada de la frecuencia especificada (y un ciclo de trabajo del 50%) en un pin digital del Arduino. Se puede especificar una duración; de lo contrario, la señal continúa hasta que se realiza una llamada a la función noTone(). El pin se puede conectar a un zumbador piezoeléctrico u otro altavoz para reproducir tonos.

Solo se puede generar un tono a la vez. Si ya se está reproduciendo un tono en un pin diferente, la llamada a tone() no tendrá ningún efecto. Si el tono se reproduce en el mismo pin, la llamada establecerá una nueva frecuencia.

El uso de la función tone() interferirá con la salida PWM en los pines 3 y 11 (en placas que no sean Mega).

No es posible generar tonos inferiores a 31 Hz. Para detalles técnicos, vea las notas de Brett Hagman.

NOTA: si desea reproducir diferentes tonos en múltiples pines, debe llamar a la función noTone() en un pin antes de llamar a tone() en el siguiente pin.

Sintaxis:

■ tone(pin, frecuencia)
■ tone(pin, frecuencia, duración)

Parámetros:

■ pin: el pin sobre el que generar el tono
■ frecuencia: la frecuencia del tono en hercios – unsigned int
■ duración: la duración del tono en milisegundos (opcional) – unsigned long

Feliz cumpleaños

/* 
 * Piezo Buzzer entre GND y 9 
 */

int speakerPin = 9;
int length = 28; // cantidad de notas
char notes[] = "GGAGcB GGAGdc GGxecBA yyecdc";
int beats[] = { 2, 2, 8, 8, 8, 16, 1, 2, 2, 8, 8, 8, 16, 1, 2, 2, 8, 8, 8, 8, 16, 1, 2, 2, 8, 8, 8, 16 };
int tempo = 220;

void playTone(int tone, int duration) {
for (long i = 0; i < duration * 1000L; i += tone * 2) {
   digitalWrite(speakerPin, HIGH);
   delayMicroseconds(tone);
   digitalWrite(speakerPin, LOW);
   delayMicroseconds(tone);
   }
}

void playNote(char note, int duration) {
char names[] = {'C', 'D', 'E', 'F', 'G', 'A', 'B',           
                 'c', 'd', 'e', 'f', 'g', 'a', 'b',
                 'x', 'y' };
int tones[] = { 1915, 1700, 1519, 1432, 1275, 1136, 1014,
                 956,  834,  765,  593,  468,  346,  224,
                 622 , 715 };
int SPEE = 5;

// tocar el tono correspondiente
for (int i = 0; i < 17; i++) {
   if (names[i] == note) {
    int newduration = duration/SPEE;
     playTone(tones[i], newduration);
   }
 }
}

void setup() {
pinMode(speakerPin, OUTPUT);
}

void loop() {
for (int i = 0; i < length; i++) {
   if (notes[i] == ' ') {
     delay(beats[i] * tempo); // rest
   } else {
     playNote(notes[i], beats[i] * tempo);
   }
   // pause between notes
   delay(tempo);
}
}

* Piezo Buzzer entre GND y 9

int speakerPin = 9;

int length = 28; // cantidad de notas

char notes[] = "GGAGcB GGAGdc GGxecBA yyecdc";

int beats[] = { 2, 2, 8, 8, 8, 16, 1, 2, 2, 8, 8, 8, 16, 1, 2, 2, 8, 8, 8, 8, 16, 1, 2, 2, 8, 8, 8, 16 };

int tempo = 220;

void playTone(int tone, int duration) {

for (long i = 0; i < duration * 1000L; i += tone * 2) {

digitalWrite(speakerPin, HIGH);

delayMicroseconds(tone);

digitalWrite(speakerPin, LOW);

delayMicroseconds(tone);

}

void playNote(char note, int duration) {

char names[] = {'C', 'D', 'E', 'F', 'G', 'A', 'B',

'c', 'd', 'e', 'f', 'g', 'a', 'b',

'x', 'y' };

int tones[] = { 1915, 1700, 1519, 1432, 1275, 1136, 1014,

956, 834, 765, 593, 468, 346, 224,

622 , 715 };

int SPEE = 5;

// tocar el tono correspondiente

for (int i = 0; i < 17; i++) {

if (names[i] == note) {

int newduration = duration/SPEE;

playTone(tones[i], newduration);

}

void setup() {

pinMode(speakerPin, OUTPUT);

}

void loop() {

for (int i = 0; i < length; i++) {

if (notes[i] == ' ') {

delay(beats[i] * tempo); // rest

} else {

playNote(notes[i], beats[i] * tempo);

}

// pause between notes

delay(tempo);

}

Para Elisa

/* 
 * Para Elisa 
 */
#define parlante 9
#define tempo 0.90

void setup() {
  pinMode(parlante, OUTPUT);
}

void loop() {
  // play e4
  delay(tempo*600);
  tone(parlante, 329.63, 300);
  delay(tempo*350);
  // play d4# 
  tone(parlante, 311.13, 300);
  delay(tempo*350);
  // play e4
  tone(parlante, 329.63, 300);
  delay(tempo*350);
  // play d4# 
  tone(parlante,311.13, 300);
  delay(tempo*350);
  // play e4
  tone(parlante, 329.63, 300);
  delay(tempo*350);
  // play b3
  tone(parlante, 246.94, 300);
  delay(tempo*400);
  // play d4
  tone(parlante, 293.66,300);
  delay(tempo*400);
  // play c4
  tone(parlante, 261.63,300);
  delay(tempo*400);
  // play a3
  tone(parlante, 220, 900);
  delay(tempo*1000);
  // play d3
  tone(parlante,146.83, 300);
  delay(tempo*350);
  //play f3
  tone(parlante, 174.61, 300);
  delay(tempo*400);
  //play a3
  tone(parlante, 220, 300);
  delay(tempo*400);
  // play b3
  tone(parlante, 246.94, 900);
  delay(tempo*1000);
  // play f3
  tone(parlante, 174.61, 300);
  delay(tempo*400);
  // play a3#
  tone(parlante, 233.08, 300);
  delay(tempo*400);
  // play b3
  tone(parlante, 246.94, 300);
  delay(tempo*400);
  // play c4
  tone(parlante, 261.63, 900);
  delay(tempo*1000);
  delay(tempo*300);
  // play e4
  tone(parlante, 329.63, 300);
  delay(tempo*400);
  // play d4#
  tone(parlante, 311.13, 300);
  delay(tempo*400);
  // play e4
  tone(parlante, 329.63, 300);
  delay(tempo*400);
  // play d4#
  tone(parlante, 311.13, 300);
  delay(tempo*400);
  // play e4
  tone(parlante, 329.63, 300);
  delay(tempo*400);
  // play b3
  tone(parlante, 246.94, 300);
  delay(tempo*400);
  // play d4
  tone(parlante, 293.66, 300);
  delay(tempo*400);
  // play c4
  tone(parlante, 261.63, 300);
  delay(tempo*400);
  // play a3
  tone(parlante, 220, 900);
  delay(tempo*1000);
  // play d3
  tone(parlante, 146.83, 300);
  delay(tempo*400);
  // play f3
  tone(parlante, 174.61, 300);
  delay(tempo*400);
  // play a3
  tone(parlante, 220, 300);
  delay(tempo*400);
  // play b3
  tone(parlante, 246.94, 900);
  delay(tempo*1000);
  // play f3
  tone(parlante, 174.61, 300);
  delay(tempo*400);
  // play c4
  tone(parlante, 261.63, 300);
  delay(tempo*400);
  // play b3
  tone(parlante, 246.94, 300);
  delay(tempo*400);
  // play a3
  tone(parlante, 220, 900);
  delay(tempo*1000);
  // play b3
  tone(parlante,246.94, 300);
  delay(tempo*400);
   // play c4
  tone(parlante, 261.63, 300);
  delay(tempo*400);
  // play d4
  tone(parlante, 293.66, 300);
  delay(tempo*400);
  // play e4
  tone(parlante, 329.63, 900);
  delay(tempo*1000);
  // play g3
  tone(parlante, 196, 300);
  delay(tempo*400);
  // play f4
  tone(parlante, 349.23, 300);
  delay(tempo*400);
  //play e4
  tone(parlante, 329.23, 300);
  delay(tempo*400);
  // play d4
  tone(parlante, 293.63, 900);
  delay(tempo*1000);
  // play e3
  tone(parlante,164.81, 300);
  delay(tempo*400);
  // play e4
  tone(parlante, 329.63, 300);
  delay(tempo*400);
  // play d4
  tone(parlante, 293.63, 300);
  delay(tempo*400);
  // play c4
  tone(parlante, 261.63, 900);
  delay(tempo*1000);
  // play d3
  tone(parlante, 146.83, 300);
  delay(tempo*400);
    // play d4
  tone(parlante, 293.63, 300);
  delay(tempo*400);
  // play c4
  tone(parlante, 261.63, 300);
  delay(tempo*400);
  // play b3
  tone(parlante, 246.94, 900);
  delay(tempo*1000);
  delay(tempo*400);
  // play e4
  tone(parlante, 329.63, 300);
  delay(tempo*400);
  // play d4# 
  tone(parlante, 311.13, 300);
  delay(tempo*350);
  // play e4
  tone(parlante, 329.63, 300);
  delay(tempo*350);
  // play d4# 
  tone(parlante,311.13, 300);
  delay(tempo*350);
  // play e4
  tone(parlante, 329.63, 300);
  delay(tempo*350);
  // play b3
  tone(parlante, 246.94, 300);
  delay(tempo*400);
  // play d4
  tone(parlante, 293.66,300);
  delay(tempo*400);
  // play c4
  tone(parlante, 261.63,300);
  delay(tempo*400);
  // play a3
  tone(parlante, 220, 900);
  delay(tempo*1000);
  // play d3
  tone(parlante,146.83, 300);
  delay(tempo*350);
  //play f3
  tone(parlante, 174.61, 300);
  delay(tempo*400);
  //play a3
  tone(parlante, 220, 300);
  delay(tempo*400);
  // play b3
  tone(parlante, 246.94, 900);
  delay(tempo*1000);
  // play f3
  tone(parlante, 174.61, 300);
  delay(tempo*400);
  // play a3
  tone(parlante, 233.08, 300);
  delay(tempo*400);
  // play b3
  tone(parlante, 246.94, 300);
  delay(tempo*400);
  // play c4
  tone(parlante, 261.63, 900);
  delay(tempo*1000);
  delay(tempo*300);
  // play e4
  tone(parlante, 329.63, 300);
  delay(tempo*400);
  // play d4#
  tone(parlante, 311.13, 300);
  delay(tempo*400);
  // play e4
  tone(parlante, 329.63, 300);
  delay(tempo*400);
  // play d4#
  tone(parlante, 311.13, 300);
  delay(tempo*400);
  // play e4
  tone(parlante, 329.63, 300);
  delay(tempo*400);
  // play b3
  tone(parlante, 246.94, 300);
  delay(tempo*400);
  // play d4
  tone(parlante, 293.66, 300);
  delay(tempo*400);
  // play c4
  tone(parlante, 261.63, 300);
  delay(tempo*400);
  // play a3
  tone(parlante, 220, 900);
  delay(tempo*1000);
  // play d3
  tone(parlante, 146.83, 300);
  delay(tempo*400);
  // play f3
  tone(parlante, 174.61, 300);
  delay(tempo*400);
  // play a3
  tone(parlante, 220, 300);
  delay(tempo*400);
  // play b3
  tone(parlante, 246.94, 900);
  delay(tempo*1000);
  // play f3
  tone(parlante, 174.61, 300);
  delay(tempo*400);
  // play c4
  tone(parlante, 261.63, 300);
  delay(tempo*400);
  // play b3
  tone(parlante, 246.94, 300);
  delay(tempo*400);
  // play a3
  tone(parlante, 220, 900);
  delay(tempo*1000);
  
  delay(tempo*5000);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

* Para Elisa

#define parlante 9

#define tempo 0.90

void setup() {

pinMode(parlante, OUTPUT);

}

void loop() {

// play e4

delay(tempo*600);

tone(parlante, 329.63, 300);

delay(tempo*350);

// play d4#

tone(parlante, 311.13, 300);

delay(tempo*350);

// play e4

tone(parlante, 329.63, 300);

delay(tempo*350);

// play d4#

tone(parlante,311.13, 300);

delay(tempo*350);

// play e4

tone(parlante, 329.63, 300);

delay(tempo*350);

// play b3

tone(parlante, 246.94, 300);

delay(tempo*400);

// play d4

tone(parlante, 293.66,300);

delay(tempo*400);

// play c4

tone(parlante, 261.63,300);

delay(tempo*400);

// play a3

tone(parlante, 220, 900);

delay(tempo*1000);

// play d3

tone(parlante,146.83, 300);

delay(tempo*350);

//play f3

tone(parlante, 174.61, 300);

delay(tempo*400);

//play a3

tone(parlante, 220, 300);

delay(tempo*400);

// play b3

tone(parlante, 246.94, 900);

delay(tempo*1000);

// play f3

tone(parlante, 174.61, 300);

delay(tempo*400);

// play a3#

tone(parlante, 233.08, 300);

delay(tempo*400);

// play b3

tone(parlante, 246.94, 300);

delay(tempo*400);

// play c4

tone(parlante, 261.63, 900);

delay(tempo*1000);

delay(tempo*300);

// play e4

tone(parlante, 329.63, 300);

delay(tempo*400);

// play d4#

tone(parlante, 311.13, 300);

delay(tempo*400);

// play e4

tone(parlante, 329.63, 300);

delay(tempo*400);

// play d4#

tone(parlante, 311.13, 300);

delay(tempo*400);

// play e4

tone(parlante, 329.63, 300);

delay(tempo*400);

// play b3

tone(parlante, 246.94, 300);

delay(tempo*400);

// play d4

tone(parlante, 293.66, 300);

delay(tempo*400);

// play c4

tone(parlante, 261.63, 300);

delay(tempo*400);

// play a3

tone(parlante, 220, 900);

delay(tempo*1000);

// play d3

tone(parlante, 146.83, 300);

delay(tempo*400);

// play f3

tone(parlante, 174.61, 300);

delay(tempo*400);

// play a3

tone(parlante, 220, 300);

delay(tempo*400);

// play b3

tone(parlante, 246.94, 900);

delay(tempo*1000);

// play f3

tone(parlante, 174.61, 300);

delay(tempo*400);

// play c4

tone(parlante, 261.63, 300);

delay(tempo*400);

// play b3

tone(parlante, 246.94, 300);

delay(tempo*400);

// play a3

tone(parlante, 220, 900);

delay(tempo*1000);

// play b3

tone(parlante,246.94, 300);

delay(tempo*400);

// play c4

tone(parlante, 261.63, 300);

delay(tempo*400);

// play d4

tone(parlante, 293.66, 300);

delay(tempo*400);

// play e4

tone(parlante, 329.63, 900);

delay(tempo*1000);

// play g3

tone(parlante, 196, 300);

delay(tempo*400);

// play f4

tone(parlante, 349.23, 300);

delay(tempo*400);

//play e4

tone(parlante, 329.23, 300);

delay(tempo*400);

// play d4

tone(parlante, 293.63, 900);

delay(tempo*1000);

// play e3

tone(parlante,164.81, 300);

delay(tempo*400);

// play e4

tone(parlante, 329.63, 300);

delay(tempo*400);

// play d4

tone(parlante, 293.63, 300);

delay(tempo*400);

// play c4

tone(parlante, 261.63, 900);

delay(tempo*1000);

// play d3

tone(parlante, 146.83, 300);

delay(tempo*400);

// play d4

tone(parlante, 293.63, 300);

delay(tempo*400);

// play c4

tone(parlante, 261.63, 300);

delay(tempo*400);

// play b3

tone(parlante, 246.94, 900);

delay(tempo*1000);

delay(tempo*400);

// play e4

tone(parlante, 329.63, 300);

delay(tempo*400);

// play d4#

tone(parlante, 311.13, 300);

delay(tempo*350);

// play e4

tone(parlante, 329.63, 300);

delay(tempo*350);

// play d4#

tone(parlante,311.13, 300);

delay(tempo*350);

// play e4

tone(parlante, 329.63, 300);

delay(tempo*350);

// play b3

tone(parlante, 246.94, 300);

delay(tempo*400);

// play d4

tone(parlante, 293.66,300);

delay(tempo*400);

// play c4

tone(parlante, 261.63,300);

delay(tempo*400);

// play a3

tone(parlante, 220, 900);

delay(tempo*1000);

// play d3

tone(parlante,146.83, 300);

delay(tempo*350);

//play f3

tone(parlante, 174.61, 300);

delay(tempo*400);

//play a3

tone(parlante, 220, 300);

delay(tempo*400);

// play b3

tone(parlante, 246.94, 900);

delay(tempo*1000);

// play f3

tone(parlante, 174.61, 300);

delay(tempo*400);

// play a3

tone(parlante, 233.08, 300);

delay(tempo*400);

// play b3

tone(parlante, 246.94, 300);

delay(tempo*400);

// play c4

tone(parlante, 261.63, 900);

delay(tempo*1000);

delay(tempo*300);

// play e4

tone(parlante, 329.63, 300);

delay(tempo*400);

// play d4#

tone(parlante, 311.13, 300);

delay(tempo*400);

// play e4

tone(parlante, 329.63, 300);

delay(tempo*400);

// play d4#

tone(parlante, 311.13, 300);

delay(tempo*400);

// play e4

tone(parlante, 329.63, 300);

delay(tempo*400);

// play b3

tone(parlante, 246.94, 300);

delay(tempo*400);

// play d4

tone(parlante, 293.66, 300);

delay(tempo*400);

// play c4

tone(parlante, 261.63, 300);

delay(tempo*400);

// play a3

tone(parlante, 220, 900);

delay(tempo*1000);

// play d3

tone(parlante, 146.83, 300);

delay(tempo*400);

// play f3

tone(parlante, 174.61, 300);

delay(tempo*400);

// play a3

tone(parlante, 220, 300);

delay(tempo*400);

// play b3

tone(parlante, 246.94, 900);

delay(tempo*1000);

// play f3

tone(parlante, 174.61, 300);

delay(tempo*400);

// play c4

tone(parlante, 261.63, 300);

delay(tempo*400);

// play b3

tone(parlante, 246.94, 300);

delay(tempo*400);

// play a3

tone(parlante, 220, 900);

delay(tempo*1000);

delay(tempo*5000);

}

Canción de Star Wars

// * Star Wars Song Selector
// * Original Composition : Star Wars
// * Coded By : https://code.google.com/p/rbots/source/browse/trunk/StarterKit/Lesson5_PiezoPlayMelody/Lesson5_PiezoPlayMelody.pde
// * Use BSD Clause 2 License for Distribution
// * Collection by GitHub User @abhishekghosh - https://github.com/AbhishekGhosh/Arduino-Buzzer-Tone-Codes
// * Program to choose between two melodies by using a potentiometer and a piezo buzzer.

// TONES //
// Defining the relationship between note, period & frequency. 
// period is in microsecond so P = 1/f * (1E6)
 
#define  c3    7634
#define  d3    6803
#define  e3    6061
#define  f3    5714
#define  g3    5102
#define  a3    4545
#define  b3    4049
#define  c4    3816    // 261 Hz 
#define  d4    3401    // 294 Hz 
#define  e4    3030    // 329 Hz 
#define  f4    2865    // 349 Hz 
#define  g4    2551    // 392 Hz 
#define  a4    2272    // 440 Hz 
#define  a4s   2146
#define  b4    2028    // 493 Hz 
#define  c5    1912    // 523 Hz
#define  d5    1706
#define  d5s   1608
#define  e5    1517    // 659 Hz
#define  f5    1433    // 698 Hz
#define  g5    1276
#define  a5    1136
#define  a5s   1073
#define  b5    1012
#define  c6    955
#define  R     0      // Define a special note, 'R', to represent a rest
 
 
// SETUP //
int speakerOut = 9;    // Set up speaker on digital pin 7
int potPin = A0;      // Set up potentiometer on analogue pin 0.
 
void setup() { 
  pinMode(speakerOut, OUTPUT);
    Serial.begin(9600); // Set serial out if we want debugging
  } 
//}
 
// MELODIES and TIMING //
//  melody[] is an array of notes, accompanied by beats[], 
//  which sets each note's relative length (higher #, longer note) 
 
// Melody 1: Star Wars Imperial March
int melody1[] = {  a4, R,  a4, R,  a4, R,  f4, R, c5, R,  a4, R,  f4, R, c5, R, a4, R,  e5, R,  e5, R,  e5, R,  f5, R, c5, R,  g5, R,  f5, R,  c5, R, a4, R};
int beats1[]  = {  50, 20, 50, 20, 50, 20, 40, 5, 20, 5,  60, 10, 40, 5, 20, 5, 60, 80, 50, 20, 50, 20, 50, 20, 40, 5, 20, 5,  60, 10, 40, 5,  20, 5, 60, 40};
 
// Melody 2: Star Wars Theme
int melody2[] = {  f4,  f4, f4,  a4s,   f5,  d5s,  d5,  c5, a5s, f5, d5s,  d5,  c5, a5s, f5, d5s, d5, d5s,   c5};
int beats2[]  = {  21,  21, 21,  128,  128,   21,  21,  21, 128, 64,  21,  21,  21, 128, 64,  21, 21,  21, 128 }; 
 
int MAX_COUNT = sizeof(melody1) / 2; // Melody length, for looping.
 
long tempo = 10000; // Set overall tempo
 
int pause = 1000; // Set length of pause between notes
 
int rest_count = 50; // Loop variable to increase Rest length (BLETCHEROUS HACK; See NOTES)
 
// Initialize core variables
int toneM = 0;
int beat = 0;
long duration  = 0;
int potVal = 0;
 
// PLAY TONE  //
// Pulse the speaker to play a tone for a particular duration
void playTone() {
  long elapsed_time = 0;
  if (toneM > 0) { // if this isn't a Rest beat, while the tone has 
    //  played less long than 'duration', pulse speaker HIGH and LOW
    while (elapsed_time < duration) {
 
      digitalWrite(speakerOut,HIGH);
      delayMicroseconds(toneM / 2);
 
      // DOWN
      digitalWrite(speakerOut, LOW);
      delayMicroseconds(toneM / 2);
 
      // Keep track of how long we pulsed
      elapsed_time += (toneM);
    } 
  }
  else { // Rest beat; loop times delay
    for (int j = 0; j < rest_count; j++) { // See NOTE on rest_count
      delayMicroseconds(duration);  
    }                                
  }                                 
}
 
// LOOP //
void loop() {
  analogRead(potPin); //Read potentiometer value and store in potVal variable
  Serial.println(potVal); // Print potVal in serial monitor
  
  if (potVal < 511) { // If potVal is less than 511, play Melody1...
  
  // Set up a counter to pull from melody1[] and beats1[]
  for (int i=0; i<MAX_COUNT; i++) {
    toneM = melody1[i];
    beat = beats1[i];
 
    duration = beat * tempo; // Set up timing
 
    playTone(); // A pause between notes
    delayMicroseconds(pause);
    }
  }
  else    // ... else play Melody2
for (int i=0; i<MAX_COUNT; i++) {
    toneM = melody2[i];
    beat = beats2[i];
 
    duration = beat * tempo; // Set up timing
 
    playTone(); // A pause between notes
    delayMicroseconds(pause);
    }
  }

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

// * Star Wars Song Selector

// * Original Composition : Star Wars

// * Coded By : https://code.google.com/p/rbots/source/browse/trunk/StarterKit/Lesson5_PiezoPlayMelody/Lesson5_PiezoPlayMelody.pde

// * Use BSD Clause 2 License for Distribution

// * Collection by GitHub User @abhishekghosh - https://github.com/AbhishekGhosh/Arduino-Buzzer-Tone-Codes

// * Program to choose between two melodies by using a potentiometer and a piezo buzzer.

// TONES //

// Defining the relationship between note, period & frequency.

// period is in microsecond so P = 1/f * (1E6)

#define c3 7634

#define d3 6803

#define e3 6061

#define f3 5714

#define g3 5102

#define a3 4545

#define b3 4049

#define c4 3816 // 261 Hz

#define d4 3401 // 294 Hz

#define e4 3030 // 329 Hz

#define f4 2865 // 349 Hz

#define g4 2551 // 392 Hz

#define a4 2272 // 440 Hz

#define a4s 2146

#define b4 2028 // 493 Hz

#define c5 1912 // 523 Hz

#define d5 1706

#define d5s 1608

#define e5 1517 // 659 Hz

#define f5 1433 // 698 Hz

#define g5 1276

#define a5 1136

#define a5s 1073

#define b5 1012

#define c6 955

#define R 0 // Define a special note, 'R', to represent a rest

// SETUP //

int speakerOut = 9; // Set up speaker on digital pin 7

int potPin = A0; // Set up potentiometer on analogue pin 0.

void setup() {

pinMode(speakerOut, OUTPUT);

Serial.begin(9600); // Set serial out if we want debugging

}

//}

// MELODIES and TIMING //

// melody[] is an array of notes, accompanied by beats[],

// which sets each note's relative length (higher #, longer note)

// Melody 1: Star Wars Imperial March

int melody1[] = { a4, R, a4, R, a4, R, f4, R, c5, R, a4, R, f4, R, c5, R, a4, R, e5, R, e5, R, e5, R, f5, R, c5, R, g5, R, f5, R, c5, R, a4, R};

int beats1[] = { 50, 20, 50, 20, 50, 20, 40, 5, 20, 5, 60, 10, 40, 5, 20, 5, 60, 80, 50, 20, 50, 20, 50, 20, 40, 5, 20, 5, 60, 10, 40, 5, 20, 5, 60, 40};

// Melody 2: Star Wars Theme

int melody2[] = { f4, f4, f4, a4s, f5, d5s, d5, c5, a5s, f5, d5s, d5, c5, a5s, f5, d5s, d5, d5s, c5};

int beats2[] = { 21, 21, 21, 128, 128, 21, 21, 21, 128, 64, 21, 21, 21, 128, 64, 21, 21, 21, 128 };

int MAX_COUNT = sizeof(melody1) / 2; // Melody length, for looping.

long tempo = 10000; // Set overall tempo

int pause = 1000; // Set length of pause between notes

int rest_count = 50; // Loop variable to increase Rest length (BLETCHEROUS HACK; See NOTES)

// Initialize core variables

int toneM = 0;

int beat = 0;

long duration = 0;

int potVal = 0;

// PLAY TONE //

// Pulse the speaker to play a tone for a particular duration

void playTone() {

long elapsed_time = 0;

if (toneM > 0) { // if this isn't a Rest beat, while the tone has

// played less long than 'duration', pulse speaker HIGH and LOW

while (elapsed_time < duration) {

digitalWrite(speakerOut,HIGH);

delayMicroseconds(toneM / 2);

// DOWN

digitalWrite(speakerOut, LOW);

delayMicroseconds(toneM / 2);

// Keep track of how long we pulsed

elapsed_time += (toneM);

}

else { // Rest beat; loop times delay

for (int j = 0; j < rest_count; j++) { // See NOTE on rest_count

delayMicroseconds(duration);

}

// LOOP //

void loop() {

analogRead(potPin); //Read potentiometer value and store in potVal variable

Serial.println(potVal); // Print potVal in serial monitor

if (potVal < 511) { // If potVal is less than 511, play Melody1...

// Set up a counter to pull from melody1[] and beats1[]

for (int i=0; i<MAX_COUNT; i++) {

toneM = melody1[i];

beat = beats1[i];

duration = beat * tempo; // Set up timing

playTone(); // A pause between notes

delayMicroseconds(pause);

}

else // ... else play Melody2

for (int i=0; i<MAX_COUNT; i++) {

toneM = melody2[i];

beat = beats2[i];

duration = beat * tempo; // Set up timing

playTone(); // A pause between notes

delayMicroseconds(pause);

}

Brilla, brilla, pequeña estrella

/*
 * Twinkle-Twinkle Little Star
 */
int speakerPin = 9;
int length = 15; // the number of notes

//twinkle twinkle little star
char notes[] = "ccggaag ffeeddc ggffeed ggffeed ccggaag ffeeddc "; // a space represents a rest
int beats[] = { 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 };
int tempo = 260;

void playTone(int tone, int duration) {
  for (long i = 0; i < duration * 1000L; i += tone * 2) {
    digitalWrite(speakerPin, HIGH);
    delayMicroseconds(tone);
    digitalWrite(speakerPin, LOW);
    delayMicroseconds(tone);
  }
}

void playNote(char note, int duration) {
  char names[] = { 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' };
  int tones[] = { 1915, 1700, 1519, 1432, 1275, 1136, 1014, 956 };
  
  // play the tone corresponding to the note name
  for (int i = 0; i < 8; i++) {
    if (names[i] == note) {
      playTone(tones[i], duration);
    }
  }
}

void setup() {
  pinMode(speakerPin, OUTPUT);
}

void loop() {
  for (int i = 0; i < length; i++) {
    if (notes[i] == ' ') {
      delay(beats[i] * tempo); // rest
    } else {
      playNote(notes[i], beats[i] * tempo);
    }
    
    // pause between notes
    delay(tempo / 2); 
  }
}

* Twinkle-Twinkle Little Star

int speakerPin = 9;

int length = 15; // the number of notes

//twinkle twinkle little star

char notes[] = "ccggaag ffeeddc ggffeed ggffeed ccggaag ffeeddc "; // a space represents a rest

int beats[] = { 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 };

int tempo = 260;

void playTone(int tone, int duration) {

for (long i = 0; i < duration * 1000L; i += tone * 2) {

digitalWrite(speakerPin, HIGH);

delayMicroseconds(tone);

digitalWrite(speakerPin, LOW);

delayMicroseconds(tone);

}

void playNote(char note, int duration) {

char names[] = { 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' };

int tones[] = { 1915, 1700, 1519, 1432, 1275, 1136, 1014, 956 };

// play the tone corresponding to the note name

for (int i = 0; i < 8; i++) {

if (names[i] == note) {

playTone(tones[i], duration);

}

void setup() {

pinMode(speakerPin, OUTPUT);

}

void loop() {

for (int i = 0; i < length; i++) {

if (notes[i] == ' ') {

delay(beats[i] * tempo); // rest

} else {

playNote(notes[i], beats[i] * tempo);

}

// pause between notes

delay(tempo / 2);

}

Módulo de emisor piezoeléctrico pasivo – KY-006: Dibujo de la pieza para el editor Fritzing

Artículos relacionados:

■ Módulo sensor de temperatura KY-001 (Kit de sensores Keyes 1)
■ Módulo detector de vibración KY-002 (Kit de sensores Keyes 2)
■ Módulo de Sensor Magnético por efecto Hall KY-003 (Kit de sensores Keyes 3)
■ Módulo de llave pulsadora – KY-004 (Kit de sensores Keyes 4)
■ Módulo sensor de temperatura KY-005 (Kit de sensores Keyes 5)
■ Módulo de emisor piezoeléctrico pasivo KY-006 (Kit de sensores Keyes 6)
■ Módulo codificador rotativo KY-040 [ó KY-007] – (Kit de sensores Keyes 040/007)

Módulo transmisor de infrarrojo KY-005 (Kit de sensores Keyes 5)

3 respuestas

Este módulo de Keyes contiene un led emisor de luz infrarroja y una resistencia limitadora de corriente.

El módulo transmisor de infrarrojo consiste de un led infrarrojo de 5mm y un resistor asociado. Funciona en conjunto con el receptor de infrarrojo KY-022.

■ Voltaje de Operación: 5V
■ Corriente Directa: 30 ~ 60 mA
■ Consumo de energía: 90mW
■ Temperatura de Operación: -25°C to 80°C
■ Dimensiones: 18,5mm x 15mm

La línea central del módulo es la alimentación, y se conecta a los +5V del Arduino. La línea marcada con el signo – va conectada a GND del Arduino. La línea marcada con la letra S va conectada a la línea digital 2 del Arduino.

Código de ejemplo:

El siguiente programa de Arduino utiliza la biblioteca IRremote para enviar señales de infrarrojos en serie con el KY-005.

La conexión del pin de salida la determina la biblioteca: la entrada digital 3 en Arduino Uno. Depende de la placa que se esté utilizando, de modo que si utiliza otra se debe verificar la documentación de la biblioteca de IRremote. Será necesario un receptor de infrarrojos como el KY-022 para procesar la señal.

Los enlaces a las bibliotecas requeridas para el programa de ejemplo de Arduino con KY-005 se pueden encontrar en los enlaces más abajo.

/*
 * Prueba de modulo de led infrarrojo KY-005  
 */
#include <IRremote.h>
IRsend irsend; // iniciar el objeto infrarrojo

void setup()
{
Serial.begin(9600); // iniciar comunicacion serie
}
void loop()
{
if (Serial.read() != -1) {
     for (int i=0; i<3; i++) {
       irsend.sendSony(0xa90, 12); // codigo de encendido de Sony TV
       delay(100);
     }
   }
}

* Prueba de modulo de led infrarrojo KY-005

#include <IRremote.h>

IRsend irsend; // iniciar el objeto infrarrojo

void setup()

{

Serial.begin(9600); // iniciar comunicacion serie

}

void loop()

{

if (Serial.read() != -1) {

for (int i=0; i<3; i++) {

irsend.sendSony(0xa90, 12); // codigo de encendido de Sony TV

delay(100);

}

Este programa envía un código de encendido/apagado de Sony TV cada vez que se envía un caracter al puerto serie, lo que permite que Arduino encienda o apague el televisor. (Tenga en cuenta que los códigos de Sony deben enviarse 3 veces de acuerdo con el diseño del protocolo).

Biblioteca IRremote: una biblioteca remota de infrarrojos multiprotocolo para Arduino

El código más reciente está en github.com/shirriff/Arduino-IRremote

La biblioteca remota IRremote permite enviar y recibir códigos remotos de IR en múltiples protocolos. Es compatible con NEC, Sony SIRC, Philips RC5, Philips RC6 y protocolos sin formato. Si se necesitan protocolos adicionales, son fáciles de agregar. Incluso la biblioteca puede utilizarse para grabar códigos desde su control remoto y retransmitirlos, como un control remoto universal mínimo.

Para usar la biblioteca, descargue desde github y siga las instrucciones de instalación en el archivo readme.

Cómo enviar:

Esta biblioteca remota de infrarrojos consta de dos partes: IRsend transmite paquetes remotos IR, mientras que IRrecv recibe y decodifica un mensaje IR. IRsend utiliza un LED infrarrojo conectado al pin digital 3. Para enviar un mensaje, llame al método de envío para el protocolo deseado con los datos a enviar y la cantidad de bits a enviar. Los ejemplos de la biblioteca proporcionan programas simples que muestran cómo enviar códigos. Uno de ellos es el que está listado más arriba.

Cómo recibir:

IRrecv utiliza un detector de infrarrojos conectado a cualquier pin de entrada digital.

El ejemplo IRrecvDemo en la biblioteca aporta un ejemplo simple de cómo recibir códigos:

/*
 * Receptor de infrarrojos  
 */
 
#include <IRremote.h>

 int pin_Recepcion = 11;
 IRrecv irrecv(pin_Recepcion);
 decode_results resultados;

 void setup()
 {
   Serial.begin (9600);
   irrecv.enableIRIn(); // iniciar el receptor
 }

 void loop() {
   if (irrecv.decode (&resultados)) {
     Serial.println(resultados.value, HEX);
     irrecv.resume(); // Recibe el siguiente valor
   }
 }

* Receptor de infrarrojos

#include <IRremote.h>

int pin_Recepcion = 11;

IRrecv irrecv(pin_Recepcion);

decode_results resultados;

void setup()

{

Serial.begin (9600);

irrecv.enableIRIn(); // iniciar el receptor

}

void loop() {

if (irrecv.decode (&resultados)) {

Serial.println(resultados.value, HEX);

irrecv.resume(); // Recibe el siguiente valor

}

La clase IRrecv realiza la decodificación y se inicializa con enableIRIn(). Se llama al método decode() para ver si se ha recibido un código; si es así, devuelve un valor distinto de cero y coloca los resultados en la estructura decode_results. Una vez que se ha descodificado un código, se debe llamar al método resume() para reanudar la recepción de códigos. Tenga en cuenta que decode() no bloquea; el croquis puede realizar otras operaciones mientras espera un código porque los códigos son recibidos por una rutina de interrupción.

Algunos antecedentes sobre los códigos IR

Un control remoto IR funciona encendiendo y apagando el LED en un patrón particular. Sin embargo, para evitar la interferencia de fuentes IR, como la luz solar o las luces, el LED no se enciende de manera constante, sino que se enciende y apaga a una frecuencia de modulación (generalmente 36, 38 o 40 KHz). El tiempo en que se envía una señal modulada se llama “marca”, y cuando el LED está apagado se llama “espacio”.

Cada tecla del control remoto tiene un código particular asociado (generalmente de 12 a 32 bits), y emite este código cuando se presiona la tecla. Si se mantiene presionada la tecla, el control remoto generalmente emite repetidamente el código de la tecla. Para un control remoto NEC, se envía un código especial de repetición cuando se mantiene presionada la tecla, en lugar de enviar el código repetidamente. Para los controles remotos Philips RC5 o RC6, se alterna un poco el código cada vez que se presiona una tecla; el receptor utiliza este bit de conmutación para determinar cuándo se presiona una tecla por segunda vez.

En el extremo receptor, el detector de IR demodula esta señal y emite una señal de nivel lógico que indica si está recibiendo una señal o no. El detector de IR funcionará mejor cuando su frecuencia coincida con la frecuencia del remitente, pero en la práctica no importa mucho.

Enlaces:

Biblioteca IRremote
Módulo de led emisor infrarrojo – KY-005: Dibujo de la pieza para el editor Fritzing

Artículos relacionados:

Módulo de llave pulsadora – KY-004 (Kit de sensores Keyes 4)

Deja un comentario

Bien, yo hubiese obviado hacer un artículo sobre este módulo: es un pulsador, lo mismo que tomar dos cables y unirlos para enviar una señal. Pero bueno, es parte del kit de “sensores” para Arduino, es el que sigue en orden en la secuencia númerica de Keyes, así que aquí está.

El módulo Keyes KY-004 es una plaqueta con un pulsador y una resistencia que, cuando no se pulsa el interruptor, mantiene la línea en 0V, y cuando se lo pulsa envía un nivel alto. Si no estuviese el resistor, la línea de entrada de un microcontrolador quedaría flotante, y por una entrada flotante ingresa ruido. Es decir, no se puede saber qué puede leer el microcontrolador si uno quiere ingresar ese dato.

Módulo KY-004:

El módulo consta de un interruptor táctil o botón pulsador FZ1713 y una resistencia.

■ Capacidad del contacto: 50mA 12V CC
■ Temperatura: -25° C a 105° C
■ Vida de los contactos: 100.000 ciclos.
■ Fuerza de operación: 180/230 ± 20gf
■ Dimensiones: 18,5 mm x 15 mm

Conexión:

La línea central se conecta a +5V, la línea marcada con un signo – a GND, y la salida está marcada con la letra S. Para conectarlo al Arduino se une a la línea digital 2 de la plaqueta.

/* 
* Programa de prueba de un pulsador KY-004 
*/ 
int pinBoton = 2; // Definir el pin del pulsador
int valor; // Definir una variable numerica

void setup() {
  pinMode(LED_BUILTIN,OUTPUT);
  pinMode(pinBoton,INPUT);
  }
void loop() {
// comprobar el estado de boton
  valor = digitalRead(pinBoton);
// si el boton es presionado enciende el LED
  if(valor == HIGH) 
  {
    digitalWrite(LED_BUILTIN,HIGH);
  }
else
  {
    digitalWrite(LED_BUILTIN,LOW);  
  }
}

* Programa de prueba de un pulsador KY-004

int pinBoton = 2; // Definir el pin del pulsador

int valor; // Definir una variable numerica

void setup() {

pinMode(LED_BUILTIN,OUTPUT);

pinMode(pinBoton,INPUT);

}

void loop() {

// comprobar el estado de boton

valor = digitalRead(pinBoton);

// si el boton es presionado enciende el LED

if(valor == HIGH)

{

digitalWrite(LED_BUILTIN,HIGH);

}

else

{

digitalWrite(LED_BUILTIN,LOW);

}

Módulo de llave pulsadora – KY-004: Dibujo de la pieza para el editor Fritzing

Artículos relacionados:

Robots Didácticos

Robótica, Automatización, control industrial, microcontroladores, electrónica digital

Archivo de la categoría: Componentes

Módulo de teclado sensible al tacto TTP229

LSM6DSOX: acelerómetro y giroscopio con aprendizaje automático incorporado

Módulo de emisor piezoeléctrico pasivo KY-006 (Kit de sensores Keyes 6)

Módulo transmisor de infrarrojo KY-005 (Kit de sensores Keyes 5)

Módulo de llave pulsadora – KY-004 (Kit de sensores Keyes 4)