2 .

DIGITAL

PARPADEAR SIN DEMORA

A veces necesitas hacer dos cosas a la vez. Por ejemplo, es posible que desee
hacer parpadear un LED mientras lee la presión de un botón. En este caso, no
puede usarlo delay(), porque Arduino pausa su programa durante el delay(). Si
se presiona el botón mientras Arduino está en pausa esperando delay() que
pase, su programa perderá la presión del botón.

Este boceto demuestra cómo hacer parpadear un LED sin

usar delay(). Enciende el LED y luego toma nota de la hora. Luego, cada vez
que loop() pasa, verifica si ha pasado el tiempo de parpadeo deseado. Si es así,
enciende o apaga el LED y toma nota de la nueva hora. De esta manera, el LED
parpadea continuamente mientras que la ejecución del boceto nunca se retrasa
en una sola instrucción.

Una analogía sería calentar una pizza en el microondas y también esperar algún
correo electrónico importante. Pones la pizza en el microondas y la pones
durante 10 minutos. La analogía con el uso delay() sería sentarse frente al
microondas y ver el temporizador contar desde 10 minutos hasta que el
temporizador llegue a cero. Si el correo electrónico importante llega durante este
tiempo, lo perderá.

Lo que harías en la vida real sería encender la pizza y luego revisar tu correo
electrónico, y luego tal vez hacer otra cosa (¡eso no toma mucho tiempo!) Y de
vez en cuando volverás al microondas para ver si el temporizador ha llegado a
cero, indica que su pizza está lista.

En este tutorial aprenderá a configurar un temporizador similar.

 HARDWARE REQUERIDO

 Tablero Arduino
 DIRIGIÓ
 Resistencia de 220 ohmios

CIRCUITO

Para construir el circuito, conecte un extremo de la resistencia al pin 13 de la

placa. Conecte la pata larga del LED (la pata positiva, llamada ánodo) al otro
extremo de la resistencia. Conecte la pata corta del LED (la pata negativa,
llamada cátodo) a la placa GND, como se muestra en el diagrama de arriba y el
esquema de abajo.

La mayoría de las placas Arduino ya tienen un LED conectado al pin 13 de la

placa. Si ejecuta este ejemplo sin hardware adjunto, debería ver que el LED
parpadea.
ESQUEMÁTICO

Después de construir el circuito, conecte su placa a su computadora, inicie el

software Arduino (IDE) e ingrese el código a continuación.

CÓDIGO

El siguiente código usa la millis() función, un comando que devuelve la cantidad

de milisegundos desde que la placa comenzó a ejecutar su boceto actual, para
hacer parpadear un LED.
 BOTÓN

Los botones o interruptores conectan dos puntos en un circuito cuando los

presionas. Este ejemplo enciende el LED incorporado en el pin 13 cuando
presiona el botón.

HARDWARE

 Tablero Arduino
 Botón o interruptor momentáneo
 Resistencia de 10K ohmios
 cables de conexión
 tablero de circuitos

CIRCUITO

Conecte tres cables a la placa. Los dos primeros, rojo y negro, se conectan a las
dos filas verticales largas en el costado de la placa para proporcionar acceso al
suministro de 5 voltios y tierra. El tercer cable va del pin digital 2 a una pata del
pulsador. Esa misma pata del botón se conecta a tierra a través de una
resistencia desplegable (aquí, 10K ohmios). La otra pata del botón se conecta al
suministro de 5 voltios.
Cuando el botón está abierto (sin presionar) no hay conexión entre las dos patas
del botón, por lo que el pin está conectado a tierra (a través de la resistencia
desplegable) y leemos un BAJO. Cuando el botón está cerrado (presionado),
hace una conexión entre sus dos patas, conectando el pin a 5 voltios, de modo
que leemos un ALTO.

También puede conectar este circuito de la manera opuesta, con una resistencia
pullup manteniendo la entrada ALTA y bajando cuando se presiona el botón. Si
es así, el comportamiento del boceto se invertirá, con el LED normalmente
encendido y apagado al presionar el botón.

