Apunte de Arduino Hecho Por Ronald Parte 2

Arduino
2. Digital
 Blink Without Delay: blinking an LED without using the delay() function.
 Button: use a pushbutton to control an LED.
 Debounce: read a pushbutton, filtering noise.
 Button State Change: counting the number of button pushes.
 Input Pullup Serial: Demonstrates the use of INPUT_PULLUP with pinMode().
 Tone: play a melody with a Piezo speaker.
 Pitch follower: play a pitch on a piezo speaker depending on an analog input.
 Simple Keyboard: a three-key musical keyboard using force sensors and a piezo speaker.
 Tone4: play tones on multiple speakers sequentially using the tone() command.
Ing. Ronald N. Kopp Página 1

Arduino
7. Blink Without Delay: parpardeo con retraso
A veces es necesario hacer dos cosas al mismo tiempo. Por ejemplo, queremos hacer parpadear un
LED (o alguna otra función sensible al tiempo) y al mismo instante tomar una lectura, ya sea de un
pulsador (u otra entrada), que está siendo presionado (o activado). En este caso, no podríamos usar el
comando delay(), porque Arduino detiene el programa durante la ejecución del comando delay(). Si el
pulsador se presiona mientras el Arduino se encuentra detenido por el comando delay(), el programa
se perderá la señal del pulsador durante el tiempo del delay.
En este boceto, veremos cómo hacer parpadear el LED, sin usar el comando delay(). Se enciende el LED
y en ese momento se toma nota del tiempo. Entonces, cada vez que se recorre el bucle loop(), se
comprueba si un intervalo de tiempo de parpadeo ha pasado. Si es así, se conmuta el LED entre
encendido y/o apagado y se toma nota del tiempo de nuevo. De este modo, el LED parpadeará
continuamente.
Una analogía sería estar calentando una pizza en el horno de microondas, y también estar esperando
un correo electrónico importante. Si pusiéramos la pizza en el microondas y ajustáramos el tiempo
durante 10 minutos. La analogía usando el comando delay() sería, sentarse delante del microondas y
ver la cuenta del temporizador desde los 10 minutos, hasta que el temporizador llegue a cero. Si el
correo electrónico importante llegará durante este tiempo, lo perderíamos.
Lo que se puede hacer en la vida real sería encender la pizza, y luego consultar nuestro correo
electrónico, y luego tal vez hacer algo más (que no tomará demasiado tiempo) y cada cierto tiempo
volver al microondas para ver si el temporizador ha llegado a cero, lo que indicaría que la pizza está
terminada.
Hardware Required
 ArduinoBoard
 LED
Circuit

Arduino
Para construir el circuito, agarramos un LED y colocamos la pata más larga, positivo (llamado el ánodo),
al pin 13 y conectemos la pata más corta, el negativo (llamado el cátodo), a tierra. A continuación,
conectamos la placa Arduino al ordenador, iniciamos el programa de Arduino, e introducimos el código
de abajo.
Schematic:

Arduino
Code
El código siguiente utiliza el comando millis(), un comando que devuelve el número de milisegundos
desde que la placa Arduino empezó a correr su programa actual, o sea desde que parpadeo el LED.
// constantes que no cambiarán.

const int ledPin = 13; // el número del pin en el que está el LED
// variables que cambiarán:

int ledState = LOW; // variable usada para configurar el estado del LED
long previousMillis = 0; // almacena el último tiempo en que el LED parpadeó
// las siguientes variables son grandes porque el tiempo, es medido en milisegundos y

// se convertirá rápidamente en un número muy grande que no puede ser almacenada en un int
long interval = 1000; //Intervalo entre parpadeos (milisegundos)
void setup() {
pinMode(ledPin, OUTPUT); // inicializamos el pin digital ledPin como una salida
}
void loop() {
// comprobamos para ver si es tiempo de que parpadeé el LED; es decir,
// si la diferencia entre la hora actual y la última vez que parpadeó el LED
// es mayor que el intervalo en el que deseamos que parpadee el LED.
unsigned long currentMillis = millis();
if(currentMillis - previousMillis > interval) {
previousMillis = currentMillis; // guardaremos el tiempo de la última vez que parpadeó el LED
// si el LED está apagado, se encenderá y se apagará:

if (ledState == LOW)
ledState = HIGH;
else // de otra forma
ledState = LOW;
// escribimos en el LED el valor de la variable ledState:

digitalWrite(ledPin, ledState);
}
}

Arduino
Nombre const
Ejemplo const int a = 10;
void setup(){
Serial.begin(9600);
}
void loop()
{
Serial.println(a); // imprime el valor de a
// quite el comentario de la línea de la suma para

// ver el error generado por el compilador ya que a no se pude cambiar
// el valor de a
// a = a + 1;
delay(200);
}
Descripción La palabra const es usada para crear variables de solo lectura, no es posible asignar
a una variable const, valores después de haber sido creada. Estas deben ser
inicializadas cuando se declaran. Son útiles cuando el compilador realiza
optimizaciones, por ejemplo al ser usadas para especificar un número de pin el cual
no va a cambiar en el código.
Sintaxis const Datatype variablename = initialvalue
Parámetro Datatype Cualquier tipo de dato: int, double, long, char, byte etc
Variablename Cualquier nombre de variable válido
Initialvalue Un valor inicial para la variable (este no podrá cambiarse después)
Nombre long
Ejemplo long a; // Declara la variable "a" como tipo long
a = 23; // Asigna a "a" el valor 23
long b = -256; // Declara la variable "b" y le asigna el valor -256
long c = a + b; // Declara la variable "c" y le asigna la suma de "a" y "b"
Descripción Tipo de dato para números enteros long (32 bits), números sin punto decimal. Los
números enteros long pueden ser tan grande como 2147483647 y tan pequeños
como -2147483648. Ellos son almacenados como 32 bits (4 bytes) de información.
Sintaxis long Var
long Var = Valor
Parámetro Var Nombre de la variable referenciada al valor
Valor Cualquier número entero
Nombre unsigned long

