Arduino Project 7: Teclado instrumental

Para esta práctica necesitaremos:

• 1 Buzzer
• 4 botones
• 2 resistencias de 10 kΩ
• 1 resistencia de 220 Ω
• 1 resistencia de 1 MΩ

En esta práctica, construiremos y programaremos un instrumento similar a un piano, es decir, un circuito que generará diferentes frecuencias según que botones (teclas) pulsemos.

Al final de la práctica, se propone hacer una carcasa para que el cableado no quede visible y se asemeje más a un piano.

Las conexiones que realizaremos serán las que se muestran en la imagen:

El código que usaremos será el siguiente:

int buttons[6];

//crea una lista con 6 elementos

buttons[0] == 2;

//le da a primer elemento el valor 2

int notes[] = {262,294,330,349};

//relaciona cada valor de la lista anterior con uno de esta

void setup(){

  Serial.begin(9600);

}

void loop(){

  int keyVal = analogRead(A0); 

//lee un valor entre 0 y 1024 dependiendo de qué botón está pulsado

  Serial.println(keyVal);

  

  if(keyVal ==1023){

    tone(8, notes[0]);

  }

  else if(keyVal >= 990 && keyVal <=1010){

    tone(8, notes[1]);

  }

  else if(keyVal <= 505 && keyVal <= 515){

    tone(8, notes[2]);

  }

  else if(keyVal >= 5 && keyVal <=10){

    tone(8, notes[3]);

  }

  else{

    noTone(8);

  }

}

/*

con estas últimas líneas de código, haremos que suene una nota según qué botón pulsemos, es decir, según qué valor de la lista este activo

*/

Con este código, y las anteriores conexiones, la simulación en crcuits.io nos da el siguiente resultado:

Y su construcción y funcionamiento en formato físico es el siguiente:

Arduino Project 6: Theremín de luz

Para esta práctica necesitaremos los siguientes materiales, que son pocos en esta ocasión:

• 1 Fotorresistencia
• 1 Buzzer
• 1 Resistencia de 10 kΩ

En esta práctica, haremos un aparato similar a un theremín, que es un instrumento musical electrónico el cual es manipulado sin contacto físico, pues funciona por ondas de radio (adjuto foto). Para ello realizaremos las siguientes conexiones:

El código usado es el siguiente:

//variable del sensor de luz

int sensorValue;

// variable para calibrado inferior

int sensorLow = 1023;

// variable para calibrado superior

int sensorHigh = 0;

// pin del LED

const int ledPin = 13;

void setup() {

  // declara el pin del LED como salida y lo enciende

  pinMode(ledPin, OUTPUT);

  digitalWrite(ledPin, HIGH);

  //calibra durante los primeros 5 segundos de programa

  while (millis() < 4000) {

    // guarda el valor máximo del sensor

    sensorValue = analogRead(A0);

    if (sensorValue > sensorHigh) {

      sensorHigh = sensorValue;

    }

    //guarda el valor mínimo del sensor

    if (sensorValue < sensorLow) {

      sensorLow = sensorValue;

    }

  }

  // apaga el led para señalar que ha acabado el calibrado

  digitalWrite(ledPin, LOW);

}

void loop() {

  //lee la señal analógica del A0 y la guarda como valor

  sensorValue = analogRead(A0);

  //mapea los los valores del sensor en un rango de frecuencias

  int pitch = map(sensorValue, sensorLow, sensorHigh, 50, 4000);

  //ejecuta el tono durante 20 ms en el pin 8

  tone(8, pitch, 20);

  delay(10);

}

La simulación en circuits.io es la siguiente:

Y este el resultado en formato físico:

Arduino Project 5: Señal de Humor

Para esta práctica necesitaremos:

• 1 Potenciómetro
• 1 Servo con brazo
• 2 Condensadores electrolíticos de 100 micro Faradios

En esta práctica se pretende hacer un brazo que controlado por un potenciómetro señale en que estado de animo estás (esto se consigue simplemente añadiendo un círculo de papel con inscripciones de estados de ánimo en él).

Usaremos los condensadores para mantener estable las señales, lo que hará que el motor que se mueva de forma más suave y no a trompicones. El uso de condensadores es escalable.
CUIDADO: ¡si los conectas al revés pueden explotar ya que están polarizados!

El esquema de conexión es el siguiente:

Y usaremos el siguiente código para controlar el servo con un potenciómetro.

#include <Servo.h>   //incluimos las librerías de control del servo

int const potPin = A0; //pin analógico A

int potVal; //guarda el valor pot

int angle = 0; //guarda la posición del servo

void setup() {

  myServo.attach(9); //declara en que pin está conectado el servo

  Serial.begin(9600);

}

void loop() {

  potVal = analogRead(potPin);

  Serial.print("potVal: ");

  Serial.print(potVal);

  

  angle = map(potVal, 0, 1023, 0, 179);
/*
el valor angle es el valor pot reescalado de 0-179 grados
*/

  Serial.print("angle: ");

  Serial.println(angle);

  myServo.write(angle);

  delay(15);

}

Aquí está subida la simulación en circuits.io con el código de arriba:

Y por último, un vídeo de su funcionamiento en formato físico:

Arduino Project 4: Lámpara mezclando colores

Comenzando por la lista de materiales, para esta práctica necesitaremos:

• 1 LED RGB
• 3 resistencias de 220
• 3 resistencias de 10 k
• 3 fotorresistencias

Con el LED RGB, mezclaremos los 3 colores primarios, rojo, azul y verde, para obtener tantos colores como queramos. Esto se hará con diferentes voltajes en cada patilla del RGB para obtener mezclar los colores a nuestro gusto. Aquí una imagen del LED RGB y tanto sus conexiones individuales como las de la práctica montada:  

• R: rojo
• B: azul
• G: verde
• -: tierra

Las fotorresistencias ofrecerán diferentes valores de resistencia según la cantidad de luz que les llegue.

El código usado será el siguiente, comentado por mí:

const int greenLEDPin = 9 ;  //crea la variable para el pin de salida del led verde

const int redLEDPin = 11;    //crea la variable para el pin de salida del led rojo

const int blueLEDPin = 10;  //crea la variable para el pin de salida del led azul

const int redSensorPin = A0;     //crea la variable para la entrada del led rojo

const int greenSensorPin = A1;  //crea la variable para la entrada del led verde

const int blueSensorPin = A2;   //crea la variable para la entrada del led azul

int redValue = 0;     //crea la variable para el valor del voltaje del led rojo

int greenValue = 0; //crea la variable para el valor del voltaje del led verde

int blueValue = 0;  //crea la variable para el valor del voltaje del led azul

int redSensorValue = 0;      //crea la variable para el valor del sensor para el led rojo

int greenSensorValue = 0;  //crea la variable para el valor del sensor para el led verde

int blueSensorValue = 0;   //crea la variable para el valor del sensor para el led azul

void setup(){ //aquí, como siempre, el setup declarado que pines son salidas

  Serial.begin(9600);

  

  pinMode(greenLEDPin, OUTPUT);

  pinMode(redLEDPin, OUTPUT);

  pinMode(blueLEDPin, OUTPUT);

}

void loop(){
/*
con este código, se revisa repetidamente el estado del voltaje que entra por las entradas analógicas en cada pin con el analogRead, después escribe los voltajes según convenga a fin de que salga por las salidas correspondientes a los pines del RGB
*/

  redSensorValue = analogRead(redSensorPin);

  delay(5);

  greenSensorValue = analogRead(greenSensorPin);

  delay(5);

  blueSensorValue = analogRead(blueSensorPin);

  

  Serial.print("Raw SensorValues \t Red: ");

  Serial.print(redSensorValue);

  Serial.print("\t Green: ");

  Serial.print(greenSensorValue);

  Serial.print("\t Blue: ");

  Serial.print(blueSensorValue);

  redValue = redSensorValue/4;

  blueValue = blueSensorValue/4;

  greenValue = greenSensorValue/4;

  

  Serial.print("Mapped SensorValues \t Red: ");

  Serial.print(redValue);

  Serial.print("\t Blue: ");

  Serial.print(blueValue);

  Serial.print("\t Green: ");

  Serial.print(greenValue);

  

  analogWrite(redLEDPin, redValue); //aquí cambia el color del led

  analogWrite(greenLEDPin, greenValue);

  analogWrite(blueLEDPin, blueValue);

}