Si desconecta el pin de E / S digital de todo, el LED puede parpadear de forma

errática. Esto se debe a que la entrada es "flotante", es decir, devolverá
aleatoriamente ALTO o BAJO. Es por eso que necesita una resistencia pull-up o
pull-down en el circuito.

ESQUEMÁTICO
CÓDIGO
 REBOTE

Tutoriales > Ejemplos > Digital> Antirrebote

Los botones pulsadores a menudo generan transiciones falsas de apertura /

cierre cuando se presionan, debido a problemas mecánicos y físicos: estas
transiciones pueden leerse como múltiples presiones en muy poco tiempo
engañando al programa. Este ejemplo demuestra cómo eliminar el rebote
de una entrada, lo que significa verificar dos veces en un corto período de tiempo
para asegurarse de que el botón esté definitivamente presionado. Sin supresión
de rebotes, presionar el botón una vez puede causar resultados
impredecibles. Este boceto utiliza la millis() función para realizar un seguimiento
del tiempo transcurrido desde que se presionó el botón.

HARDWARE REQUERIDO

 Tablero Arduino
 botón o interruptor momentáneo
 Resistencia de 10k ohmios
 cables de conexión
 tablero de circuitos

CIRCUITO
ESQUEMÁTICO

CÓDIGO

El siguiente boceto se basa en la versión de rebote de Limor Fried, pero la

lógica se invierte en su ejemplo. En su ejemplo, el interruptor regresa BAJO
cuando está cerrado y ALTO cuando está abierto. Aquí, el interruptor regresa
ALTO cuando se presiona y BAJO cuando no se presiona.
 PULLUP ENTRADA DIGITAL

Ejemplos> Digital

ENTRADA PULLUP SERIAL

Este ejemplo demuestra el uso de INPUT_PULLUP con pinMode (). Supervisa el

estado de un interruptor mediante el establecimiento de una comunicación en
serie entre su Arduino y su computadora a través de USB.

Además, cuando la entrada es ALTA, el LED integrado en el pin 13 se

encenderá; cuando está BAJO, el LED se apagará.

Hardware requerido

 Tablero Arduino
 Un interruptor, botón o interruptor momentáneo
 tablero de circuitos
 conectar cable

CIRCUITO

Conecte dos cables a la placa Arduino. El cable negro conecta tierra a una pata
del botón. El segundo cable va del pin digital 2 a la otra pata del botón pulsador.
Los botones o interruptores conectan dos puntos en un circuito cuando los
presionas. Cuando el botón está abierto (sin presionar) no hay conexión entre las
dos patas del botón. Debido a que el pull-up interno en el pin 2 está activo y
conectado a 5V, leemos ALTO cuando el botón está abierto. Cuando el botón
está cerrado, el Arduino lee BAJO porque se completa una conexión a tierra.

ESQUEMÁTICO

CÓDIGO

En el programa a continuación, lo primero que hará en la función de

configuración es comenzar las comunicaciones en serie, a 9600 bits de datos por
segundo, entre su Arduino y su computadora con la línea:

[Link](9600);

A continuación, inicialice el pin digital 2 como entrada con la resistencia pull-up

interna habilitada:

pinMode(2,INPUT_PULLUP);
La siguiente línea hace que el pin 13, con el LED integrado, sea una salida:

pinMode(13, OUTPUT);

Ahora que su configuración se ha completado, pase al bucle principal de su

código. Cuando su botón no está presionado, la resistencia pull-up interna se
conecta a 5 voltios. Esto hace que Arduino informe "1" o ALTO. Cuando se
presiona el botón, el pin Arduino se tira a tierra, lo que hace que Arduino informe
un "0" o BAJO.

Lo primero que debe hacer en el ciclo principal de su programa es establecer

una variable para contener la información proveniente de su conmutador. Dado
que la información proveniente del conmutador será un "1" o un "0", puede
utilizar un int tipo de datos. Llame a esta variable sensorValue y configúrela
para que sea igual a lo que se esté leyendo en el pin digital 2. Puede lograr todo
esto con solo una línea de código:

int sensorValue = digitalRead(2);

Una vez que Arduino haya leído la entrada, haga que imprima esta información
en la computadora como un DEC valor decimal ( ). Puede hacer esto con el
comando [Link] () en nuestra última línea de código:

[Link](sensorValue, DEC);

Ahora, cuando abra su Serial Monitor en el entorno Arduino, verá un flujo de "0" s
si su interruptor está cerrado, o "1" si su interruptor está abierto.

El LED en el pin 13 se iluminará cuando el interruptor esté en ALTO y se

apagará cuando esté en BAJO.
 DETECCIÓN DE CAMBIO DE ESTADO (DETECCIÓN DE BORDES) PARA
BOTONES

Una vez que haya un botón en funcionamiento, a menudo querrá realizar alguna
acción en función de la cantidad de veces que se presione el botón. Para hacer
esto, necesita saber cuándo el botón cambia de estado de apagado a encendido
y contar cuántas veces ocurre este cambio de estado. A esto se le
llama detección de cambio de estado o detección de borde. En este tutorial
aprendemos cómo verificar el cambio de estado, enviamos un mensaje al
Monitor Serial con la información relevante y contamos cuatro cambios de estado
para encender y apagar un LED.

HARDWARE REQUERIDO

 Tablero Arduino
 botón o interruptor momentáneo
 Resistencia de 10k ohmios
 cables de conexión
 tablero de circuitos

CIRCUITO
Conecte tres cables a la placa. El primero va desde una pata del botón a través
de una resistencia desplegable (aquí 10k ohmios) a tierra. El segundo va desde
la pata correspondiente del pulsador hasta la alimentación de 5 voltios. El tercero
se conecta a un pin de E / S digital (aquí pin 2) que lee el estado del botón.

Cuando el botón está abierto (sin presionar) no hay conexión entre las dos patas
del botón, por lo que el pin está conectado a tierra (a través de la resistencia
desplegable) y leemos un BAJO. Cuando el botón está cerrado (presionado),
hace una conexión entre sus dos patas, conectando el pin a voltaje, de modo
que leemos un ALTO. (El pin todavía está conectado a tierra, pero la resistencia
resiste el flujo de corriente, por lo que la ruta de menor resistencia es a + 5V).

Si desconecta el pin de E / S digital de todo, el LED puede parpadear de forma

errática. Esto se debe a que la entrada es "flotante", es decir, no está conectada
ni a voltaje ni a tierra. Devolverá más o menos aleatoriamente ALTO o BAJO. Es
por eso que necesita una resistencia desplegable en el circuito.

ESQUEMÁTICO
Código

El dibujo a continuación lee continuamente el estado del botón. Luego compara

el estado del botón con su estado la última vez a través del bucle principal. Si el
estado actual del botón es diferente del estado del último botón y el estado actual
del botón es alto, entonces el botón cambió de apagado a encendido. El boceto
luego incrementa un contador de pulsaciones de botones.

El boceto también verifica el valor del contador de pulsaciones de botón, y si es

un múltiplo par de cuatro, enciende el LED en el pin 13. De lo contrario, lo apaga.
 TECLADO SIMPLE USANDO LA FUNCIÓN DE TONO ()

Este ejemplo muestra cómo usar el comando tone () para generar diferentes
tonos según el sensor que se presione.

HARDWARE REQUERIDO

 Tablero Arduino
 Altavoz de 8 ohmios
 3 resistencias de detección de fuerza
 3 resistencias de 10k ohmios
 Resistencia de 100 ohmios
 cables de conexión
 tablero de circuitos

CIRCUITO

Conecte un terminal de su altavoz al pin digital 8 a través de una resistencia de