Ejemplo unsigned long a; // Declara la variable "a" de tipo entero sin signo
a = 23; // Asigna a "a" el valor 23

Arduino
unsigned long b = -256; // Declara la variable "b" y le asigna el valor -256
unsigned long c = a + b; // Declara la variable "c" y le asigna el valor de la suma
de "a" y "b"
Descripción Tipo de dato para enteros sin signo (32 bits), números sin punto decimal. Los enteros
largos pueden ser tan grandes como 4294967295 y tan pequeños como 0. Son
almacenados como 32 bits ( 4 bytes ) de información.
Sintaxis Unsigned long Var
Unsigned long Var = Valor
Parámetro Var Nombre de la variable referenciada al valor
Valor Cualquier valor entero
Nombre millis()
Descripción Devuelve el número de milisegundos (milésimas de segundo) desde que empieza la
aplicación. Esta información es a menudo usada para secuencias de tiempo.
Sintaxis millis()
Nombre else
Descripción Extiende la estructura if () permitiendo al programa escoger entre dos o más bloques
de código. Especifica un bloque de código que se ejecuta cuando la expresión en el
if () es falsa.
Sintaxis if (expresión) {
declaración
} else {
declaración
}
if (expresión) {
declaración
} else if (expresión) {
declaración
} else {
declaración
}
Parámetro Expresión Cualquier expresión valida que evalúa verdadero o falso (true o
false)
Declaración Una o más instrucciones para ser ejecutadas

Arduino
8. Button: utilizar un pulsador para controlar un LED.
En este ejemplo se enciende un LED conectado al pin 13 a través de una resistencia de 220 Ohm (no
dibujado en el circuito). Cuando presionamos el pulsador conectado al pin 2.
Hardware
 Arduino Board
 momentary button or switch
 10K ohm resistor
 breadboard
 hook-up wire
Circuit
Conectamos tres cables. Los dos primeros, rojo y negro, se conectan a las dos filas horizontales largas
en el lado derecho del protoboard, para proporcionar acceso a la alimentación de 5 voltios y a tierra.
El tercer cable va desde pin digital 2 a una pata del pulsador. Esa misma pata del pulsador se conecta
a través de una resistencia pull-down (en este caso de 10 KOhms) a tierra. La otra pata del botón se
conecta a la alimentación de 5 voltios.
También se puede conectar este circuito en sentido contrario, con una resistencia de pull-up
manteniendo la entrada ALTA, y poniendo en BAJO al pulsar el pulsador. Si es así, el comportamiento
del boceto se invertirá, el LED estará normalmente encendido y se apagará cuando se presiona el
pulsador
Si desconectamos las I/O digitales del todo, el LED puede parpadear de forma errática. Esto es porque
la entrada está "flotando", es decir, dará al azar un valor alto o bajo. Por ello se necesita colocar una
resistencia pull-up o una resistencia de pull-down en el circuito.

Arduino
Schematic:

Arduino
Code
// constantes que no cambiarán. Usados aquí para configurar los números de los pines
const int buttonPin = 2; // número de pin del pulsador
const int ledPin = 13; // número de pin del LED

int buttonState = 0; // variable para leer el estado del pulsador
void setup() {
pinMode(ledPin, OUTPUT); // configuramos el ledPin como una salida
pinMode(buttonPin, INPUT); // configuramos el buttonpin como una entrada
}
void loop(){
buttonState = digitalRead(buttonPin); // leemos el estado del pulsador
if (buttonState == HIGH) { // comprobamos si se presionó el pulsador.

// Si es así, buttonState es un ALTO
digitalWrite(ledPin, HIGH); // entonces encendemos el LED

}
else { // de otro modo / de lo contrario
digitalWrite(ledPin, LOW); // apagamos el LED
}
}

Arduino
9. Debounce/De rebote: leer la señal de un pulsador y filtrar el ruido.
Este ejemplo muestra cómo evitar el rebote de una entrada, lo que significa comprobar dos veces en
un corto período de tiempo para asegurarse de que está definitivamente presionado. Sin la supresión
de rebotes, al pulsar el pulsador una vez, puede parecer que se haya pulsado varias veces. Se hace uso
del comando millis() para realizar un seguimiento de las veces que es pulsado el pulsador.
Hardware Required
 Arduino Board
 breadboard
 hook-up wire
Circuit

Arduino
Schematic
El código siguiente se basa en la versión de Limor Fried de supresión de rebotes, pero se invierte la
lógica de su ejemplo. En su ejemplo, el pulsador retorna a BAJO cuando está cerrado, y a ALTO cuando
está abierto. En este caso, el pulsador regresa a ALTO cuando se presiona y a BAJO cuando no se
presiona.

Arduino
Code
Cada vez que el pin de entrada va de BAJO a ALTO (por ejemplo, debido a un pulsador que se aprieta),
el pin de salida se conmuta de BAJO a ALTO o ALTO a BAJO. Hay una demora mínima entre alternación
para evitar el rebote del circuito (es decir, para ignorar ruido).
// constantes que no cambiarán:

const int buttonPin = 2; // número de pin del pulsador
const int ledPin = 13; // número de pin del LED

int ledState = HIGH; // declara la variable ledState
int buttonState; // declara la variable buttonState (pulsador)
int lastButtonState = LOW; // declara la variable lastButtonState
// para almacenar el valor anterior del pulsador
// las siguientes variables son valores grandes porque el tiempo es medido en milisegundos,
// y se convertirá rápidamente en un número muy grande que puede ser almacenadas
// en un tipo de dato long
long lastDebounceTime = 0; // la última vez que el pin de salida se conmutó

long debounceDelay = 50; // el tiempo de rebote; aumentar si la salida rebota
void setup() {
pinMode(buttonPin, INPUT);
pinMode(ledPin, OUTPUT);
// configuración del estado inicial del LED, como esta seteado en HIGH el LED estará encendido
digitalWrite(ledPin, ledState);
}
void loop() {
int reading = digitalRead(buttonPin); // leemos el estado del pulsador
// y lo cargar en la variable reading
if (reading != lastButtonState) { // comprobamos si el estado del pulsador cambio

// (por ej., si la entrada fue de un BAJO a un ALTO)
lastDebounceTime = millis(); // si es así, restablecemos el temporizador
if ((millis() - lastDebounceTime) > debounceDelay) { // comprobamos si permaneció la señal el

// tiempo suficiente, para no ser un ruido

Arduino
if (reading != buttonState) { // y sí además el pulsador ha cambiado

buttonState = reading; // se toma este valor, como el valor actual
if (buttonState == HIGH) { // solo conmutaremos el LED sí el nuevo estado

// del pulsador es un ALTO
ledState = !ledState;
}
}
}
digitalWrite(ledPin, ledState); // escribimos en el LED el valor de ledState
lastButtonState = reading; // guardamos la lectura para La próxima vez que se recorra el bucle
// que será el lastButtonState
}
Nombre != (no equivalente)

Ejemplo int a = 22;
int b = 23;
if (a != b) {
Serial.print("la variable a no es igual a la variable b");
}
Descripción Determina si una expresión no es equivalente a otra
Sintaxis Valor1 != Valor2
Parámetros Valor 1 int, char, byte, boolean
Valor 2 int, char, byte, boolean
Nombre ! (lógica NOT)

Descripción Invierte el valor Boleano de una expresión. Retorna true si la expresión es false y
retorna false si la expresión es true. Si la expresión (a>b) es evaluada como verdad,
entonces !(a>b) es evaluada como falsa.
Sintaxis ! Expresión
Parámetros Expresión Cualquier expresión valida

Arduino
10. Button State Change: contar el número de cambios de estado del pulsador.
Cuando tenemos un pulsador trabajando, a menudo se quiere hacer una acción basado en la cantidad
de veces que se pulsa el pulsador. Para ello, lo que se necesita saber es cuando el botón cambio el
estado de apagado a encendido, y contar cuántas veces sucede este cambio de estado. Esto se conoce
como la detección de cambio de estado o de detección de flanco.
Hardware Required
 Arduino Board
 breadboard
 hook-up wire
Circuit
Conectamos tres cables a la placa Arduino. La primera va desde una pata del pulsador a través de una
resistencia de caída (en este caso 10 KOhms) a tierra. El segundo va desde la otra pata del pulsador a
la alimentación de 5 voltios. El tercero se conecta a una E / S digital pin (aquí pin 2) que lee el estado
del botón.
Cuando el pulsador está abierto (sin apretar) no hay conexión entre las dos patas del pulsador, por lo
que el pin está conectado a tierra (a través de la resistencia de pull-down) y nos leerá un BAJO. Cuando
se cierra el pulsador (apretándolo), se establece una conexión entre sus dos patas, conectando el pin
a la tensión, por lo que leemos un ALTO. (El pulsador está todavía conectado a tierra, pero la resistencia
se opone al flujo de corriente, por lo que el camino de menor resistencia es el que va de + 5V al pin 2).
Si desconectamos las E/S digitales del todo, el LED puede parpadear de forma errática. Esto es porque
la entrada está "flotando", es decir, dará al azar un valor alto o bajo. Por ello se necesita colocar una
resistencia pull-up o una resistencia de pull-down en el circuito.

Arduino
Schematic
El programa de abajo lee continuamente el estado del pulsador. A continuación, compara el estado
del pulsador, con el estado de la última vez que el pulsador cambio, en el bucle principal. Si el estado
del pulsador actual es diferente del último estado de pulsador y el estado del botón actual está ALTO,
el botón cambia de apagado a encendido. En ese caso, el programa incrementará el contador del
pulsador.
El comando también comprueba el valor del contador del pulsador, y si se trata de un múltiplo de
cuatro, enciende el LED en el pin. De lo contrario, lo apaga.

Arduino
Code
// constantes que no cambiarán

const int buttonPin = 2; // el pin en el que, él pulsador está conectado
const int ledPin = 13; // el pin en el que, él LED está conectado
// Variables que cambiarán:

int buttonPushCounter = 0; // contador de veces que el pulsador es presionado
int buttonState = 0; // estado actual del pulsador
int lastButtonState = 0; // estado previo del pulsador
void setup() {
pinMode(buttonPin, INPUT); // configuramos el buttonPin como una entrada

pinMode(ledPin, OUTPUT); // configuramos el ledPin como una salida
Serial.begin(9600); // comenzamos la comunicación serial

}
void loop() {
buttonState = digitalRead(buttonPin); // leemos el pin de entrada del pulsador
// y lo almacenamos en buttonState
if (buttonState != lastButtonState) { // comparábamos el buttonState con su estado anterior,
// sí su el estado ha cambiado
if (buttonState == HIGH) { // y además es equivalente a un ALTO,
buttonPushCounter++; // incrementamos el contador
Serial.println("on");
Serial.print("number of button pushes: "); // imprimimos number of button pushes:
Serial.println(buttonPushCounter); // imprimimos la variable buttonPushCounter
}
else { // de otra manera, como el pulsador cambio de encendido a apagado,
// el estado actual es un BAJO
Serial.println("off"); // imprimimos off
}
}
lastButtonState = buttonState; // guardaremos el estado actual como el último estado

// para la próxima vez que se recorra el bucle
// encenderemos el LED cada cuatro veces que se pulsa el pulsador

// comprobando el módulo de la variable buttonPushCounter
// la función modulo da el resto de la división de dos números,
// si el resto es cero, eso quiere decir que es múltiplo de 4:

Arduino
if (buttonPushCounter % 4 == 0) {
digitalWrite(ledPin, HIGH);
} else {
digitalWrite(ledPin, LOW);
}
}
Nombre ++ (incremento)
Ejemplo int a = 0; // Inicializa "a" en 0
a++;
int b = a; // Inicializa "b" en 1
Descripción Incrementa el valor de una variable entera en 1. Es equivalente a la operación i = i +

1. Si el valor de la variable i es cinco, la expresión i++ incrementa el valor de i a 6.
Sintaxis Valor++
Parámetros Valor int
Nombre % (modulo)
Ejemplo int a = 20%100; // Asigna a como 20
int b = 20%100; // Asigna b como 20
int c = 75%100; // Asigna c como 75
int d = 275%100; // Asigna d como 75
Descripción Calcula el resto cuando un número es dividido por otro.
Sintaxis Valor1 % Valor2
Parámetros Valor 1 int
Valor 2 int

Arduino
11. Input Pullup Serial: Demonstrar el uso de INPUT_PULLUP con el pinMode().
Este ejemplo demuestra el uso de INPUT_PULLUP en el pinMode (). Supervisando el estado de un

interruptor mediante la comunicación en serie entre el Arduino y el ordenador a través del USB.
Además, cuando la entrada es un ALTO, el LED en el protoboard unido al pin 13 se encenderá; cuando
es un BAJO, el LED se apagará.
Hardware Required
 Arduino Board
 A momentary switch, button, or toggle switch
 breadboard
 hook-up wire
Circuit
Conectamos dos cables a la placa Arduino. El cable negro conectamos a tierra y a una pata del pulsador.
El segundo cable va del pin digital 2 a la otra pata del pulsador.
Cuando el pulsador está abierto (sin apretar) no hay conexión entre las dos patas del pulsador. Debido
a que la resistencia interna de pull-up en el pin 2 está activa y conectada a 5V, leemos un ALTO cuando
el pulsador está abierto. Cuando se cierra el pulsador, el Arduino lee un BAJO debido a que la conexión
a tierra se ha completado.

Arduino
Schematic

Arduino
Code
En el siguiente programa, la primera cosa que hacemos en la función de configuración es comenzar la
comunicación serial, a 9600 bits de datos por segundo, entre la placa Arduino y el ordenador con la
línea:
Serial.begin(9600);
A continuación, configurarnos el pin digital 2 como una entrada con la resistencia pull-up interna
habilitada:
pinMode(2, INPUT_PULLUP);
En la siguiente línea lo que se hace es configurar al pin 13 como una salida

pinMode(13, OUTPUT);
Ahora que su configuración se ha completado, nos introducimos en el bucle principal de nuestro

código. Cuando no se presiona el botón, la resistencia pull-up interna se conecta a 5 voltios. Esto hace
que el Arduino informe un "1" o un ALTO. Cuando se pulsa el botón, el pin de Arduino se pone a tierra,
haciendo que el Arduino informe un "0", o un BAJO.
Lo primero que hay que hacer en el bucle principal del programa es establecer una variable para
contener la información que viene del pulsador. Dado que la información que viene del pulsador será
un "1" o un "0", se puede utilizar un tipo de datos int. Llamando a ésta variable sensorValue, y lo
ponemos a que sea igual a todo lo que se lee en el pin digital 2. Se puede lograr todo esto con una sola
línea de código:
int sensorVal = digitalRead(2);
Una vez que el Arduino ha leído la entrada, hacemos que se imprima esta información a la
computadora como un valor decimal (DEC). Se puede hacer esto con el comando Serial.println () en la
última línea del código:
Serial.println(sensorVal);
Ahora, cuando se abre el monitor serial en el entorno Arduino, se verá una corriente de "0" s sí el
pulsador está cerrado, o de "1" s si el pulsador está abierto.
El LED en el pin 13 se iluminará cuando el pulsador esté en ALTO, y se apagará cuando esté en BAJO.
void setup(){
Serial.begin(9600); //comenzamos la comunicación serial
pinMode(2, INPUT_PULLUP); // configura el pin2 como una entrada

// y habilitamos la resistencia interna pull-up
pinMode(13, OUTPUT); // configurar al pin 13 como una salida
}

Arduino
void loop(){
int sensorVal = digitalRead(2); // leemos el valor del pulsador y lo cargamos en la variable sensorVal
Serial.println(sensorVal); // imprimimos el valor del pulsador
// tengamos en cuenta que la forma pullup de pulsar, es lógica invertida

// esto será un ALTO cuando está abierto y un BAJO cuando esté presionado.
// esto enciende el pin 13 cuando el pulsador está presionado, y lo apaga cuando no lo esta
if (sensorVal == HIGH) { // si sensorVal es equivalente a un Alto

digitalWrite(13, LOW); // apagamos el led
}
else { // de otra manera
digitalWrite(13, HIGH); // lo apagamos
}
}

Arduino
12. Tono: tocar una melodía con un altavoz piezoeléctrico.
Este ejemplo muestra cómo utilizar el comando tono () para generar notas. Creando una pequeña
melodía que después puede ser oída.
Hardware Required
 Arduino board
 8 ohm small speaker
 100 ohm resistor
 hook-up wire
Circuit
Conectamos un terminal del altavoz al pin digital 8 a través de una resistencia de 100 ohmios. Y
conectamos el otro terminal a tierra.

Arduino
Schematic

Arduino
Code
El programa siguiente utiliza un archivo extra, pitches.h. Este archivo contiene todos los valores de
tono para las notas típicas. Por ejemplo, NOTE_C4 es Do en la octava media. NOTE_FS4 es Fa sostenido,
y así sucesivamente. Esta tabla de nota fue escrita originalmente por Brett Hagman, en cuyo trabajo
se basó el comando de tone(). Puede que nos resulte útil para cuando queramos tomar notas
musicales.
#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_A3 220
#define NOTE_B3 247
#define NOTE_C4 262

Arduino
#define NOTE_D4 294
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_G4 392
#define NOTE_A4 440
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_D5 587
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_G5 784
#define NOTE_A5 880
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_D6 1175
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_G6 1568
#define NOTE_A6 1760
#define NOTE_B6 1976
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_G7 3136
#define NOTE_A7 3520
#define NOTE_B7 3951

Arduino
#include "pitches.h"
int melody[] = { // Notas de la melodía

NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3, NOTE_C4};
int noteDurations[] = { // duración de la nota: 4 = quarter note, 8 = eighth note, etc.:

4, 8, 8, 4, 4, 4, 4, 4 };
void setup() {
for (int thisNote = 0; thisNote < 8; thisNote++) { // repite las notas de la melodía
// para calcular la duración de la nota, se toma un segundo

// y se divide por el tipo de nota
//ej. quarter note = 1000 / 4, eighth note = 1000/8, etc.
int noteDuration = 1000/noteDurations[thisNote];
tone(8, melody[thisNote],noteDuration);
// para distinguir las notas, se establece un tiempo mínimo de pausa entre ellas
// la duración de la nota + 30% parece funcionar bien:
int pauseBetweenNotes = noteDuration * 1.30;
delay(pauseBetweenNotes);
noTone(8); // detener la reproducción del tono en el pin 8

}
}
void loop() {
// No hay necesidad de repetir la melodía.
}

Arduino
Nombre #include
Ejemplo #include "LiquidCrystal.h" // incluye la librería LiquidCrystal en el programa
LiquidCrystal myDisplay = LiquidCrystal(8,9,10,2);

int a = 0;
void setup()
{
void loop()
{
myDisplay.clear();
myDisplay.home();
myDisplay.print("Variable a es: ");
myDisplay.setCursor(16, 0);
myDisplay.print(a);
a = a + 1;
delay(200);
}
Descripción La directiva #include es usada para importar una librería externa en un programa.
Una directiva #include es agregada automáticamente a un programa después de
seleccionar una librería con el menú Sketch/Import Library. Note que la directiva
tiene una sintaxis especial, a diferencia de otros comandos esta no finaliza con un
punto y coma.
Sintaxis #include
Nombre array[]
Ejemplo int numbers[] = { 90, 150, 30 }; // declara un arreglo de enteros
int a, b;
void setup() {
a = numbers[0] + numbers[1]; // Asigna a "a" el valor 240
b = numbers[1] + numbers[2]; // Asigna a la variable "b" el valor 180
}
// formas diferentes de declarar arreglos de caracteres

char string1[15]; // declaramos una matriz
char string2[7] = {'h', 'e', 'l', 'l', 'o', '!'}; /* inicializamos y dimensionamos una
matriz. Tengamos en cuenta que al declarar una matriz del tipo char, se

Arduino
requiere un elemento más en su inicialización, para mantener el carácter
nulo requerido, o sea el espacio.
char string3[7] = {'h', 'e', 'l', 'l', 'o', '!', ''};
char string4[] = "hello there!"; /* declaramos una matriz sin elegir

explícitamente un tamaño. El compilador cuenta los elementos y crea una
matriz del tamaño apropiado */
int a = 10;
char *string5 = new char[a+1]; // reserva espacio para un arreglo de 10 characters
/* (la última posición es para almacenar el caracter
'' o finalizador de cadenas de caracteres NULL) */
delete [] string5; // libera el espacio de memoria reservado para string5
Descripción Un arreglo es una lista de datos. Es posible tener un arreglo de cualquier tipo de
datos. Cada dato en un arreglo es identificado por un índice numérico que
representa su posición en el arreglo. El primer elemento en el arreglo es [0], el
segundo elemento es [1], y así sucesivamente.
Sintaxis Datatype Var[]
Var[elemento] = valor
Parámetros Datatype Cualquier tipo de datos primitivo o compuesto, incluyendo clases
definidas por el usuario
Var Cualquier variable con un nombre válido
elemento Int: No debe exceder la longitud del arreglo -1
valor Dato a asignar al elemento del arreglo, debe ser el mismo tipo de
datos del arreglo
Nombre for ()
Ejemplo // set pins 8-15 to HIGH
for (int i=8; i<16; i=i+1) {
digitalWrite(i, HIGH);
}
Descripción Controla una secuencia de repeticiones. Una estructura for () tiene tres partes:
inicialización, evaluación, y actualización. Cada parte debe estar separada por un
punto y coma ";". El ciclo continúa hasta que la evaluación evalúe false. Cuando una
estructura for () es ejecutada, la siguiente secuencia de eventos ocurre:
1. La instrucción de inicialización es ejecutada
2. Se evalúa la expresión de evaluación true o false
3. Si es true, salta al paso 4. Si es false, salta al paso 6
4. Ejecuta las instrucciones contenidas en el bloque
5. Ejecuta la expresión de actualización y salta al paso 2
6. Termina el ciclo

Arduino
Sintaxis for (Inicializa; Evalúa; Actualiza) {
declaraciones
}
Parámetros Inicializa Expresión ejecutada cuando se inicia el ciclo
Evalúa Si la expresión de evaluación evalúa true, se ejecutan las
instrucciones del bloque
Actualiza Se ejecuta al final de cada iteración
Declaraciones Colección de expresiones que se ejecutan en cada iteración del
ciclo.
Nombre tone()
Ejemplo void setup() {
// genera un tono de 400Hz en el pin de salida 8 con 200ms de duración
tone(8, 400, 200);
}
void loop() {
}
void setup() {
// genera un tono de 415Hz en el pin de salida 8 con una duración infinita
tone(8, NOTE_GS4);
}
void loop() {
}
Descripción La función tone() genera un tono a una frecuencia determinada en hertz en un pin
específico con una duración especificada. El comando tone() usa recursos como
timers para generar el tono de forma precisa.
Sintaxis tone(Pin, Frecuencia, Duración)
tone(Pin, Frecuencia)
Parámetros Pin int: El número del pin de salida en el que el tono será generado.
Frecuencia int: La frecuencia del pulso en Hertz. Las siguientes frecuencias de
tonos están predefinidas en el lenguaje:
NOTE_B0=31, NOTE_C1=33, NOTE_CS1=35, NOTE_D1=37,
NOTE_DS1=39, NOTE_E1=41, NOTE_F1=44, NOTE_FS1=46,
NOTE_G1=49, NOTE_GS1=52, NOTE_A1=55, NOTE_AS1=58,

Arduino
NOTE_DS6=1245, NOTE_E6=1319, NOTE_F6=1397,
NOTE_FS6=1480, NOTE_G6=1568, NOTE_GS6=1661,
NOTE_A6=1760, NOTE_AS6=1865, NOTE_B6=1976, NOTE_C7=2093,
NOTE_CS7=2217, NOTE_D7=2349, NOTE_DS7=2489,
NOTE_E7=2637, NOTE_F7=2794, NOTE_FS7=2960, NOTE_G7=3136,
NOTE_GS7=3322, NOTE_A7=3520, NOTE_AS7=3729,
NOTE_B7=3951, NOTE_C8=4186, NOTE_CS8=4435, NOTE_D8=4699
y NOTE_DS8=4978
Duración int: La duración en milisegundos o nada para una duración infinita
(hasta que se invoque el comando noTone(), o se llame un nuevo
tone()
Nombre noTone()
Ejemplo void setup() {
// Asigna el pin digital 8 como entrada para conectar un switch
pinMode(8, INPUT);
// genera un tono de 400Hz en el pin de salida 7
// con duración infinita
tone(7, 400);
}
void loop() {
// Si el switch está; presionado detiene el tono en el pin 7
if (digitalRead(8) == HIGH) {
noTone(7);
}
}
Descripción El método noTone() detiene la generación de un tono en un pin de salida específico.
Sintaxis noTone(Pin)
Parámetros Pin int: El número del pin de salida donde se detendrá la generación del
tono

Arduino
Nombre #define
Ejemplo // reemplaza COUNT con el número 1000
// no usa memoria para una variable
#define COUNT 1000
int i = 0;
void setup()
{
Serial.begin(9600);
}
void loop()
{
if (i < COUNT) {
Serial.print("i = ");
Serial.println(i);
}
i = i+1;
}
________________________________________
// reemplaza MYLED con el número 8
// no usa memoria para una variable
#define MYLED 8
void setup()
{
pinMode(MYLED, OUTPUT);
}
void loop()
{
digitalWrite(MYLED, HIGH);
delay(100);
digitalWrite(MYLED, LOW);
delay(100);
}
Descripción La directiva #define direcciona al preprocesador para reemplazar todas las
ocurrencias de un identificador con el correspondiente token de reemplazo. El
preprocesador reemplaza todas las apariciones subsecuentes del identificador
COUNT con el token 1000 como se muestra en el primer ejemplo. #define COUNT
1000.
Sintaxis #define identifier replacement
Parámetros Identifier el token (simbolo) a ser reemplazado
Replacement el valor con el que se reemplaza

Arduino
13. Pitch follower: reproducir un tono en un altavoz piezoeléctrico siguiendo una entrada analógica.
Este ejemplo muestra cómo utilizar el comando tone() para generar un tono que sigue los valores de
una entrada analógica
Hardware Required
 8-ohm speaker
 1 photocell
 4.7K ohm resistor
 100 ohm resistor
 breadboard
 hook up wire
Circuit
Conectamos un terminal de nuestro altavoz al pin digital 9 a través de una resistencia de 100 ohmios,
y el otro terminal a tierra. Potenciamos nuestro fotoresistor con 5V, y lo conectamos a la entrada
analógica 0 con la adición de una resistencia de 4.7K a tierra.

Arduino
Schematic
El código para este ejemplo es muy simple. Basta con echar una entrada analógica y trazar sus valores
a un rango de tonos audibles. Los seres humanos pueden escuchar de 20 - 20.000 Hz, pero 120 a 1500
por lo general funciona bastante bien para este bosquejo.
Tendremos que obtener el rango real de nuestra entrada analógica para la asignación. En el circuito
mostrado, el valor de entrada analógica varía de 400 a 1000. Cambiar los valores con el comando map()
para que coincida con el rango que queremos escuchar.

Arduino
Code
void setup() {
Serial.begin(9600); // iniciamos la comunicación con el puerto serial
}
void loop() {
int sensorReading = analogRead(A0); // leemos el sensor
Serial.println(sensorReading); // imprimimos la lectura del sensor para conocer su rango
// mapeamos el rango de entrada analógica (en este caso, 400 - 1000 del fotoresistor)
// para el rango de salida audible del tono que queremos (120 - 1500Hz)
// cambiando los números máximos y mínimos de la entrada
// dependiendo del rango que tenga nuestro sensor:
int thisPitch = map(sensorReading, 400, 1000, 120, 1500);
tone(9, thisPitch, 10); // ejecutamos el tono

delay(1); // retraso entre la lectura para la estabilidad.
}
Nombre map()
Ejemplo int value;
int m;
void setup() {
Serial.begin(9600);
}
void loop() {
value = analogRead(0);
m = map(value, 0, 255, 0, 100); // convierte un número de un rango entre
// 0-255 a un número en un rango entre 0-100
Serial.println(m);
delay(100);
}
Descripción Re-mapea el número desde un rango a otro. En el ejemplo anterior, el número Valor
es convertido de un valor entre el rango 0..255 a un valor dentro del rango de 0 a
100.
Sintaxis map(Valor, Min1, Max1 ,Min2 , Max2);
Parámetros Valor float: El valor que entrada que será convertido
Min 1 float: El límite más bajo para el rango del valor actual
Max 1 float: El límite más alto para el rango del valor actual

Arduino
Min 2 float: El limite más bajo para el rango objetivo
Max 2 float: El limite más alto para el rango objetivo

Arduino
14. Simple Keyboard: realizar un teclado musical de tres teclas, usando sensores de fuerza y un altavoz
piezoeléctrico.
Este ejemplo muestra cómo utilizar el comando tone(), para generar diferentes tonos, dependiendo
del sensor que se pulse.
Hardware Required
 8-ohm speaker
 (3) force sensing resistors
 (3) 10k ohm resistors
 (1) 100 ohm resistor
 breadboard
 hook up wire
Circuit
Conectamos un terminal del altavoz al pin digital 8, a través de una resistencia de 100 ohmios, y su
otro terminal a tierra.
Alimentamos los tres FSRs (o cualquier otro sensor analógico) en paralelo con 5V. Conectando cada
uno de ellos a la entrada analógica correspondiente (0-2), y utilizamos una resistencia de 10KOhm
como referencia a tierra, en cada línea de entrada.

Arduino
Schematic

Arduino
Code
#include "pitches.h"
const int threshold = 10; // tiempo de lectura mínima de los sensores para generar una nota
int notes[] = {
NOTE_A4, NOTE_B4, NOTE_C3 }; // notas que se tocarán, correspondientes a los 3 sensores
void setup() {
}
void loop() {
for (int thisSensor = 0; thisSensor < 3; thisSensor++) {
int sensorReading = analogRead(thisSensor); // obtenemos la lectura del sensor
if (sensorReading > threshold) { // si el sensor se mantiene presionado lo suficiente
tone(8, notes[thisSensor], 20); // tocarmos la nota correspondiente a este sensor

}
}
}

Arduino
15. Tone4: reproducir tonos en múltiples altavoces de forma secuencial, con el comando de tono ().
Este ejemplo muestra cómo utilizar el comando tone() para reproducir diferentes notas en varias
salidas.
El comando de tone() trabaja haciéndose cargo de uno de los temporizadores internos del Atmega,
estableciendo la frecuencia que se desea, y utilizando un temporizador para generar un pulso en el pin
de salida. Ya que sólo se está utilizando un temporizador, sólo se puede reproducir una nota a la vez.
Se Puede, sin embargo, para tocar notas en varios pines (salidas) secuencialmente, desactivar el
temporizador para un pin antes de pasar al siguiente.
Hardware Required
 (3) 8-ohm speakers
 (3) 100 ohm resistor
 breadboard
 hook up wire
Circuit

Arduino
Schematic
Code
En el siguiente boceto se reproduce un tono en cada uno de los parlantes de forma secuencialmente,
apagando el parlante anterior previamente. La duración de cada tono es el mismo que el retardo que
le sigue.
void setup() {
}
void loop() {
noTone(8); // desactiva la función tone para el pin 8
tone(6, 440, 200); // reproduce la nota LA (440) en el pin 6 por 200 milisegundos:
delay(200);
noTone(6); // desactiva la función tone para el pin 6:
tone(7, 494, 500); // reproduce la nota 494 en el pin 7 por 500 milisegundos:
delay(500);
noTone(7); // desactiva la función tone para el pin 7:
tone(8, 523, 300); // reproduce la nota 523 en el pin 8 por 300 milisegundos
delay(300);

Apunte de Arduino Hecho Por Ronald Parte 2

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Apunte de Arduino Hecho Por Ronald Parte 2

Cargado por

Copyright:

Formatos disponibles

Arduino

Ing. Ronald N. Kopp Página 1

Ing. Ronald N. Kopp Página 2

Ing. Ronald N. Kopp Página 3

// constantes que no cambiarán.

// variables que cambiarán:

// las siguientes variables son grandes porque el tiempo, es medido en milisegundos y

if(currentMillis - previousMillis > interval) {

previousMillis = currentMillis; // guardaremos el tiempo de la última vez que parpadeó el LED

// si el LED está apagado, se encenderá y se apagará:

// escribimos en el LED el valor de la variable ledState:

Ing. Ronald N. Kopp Página 4

// quite el comentario de la línea de la suma para

Nombre unsigned long

Ing. Ronald N. Kopp Página 5

Ing. Ronald N. Kopp Página 6

Ing. Ronald N. Kopp Página 7

Ing. Ronald N. Kopp Página 8

// variables que cambiarán:

if (buttonState == HIGH) { // comprobamos si se presionó el pulsador.

digitalWrite(ledPin, HIGH); // entonces encendemos el LED

Ing. Ronald N. Kopp Página 9

Ing. Ronald N. Kopp Página 10

Ing. Ronald N. Kopp Página 11

// constantes que no cambiarán:

// variables que cambiarán:

long lastDebounceTime = 0; // la última vez que el pin de salida se conmutó

if (reading != lastButtonState) { // comprobamos si el estado del pulsador cambio

lastDebounceTime = millis(); // si es así, restablecemos el temporizador

if ((millis() - lastDebounceTime) > debounceDelay) { // comprobamos si permaneció la señal el

Ing. Ronald N. Kopp Página 12

if (reading != buttonState) { // y sí además el pulsador ha cambiado

if (buttonState == HIGH) { // solo conmutaremos el LED sí el nuevo estado

digitalWrite(ledPin, ledState); // escribimos en el LED el valor de ledState

Nombre != (no equivalente)

Nombre ! (lógica NOT)

Ing. Ronald N. Kopp Página 13

Ing. Ronald N. Kopp Página 14

Ing. Ronald N. Kopp Página 15

// constantes que no cambiarán

// Variables que cambiarán:

pinMode(buttonPin, INPUT); // configuramos el buttonPin como una entrada

Serial.begin(9600); // comenzamos la comunicación serial

lastButtonState = buttonState; // guardaremos el estado actual como el último estado

// encenderemos el LED cada cuatro veces que se pulsa el pulsador

Ing. Ronald N. Kopp Página 16

Descripción Incrementa el valor de una variable entera en 1. Es equivalente a la operación i = i +

Ing. Ronald N. Kopp Página 17

Este ejemplo demuestra el uso de INPUT_PULLUP en el pinMode (). Supervisando el estado de un

Ing. Ronald N. Kopp Página 18

Ing. Ronald N. Kopp Página 19

En la siguiente línea lo que se hace es configurar al pin 13 como una salida

Ahora que su configuración se ha completado, nos introducimos en el bucle principal de nuestro

Serial.begin(9600); //comenzamos la comunicación serial

pinMode(2, INPUT_PULLUP); // configura el pin2 como una entrada

Ing. Ronald N. Kopp Página 20

Serial.println(sensorVal); // imprimimos el valor del pulsador

// tengamos en cuenta que la forma pullup de pulsar, es lógica invertida

if (sensorVal == HIGH) { // si sensorVal es equivalente a un Alto

Ing. Ronald N. Kopp Página 21

Ing. Ronald N. Kopp Página 22

Ing. Ronald N. Kopp Página 23

Ing. Ronald N. Kopp Página 24