La simulación en circuits.io es la siguiente:

Y la construcción en formato físico con su funcionamiento es esta:

Arduino Project 3: Love-o-Meter

En esta práctica, construiremos un termómetro rudimentario, para lo que necesitaremos los siguientes materiales:

• 3 led, usaré el color rojo
• 1 sensor de temperatura TMP-36
• resistencias de 220 Ω para cada led

El sensor TMP-36 podemos encontrarlo por 2 € en casi cualquier tienda de electrónica, y nos aporta la ventaja de que el voltaje de salida es directamente proporcional a la temperatura que mide.

El esquema de conexión es el que aparece en la imágen.

Las conexiones son las siguientes:

                                       

De nuevo, esta práctica está enfocada a aprender algo de programación, con la diferencia de que usaremos sensores y, por ende, a tratar señales analógicas.

Usaremos el siguiente código, otra vez comentado por mí para aclarar que hace cada una de sus partes:

const int sensorPin = A0; //establece cual será el pin análogico de entrada de datos (para el sensor)

const float baselineTemp = 20.0; //determina la temperatura base entorno a la cual programaremos

void setup(){

  Serial.begin(9600); //inicia el monitor serial, que podemos abrir arriba a la derecha en la consola de                                    //programación

  for (int pinNumber = 2; pinNumber < 5; pinNumber++){

       pinMode(pinNumber, OUTPUT);

       digitalWrite(pinNumber, LOW);

       }

       }

       

       void loop(){

         int sensorVal = analogRead(sensorPin); //

         Serial.print("Sensor Value:: ");

         Serial.print (sensorVal);

         

         //convierte la señal ADC leída en voltaje

         float voltage = (sensorVal/1024.0)*5.0;

         Serial.print(", Volts: ");

         Serial.print(voltage);

         Serial.print(", degress C: ");

                      //convierte el voltaje en temperatura, en grados centígrados

                      float temperature = (voltage - .5)*100;

                      Serial.println(temperature); //con el siguiente if, haremos que se enciendan los leds                                                                            // que queremos según la temperatura

                      if(temperature < baselineTemp){

                        digitalWrite(2, LOW);

                        digitalWrite(3, LOW);

                        digitalWrite(4, LOW);

                      }

         else if(temperature >= baselineTemp+2 && temperature < baselineTemp+4){

                        digitalWrite(2, HIGH);

                        digitalWrite(3, LOW);

                        digitalWrite(4, LOW);

                      }

                      else if(temperature >= baselineTemp+4 && temperature < baselineTemp+6){

                        digitalWrite(2, HIGH);

                        digitalWrite(3, HIGH);

                        digitalWrite(4, LOW);

                      }

                      else if(temperature >= baselineTemp+6){

                        digitalWrite(2, HIGH);

                        digitalWrite(3, HIGH);

                        digitalWrite(4, HIGH);

                      }

                      delay(1);

                      }

Este código, dará el siguiente resultado en la simulación:

Y su construcción en formato físico nos dará este otro resultado:

Arduino Project 2: Interfaz de nave espacial

Para esta práctica, necesitaremos:

• Resistencias de 220 y 10 kΩ
• 1 botón
• 2 leds rojos y 1 led verde
• Placa arduino y breadboard

Nada más comenzar, nos dan el siguiente esquema de conexión (la resistencia de 10 kΩ esta con el botón para evitar ruido y así obtener una señal clara de este; el resto son las de 220 Ω).

Toda la práctica gira en torno al análisis del código que nos dan, el cual he comentado en cada línea, que es el siguiente:

//se crea la variable que usaremos para saber si el botón esta activo

int switchState = 0;

//setup

// la rutina del setup empieza al resetear y se lee solo una vez