100 ohmios y su otro terminal a tierra.

Alimente sus tres FSR (o cualquier otro sensor analógico) con 5 V en

paralelo. Conecte cada sensor a los pines analógicos 0-2, usando una
resistencia de 10K como referencia a tierra en cada línea de entrada.
ESQUEMÁTICO
CÓDIGO

El dibujo a continuación lee tres sensores analógicos. Cada uno corresponde a

un valor de nota en una matriz de notas. Si alguno de los sensores está por
encima de un umbral determinado, se reproduce la nota correspondiente.

Aquí está el boceto principal:

El boceto utiliza un archivo adicional, pitches.h. Este archivo contiene todos los
valores de tono para notas típicas. Por ejemplo, NOTE_C4 es la C media.
NOTE_FS4 es F sostenido, y así sucesivamente. Esta tabla de notas fue escrita
originalmente por Brett Hagman, en cuyo trabajo se basó el comando tone
(). Puede resultarle útil cuando quiera hacer notas musicales.

Para crear el archivo pitches.h, haga clic en el botón justo debajo del icono del
monitor en serie y seleccione "Nueva pestaña", o use Ctrl + Shift + N.

Luego pega el siguiente código:

/*************************************************

* Public Constants

*************************************************/

#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978
 REPRODUCIR UNA MELODÍA CON LA FUNCIÓN DE TONO ()

Este ejemplo muestra cómo utilizar el tone() comando para generar

notas. Reproduce una pequeña melodía que quizás hayas escuchado antes.

HARDWARE REQUERIDO

 Placa Arduino
 zumbador piezoeléctrico o un altavoz
 cables de conexión

CIRCUITO

ESQUEMÁTICO
CÓDIGO

El siguiente código utiliza un archivo adicional, pitches.h. Este archivo contiene

todos los valores de tono para notas típicas. Por ejemplo, NOTE_C4 es la C
media. NOTE_FS4 es F sostenido, y así sucesivamente. Esta tabla de notas fue
escrita originalmente por Brett Hagman, en cuyo trabajo se basó el comando
tone (). Puede resultarle útil siempre que desee realizar notas musicales.

El esquema principal es el siguiente:

/*

Melody

Plays a melody

circuit:

- 8 ohm speaker on digital pin 8

created 21 Jan 2010

modified 30 Aug 2011

by Tom Igoe

This example code is in the public domain.

[Link]

*/

#include "pitches.h"
// notes in the melody:
int melody[] = {

NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3,

NOTE_C4
};

// note durations: 4 = quarter note, 8 = eighth note, etc.:

int noteDurations[] = {

4, 8, 8, 4, 4, 4, 4, 4
};

void setup() {

// iterate over the notes of the melody:

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

// to calculate the note duration, take one second divided by the note type.

//e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.

int noteDuration = 1000 / noteDurations[thisNote];

tone(8, melody[thisNote], noteDuration);

// to distinguish the notes, set a minimum time between them.

// the note's duration + 30% seems to work well:

int pauseBetweenNotes = noteDuration * 1.30;

 delay(pauseBetweenNotes);

// stop the tone playing:

noTone(8);

}
}

void loop() {

// no need to repeat the melody.

}

Para crear el archivo pitches.h, haga clic en el botón justo debajo del icono del
monitor en serie y seleccione "Nueva pestaña", o use Ctrl + Shift + N.

Luego pega el siguiente código:

/*************************************************

* Public Constants

*************************************************/
#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978

y guárdelo como parcelas.

 REPRODUCCIÓN DE TONOS EN MÚLTIPLES SALIDAS USANDO LA
FUNCIÓN DE TONO ()

Este ejemplo muestra cómo usar el comando tone () para tocar diferentes notas
en múltiples salidas.

El comando tone () funciona tomando el control de uno de los temporizadores

