Arduino Project 11: Bola de cristal

Necesitaremos los siguientes materiales:

• 1 sensor de movimiento
• 1 potenciómetro
• 1 resistencia de 220Ω
• 1 resistencia de 10 kΩ
• 1 panel LCD

Todo esto lo conectaremos en nuestro bredboard junto a nuestro Arduino (o similar) y cables de la siguiente manera:

Cargaremos el siguiente código en nuestra placa:

// incluimos las librerias
#include <LiquidCrystal.h>

// iniciamos las librerias con los números de los pines de la interfaz
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

/*
aquí declaramos los pines que serán para cada uno de nuestros elementos
*/
const int switchPin = 6;

int switchState = 0;

int prevSwitchState = 0;

int reply;

void setup() {

  // inicia el numero de filas y columnas del LCD
  lcd.begin(16, 2);

  pinMode(switchPin,INPUT);

  // imprime unn mensaje en el LCD
  lcd.print("Ask the");

  // pone el cursor en la linea 1 columna 0
  lcd.setCursor(0, 1);

  //imprime en la segunda línea
  lcd.print("Crystal Ball!");

}

void loop() {
  //revisa el estado del switch
  switchState = digitalRead(switchPin);

  //compara el estado del switch con el anterior
  if (switchState != prevSwitchState) {

    /*
si el estado cambia de HIGH a LOW es porque la bola se ha movido
*/
    if (switchState == LOW) {
      // elige de forma aleatoria una respuesta
      reply = random(8);
      // limpia la pantalla tras dar una respuesta
      lcd.clear();
   
      lcd.setCursor(0, 0);
     //imprime el siguiente texto
      lcd.print("the ball says:");
      //pone el cursor en la segunda linea
      lcd.setCursor(0, 1);

      //elige la respuesta
      switch(reply){
      case 0:
        lcd.print("Yes");
        break;

      case 1:
        lcd.print("Most likely");
        break;

      case 2:
        lcd.print("Certainly");
        break;

      case 3:
        lcd.print("Outlook good");
        break;

      case 4:
        lcd.print("Unsure");
        break;

      case 5:
        lcd.print("Ask again");
        break;

      case 6:
        lcd.print("Doubtful");
        break;

      case 7:
        lcd.print("No");
        break;
      }
    }
  }
  //guarda el ultimo estado del switch
  prevSwitchState = switchState;
}

Tras simular en circuits.io, obtenemos el siguiente resultado:





El funcionamiento en físico junto a su construcción se muestran, como siempre, en el siguiente video:

Arduino Project 10: Zoótropo

Necesitaremos los siguientes materiales:

• 2 resistencias de 10 k‎Ω
• 1 potenciómetro
• 2 botones
• 1 batería de 9 V
• 1 motor
• 1 chip H-bridge (puente en H)

El objetivo es crear una imágen en movimiento mediante el rápido movimiento de imágenes en torno a un eje.

Usaremos un puente en H para poder mover el motor en ambos sentidos, su funcionamiento elemental se detalla en la imagen.

Se usará el siguiente código:

//el puente en H controla el encendido y apagado

const int controlPin1 = 2;

const int controlPin2 = 3;

const int enablePin = 9;

//botones

const int directionSwitchStatePin = 4;

const int onOffSwitchStatePin = 5;

//potenciómetro

const int potPin = A0;

int onOffSwitchState = 0;

int previousOnOffSwitchState = 0;

int directionSwitchState = 0;

int previousDirectionSwitchState = 0;

int motorEnabled = 0;

int motorSpeed = 0;

int motorDirection = 1;

void setup(){

//declarar entradas y salidas

  pinMode(directionSwitchStatePin, INPUT);

  pinMode(onOffSwitchStatePin, INPUT);

  pinMode(controlPin1, OUTPUT);

  pinMode(controlPin2, OUTPUT);

  pinMode(enablePin, OUTPUT);

  //apaga el motor inicialmente
  digitalWrite(enablePin, LOW);

}

void loop(){

  onOffSwitchState = digitalRead(onOffSwitchStatePin);

  delay(1);

  directionSwitchState = digitalRead(directionSwitchStatePin);

  motorSpeed = analogRead(potPin)/4;

  

  if(onOffSwitchState != previousOnOffSwitchState){

    if(onOffSwitchState == HIGH){

      motorEnabled = !motorEnabled;
//las exclamaciones invierten el estado de la variable

    }//end of nested(if)

  }//end of outer (if)

  

  if(directionSwitchState != previousDirectionSwitchState){

    if(directionSwitchState ==HIGH){

      motorDirection = !motorDirection; //cambia la dirección del motor

    } //end of nested if()

  } //end of outer (if)

  

  if(motorDirection == 1){

//con esto se hace la configuración del puente en H

    digitalWrite(controlPin1, HIGH);

    digitalWrite(controlPin2, LOW);

  }

  else{

    digitalWrite(controlPin1, LOW);

    digitalWrite(controlPin2, HIGH);

  }

  

  if (motorEnabled == 1){

    //determina la velocidad

    analogWrite(enablePin, motorSpeed);

  }

  else{

    analogWrite(enablePin, 0);

  }

  

  previousDirectionSwitchState = directionSwitchState;

  previousOnOffSwitchState = onOffSwitchState;

} 

  