void setup() {

  // inicia los pines digitales como salidas (OUTPUT) o entradas (INPUT)

  pinMode(3, OUTPUT);

  pinMode(4, OUTPUT);

  pinMode(5, OUTPUT);

  pinMode(2, INPUT);

}

// la rutina loop se lee continuamente

void loop() {

  switchState = digitalRead(2);   //HIGH o LOW según el botón este encendido o apagado

  if (switchState == LOW) { //la función if funciona si se cumple su condición (en este caso que la                                                     //entrada del botón este activa, es decir, el botón pulsado)

    //con el boton no accionado

    digitalWrite(3, HIGH);  //enciende el led verde

    digitalWrite(4, LOW);   //apaga el led rojo

    digitalWrite(5, LOW);   //apaga el led rojo

  }

  else { //la función else funciona si no se cumple la condición de un if

    //con el botón accionado

    digitalWrite(3, LOW); //apaga el led verde

    digitalWrite(4, LOW); //apaga el led rojo uno

    digitalWrite(5, HIGH); //enciende el led rojo dos

    delay (250);  //espera un cuarto de segundo (250 milisegundos)

    //cambia el led rojo encendido

    digitalWrite(4, HIGH); //enciende el led rojo uno

    digitalWrite(5, LOW); //apaga el led rojo dos

    delay (250); //espera un cuarto de segundo

  }

    

} //vuelve a empezar la función loop

Adjunto una simulación antes de pasar a compartir la práctica en formato físico:

Y he aquí el resultado en formato físico:

Se recomienda el uso de una pequeña carcasa para tapar el cableado, pero no es necesario tenerla, funcionará igual.

Esta práctica es corta y sencilla, ideal para introducirnos a cómo programar Arduino.

Arduino Project 0: Introducción

Antes de nada, debo comentar que las practicas están en inglés, pero gracias a mi manejo de la lengua, propio de todo experto en Arduino, haré la mejor traducción que pueda.

Bien, en este primer proyecto, se nos introduce al mundo de Arduino, y se nos presentan y explican los elementos que todo proyecto tiene:

Sensores: captan una variable del mundo físico, adaptándola y transformándola en una diferencia de potencial determinada, que podrá ser usada en el circuito.

Actuadores: tienen una respuesta física en función de la señal eléctrica que les llegue.

Microcontroladores: son los que captan la señal de los sensores, la analizan y envían una respuesta a los actuadores en función de lo que esté programado.


Esta primera práctica nos enseña además a ensamblar nuestro kit de Arduino y una introducción general al uso de cada una de las partes de la placa: pines, leds indicadores...

Posteriormente se dan indicaciones de como usar el simulador que proporciona circuits.io y como obtener el programa Arduino IDE, con el que podras desarrollar tu propio código y subirlo a tu Arduino.

Luego, pone un ejemplo de circuito, que hará parpadear un led, con una conexión sencilla y algo de código:

int led = 13; //crea la variable que designará el pin digital 13

// la rutina setup se ejecuta una vez

void setup() {

  //inicia el pin como salida

  pinMode(led, OUTPUT);

}

// la rutina loop se ejecuta repetidamente

void loop() {

  digitalWrite(led, HIGH);   //enciende el LED (HIGH es el nivel de voltaje, 5 V)

  delay(1000);               //espera 1000 milisegundos (1 segundo)

  digitalWrite(led, LOW);    //apaga el LED cambiando el voltaje a 0 V

  delay(1000);               //espera otro segundo

}

Primero, se efectúa la siguiente simulación en la página de Circuits.io, con ese código. Se ve aquí también el diagrama de conexión:




A continuación, un vídeo de su funcionamiento en formato físico (usará el mismo código ya que usa los mismos componentes) y una foto de montaje:

Al iniciar el programa el led comienza a parpadear, encendiéndose y apagándose en intervalos de 1 s.

Para acabar, introduce los conceptos de intensidad, voltaje y resistencia, así como los diagramas y representaciones de varios componentes comunes.

Dentro de poco estará la siguiente práctica.