internos de Atmega, configurándolo en la frecuencia que desee y usando el
temporizador para pulsar un pin de salida. Como solo usa un temporizador, solo
puede tocar una nota a la vez. Sin embargo, puede tocar notas en diferentes
pines, de forma secuencial. Para hacer esto, debe apagar el temporizador para
un pin antes de pasar al siguiente.

Gracias a Greg Borenstein por aclarar esto.

HARDWARE REQUERIDO

 Tablero Arduino
 3 altavoces de 8 ohmios
 3 resistencia de 100 ohmios
 cables de conexión
 tablero de circuitos

CIRCUITO
Esquemático

CÓDIGO

El siguiente dibujo reproduce un tono en cada uno de los altavoces en

secuencia, apagando primero el altavoz anterior. Tenga en cuenta que la
duración de cada tono es la misma que la demora que le sigue.
Aquí está el boceto principal:

/*
Multiple tone player

Plays multiple tones on multiple pins in sequence

circuit:

- three 8 ohm speakers on digital pins 6, 7, and 8

created 8 Mar 2010

by Tom Igoe

based on a snippet from Greg Borenstein

This example code is in the public domain.

[Link]

*/

void setup() {

void loop() {
 // turn off tone function for pin 8:

noTone(8);

// play a note on pin 6 for 200 ms:

tone(6, 440, 200);

delay(200);

// turn off tone function for pin 6:

noTone(6);

// play a note on pin 7 for 500 ms:

tone(7, 494, 500);

delay(500);

// turn off tone function for pin 7:

noTone(7);

// play a note on pin 8 for 300 ms:

tone(8, 523, 300);

delay(300);
}
 SEGUIDOR DE TONO USANDO LA FUNCIÓN TONE ()

Este ejemplo muestra cómo usar el comando tone () para generar un tono que
sigue los valores de una entrada analógica. Usando un fotorresistor, su placa
Arduino se convierte en un theremin ligero simplificado.

HARDWARE REQUERIDO

 Placa Arduino
 Altavoz de 8 ohmios
 fotorresistencia
 Resistencia de 4.7K ohmios
 Resistencia de 100 ohmios
 cables de conexión
 tablero de circuitos

Circuito
Conecte un terminal de su altavoz al pin digital 9 a través de una
resistencia de 100 ohmios y su otro terminal a tierra. Alimente su
fotorresistor con 5V y conéctelo al analógico 0 con la adición de un
resistor de 4.7K a tierra.

ESQUEMÁTICO

CÓDIGO

El código de este ejemplo es muy simple. Simplemente tome una entrada

analógica y asigne sus valores a un rango de tonos audibles. Los humanos
pueden escuchar entre 20 y 20 000 Hz, pero entre 120 y 1500 suele funcionar
bastante bien para este boceto.

Necesitará obtener el rango real de su entrada analógica para el mapeo. En el

circuito que se muestra, el valor de la entrada analógica osciló entre 400 y 1000
aproximadamente. Cambie los valores en el comando map () para que coincidan
con el rango de su sensor.

El croquis es el siguiente:
/*
Pitch follower

Plays a pitch that changes based on a changing analog input

circuit:

- 8 ohm speaker on digital pin 9

- photoresistor on analog 0 to 5V

- 4.7 kilohm resistor on analog 0 to ground

created 21 Jan 2010

modified 31 May 2012

by Tom Igoe, with suggestion from Michael Flynn

This example code is in the public domain.

[Link]
*/

void setup() {

// initialize serial communications (for debugging only):

[Link](9600);
}

void loop() {

// read the sensor:

int sensorReading = analogRead(A0);

// print the sensor reading so you know its range

[Link](sensorReading);

// map the analog input range (in this case, 400 - 1000 from the
photoresistor)

// to the output pitch range (120 - 1500Hz)

// change the minimum and maximum input numbers below depending

on the range

// your sensor's giving:

int thisPitch = map(sensorReading, 400, 1000, 120, 1500);

// play the pitch:

tone(9, thisPitch, 10);

delay(1); // delay in between reads for stability

}