La simulación con circuits.io da el siguiente resultado:

Y como siempre, su construcción y funcionamiento se ven así:

Arduino Project 9: Molinillo motorizado

Para esta práctica harán falta los siguientes elementos:

• 1 transistor N-MOSFET
• 1 diodo
• 1 batería de 9 V
• 1 botón
• 1 resistencia de 10 kΩ

Esta practica consiste en controlar con nuestro Arduino un motor que funciona a 9 V, es decir, con un circuito electrónico de 5 V, controlar uno eléctrico de mayos voltaje. Para ello emplearemos un transistor, que deja pasar la corriente (este tipo así lo hace) cuando recibe una señal por la entrada G (gate). La corriente fluirá desde S (source) hasta D (drain). 

El transistor tiene el siguiente esquema, adjunto con una foto con conexiones y diagrama eléctrico.

Usaremos el siguiente código, esta vez comentado de forma más escueta ya que avanzamos en dificultad, por lo que las partes fáciles no recibirán tanta atención a partir de ahora.

//nombrar primeros las constantes que definirán los pines

const int switchPin = 2;

const int motorPin = 9;

//y la constante que tendrá el valor del botón

int switchState = 0;

void setup() {

  // iniciar los pines según convenga

  pinMode(motorPin, OUTPUT);

  pinMode(switchPin, INPUT);

}

void loop() {

//da a la constante seitchState el valor leido por el pin switchPin

  switchState = digitalRead(switchPin);

  

/*

si la variable switchState está en estado HIGH (activado), manda una señal en HIGH por el pin motorPin

*/

  if (switchState == HIGH) {

    digitalWrite(motorPin, HIGH);

  }

//si no, lo mantiene apagado

  else {

    digitalWrite(motorPin, LOW);

  }

}

El código nos da el siguiente resultado al simular:

Y su posterior construcción en físico y su funcionamiento se ven a continuación:

Arduino Project 8: Reloj de arena digital

Para esta práctica necesitaremos:

• 6 LEDS
• 6 resistencias de 220Ω
• 1 resistencia de 10 kΩ
• 1 sensor de movimiento

El objetivo es hacer un circuito que funcione de forma similar a un reloj de arena, que cambie de forma comprensible y regular en el tiempo y que, al agitarlo, se reinicie (esto se conseguirá con el sensor de movimiento).

Las conexiones a realizar son las siguientes:

Para hacer que funcione, tendremos que cargar en nuestra placa Arduino (o similar, aquí somos partidarios de marcas blancas ;) ) el siguiente código:

//nombra la constante para el pin del sensor
const int switchPin = 8;

unsigned long previousTime = 0; 

//guarda el último momento en que un led fue encendido

int switchState = 0;

//variable para el estado actual del sensor

int prevSwitchState = 0;

//guarda el anterior estado del sensor

int led = 2;

//variable referida a los leds

//3000 = 3000 milisegundos
long interval = 3000;

//este será el intervalo entre un led que se enciende y el siguiente

void setup() {

 for(int x = 2;x<8;x++){
   pinMode(x, OUTPUT);

//declara lo que serán las salidas de los leds, con un contador

 }

 //declara el pin del sensor como entrada
 pinMode(switchPin, INPUT);

}

void loop(){ 

 //guarda el tiempo desde el cual la placa comenzó el programa
 unsigned long currentTime = millis(); 

 /*

compara el tiempo con el que hubo la última vez que un led se encendió

y si es mayor que el intervalo definido, enciende el siguiente

*/

 if(currentTime - previousTime > interval) {

   //guarda la última vez que cambiaste un led
   previousTime = currentTime; 

   //enciende el led
   digitalWrite(led, HIGH);
   led++; 
   
   if(led == 7){

   }
 }

 //lee el valor del sensor
 switchState = digitalRead(switchPin); 

 //si el sensor cambia, apaga todos los sensores
 if(switchState != prevSwitchState){

   for(int x = 2;x<8;x++){    
     digitalWrite(x, LOW);

   }  
   
   //resetea la variable de los leds a la original
   led = 2;
   
   //resetea el contador de tiempos
   previousTime = currentTime;
 }
 //guarda el último estado en que estuvo el led
 prevSwitchState = switchState;

}

Este es el resultado de simular en circuits.io:

Y su posterior construcción en físico da el siguiente resultado:

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: