Arduino Project 15: Hackeando botones

Necesitaremos:

• 1 resistencia de 220 Ω
• 1 octoacoplador
• 1 circuito para hackear (una bombilla es lo más sencillo en este caso)

Utilizaremos un octoacoplador para poder controlar otros circuitos con nuestra placa de Arduino (o similares asiáticos).

Haremos las siguientes conexiones (el circulito azul representa el circuito que queremos hackear).

Podemos añadir un botón:

El código, muy sencillo en este caso es el siguiente:

const int optoPin = 2;

void setup() {

  pinMode(optoPin, OUTPUT);

}

void loop() {

  digitalWrite(optoPin, HIGH);   

  delay(5000);               

  digitalWrite(optoPin, LOW);   

  delay(1000);               

}

La simulación en circuits.io:

Esta vez se nos ha indicado que no es necesario contruirlo en formato físico para optar a la mejor nota, pues puede resultar complicado e incluso peligroso al trabajar con otros circuitos.

Hasta aquí las prácticas.

Arduino Project 14: Retocar el logo de Arduino

Para esta práctica necesitaremos:

• 1 potenciómetro
• Ordenador

Esta práctica es algo diferente al resto, ya que se centra más en la programación, en concreto, en establecer una conexión entre el ordenador y nuestra placa Arduino (o similar más barato) a traves de un puerto serial, para controlar, en este caso, el color del logo de Arduino.
Podemos utilizar la conexión serial para enviar datos de ida y vuelta al IDE de Arduino.

Podríamos usarla para otras aplicaciones.

Usaremos este código en el Arduino:

void setup(){

  Serial.begin(9600);

}

void loop(){

  Serial.write(analogRead(A0/4));

  delay(1);

}

Y este otro en la interfaz del ordenador. Lo cargaremos en un entorno llamado Processing, que enconraremos en processing.org :

import processing.serial.*;

Serial myPort;

PImage logo;

int bgcolor = 0;

void setup(){

  colorMode(HSB, 255);

  

  logo = loadImage("http://arduino.cc/logo.png");

  size(logo.width, logo.height);

  

  println("Available sreial ports:");

  println(Serial.list());

  

  myPort = new Serial(this, Serial.list()[0], 9600);

}

void draw(){

  if (myPort.available() > 0){

    bgcolor = myPort.read();

    print.ln(bgcolor);

  }

  

  background(bgcolor, 255, 255);

  image(logo, 0, 0);

}

La simulación en circuits.io muestra las conexiones y si abrimos el monitor serial, cambiaran los caracteres con el potenciómetro, pero no se puede ver al logo cambiar de color hasta que no lo conectemos al ordenador y abramos el programa de Processing, con el código correspondiente, y lo ejecutemos también.



En este caso, no he realizado la construcción en físico ni lo he grabado ya que se nos indicó que podía dar problemas.

Arduino Project 13: Lampara táctil

Material necesario:

• 1 resistencia de 220 Ω
• 1 resistencia de 1 MΩ
• 1 LED
• Algo de papel de aluminio

El objetivo de esta práctica, es hacer un sistema que encienda la bombilla al tocar la "antena" de papel de aluminio.

Realizaremos las siguientes conexiones, colocando además algo de papel de aluminio en el extremo del cable que sobresale.

Como siempre, aquí va el código:

#include <CapacitiveSensor.h>

CapacitiveSensor capSense = CapacitiveSensor(4,2);

int threshold = 1000;

const int ledPin = 12;

void setup(){

  Serial.begin(9600);

  pinMode(ledPin, OUTPUT)

}

void loop(){

  long sensorValue = capSensor.capacitiveSensor(30);

  Serial.println(sensorValue);

  

  if(sensorValue > threshold){

    digitalWrite(ledPin, HIGH);

  }

  else{

    digitalWrite(ledPin, LOW);

  }

  delay(10);

}

El código se analiza fácilmente. Se usaran las librerias de CapacitiveSensor para hacer del papel de plata un panel sensible.

Este el el resultado de simular en circuits.io, sin la construcción completa, ya que faltan materiales:

La simulación no funciona ya que no existe nada parecido al papel de alumnio en la lista de componentes del constructor de circuitos de circuits.io ni se puede añadir la libreria correspondiente, sin embargo, se aprecian el montaje y el código.

Y por último, una foto del circuito en formato físico:

Arduino Project 12: Sistema de seguridad

Necesitaremos los siguientes materiales:

• 1 botón
• 1 buzzer
• 3 LEDS (rojo, verde y amarillo)
• 3 resistencias de 220 Ω
• 1 resistencia de 10 kΩ
• 1 resistencia de 1 MΩ
• 1 servo
• 1 condensador de 100 uF

La practica consistirá en hacer una cerradura que controlaremos con nuestra placa Arduino (o similar).
El esquema con las conexiones viene a continuación, en la imagen:

Cargaremos el siguiente código en nuestra placa:

#include <Servo.h>

Servo myServo;

const int piezo = A0;
const int switchPin = 2;
const int yellowLed = 3;
const int greenLed = 4;
const int redLed = 5;

int knockVal;
int switchVal;

const int quietKnock = 10;
const int loudKnock = 1053;

boolean locked = false;
int numberOfKnocks = 0;

void setup(){
  myServo.attach(9);
  pinMode(yellowLed, OUTPUT);
  pinMode(redLed, OUTPUT);
  pinMode(greenLed, OUTPUT);
  pinMode(switchPin, INPUT);
  Serial.begin(9600);

  digitalWrite(greenLed, HIGH);
  myServo.write(0);
  Serial.println("The box is unlocked!");
} //end of setup()

void loop(){
  if(locked == false){
  switchVal = digitalRead(switchPin);
    if(switchVal == HIGH){
      locked = true;
      digitalWrite(greenLed, LOW);
      digitalWrite(redLed, HIGH);
      myServo.write(90);
      Serial.println("The box is locked!");
      delay(1000);
    } //end of nested if()
  } //end of outer if()

  if(locked == true){
    knockVal = analogRead(piezo);
    if(numberOfKnocks < 3 && knockVal > 0){
      if(checkForKnock(knockVal) == true){
        numberOfKnocks ++;
      }
      //subtract knocks made so far from three
      Serial.print(3-numberOfKnocks);
      Serial.print(" more knocks to go");
    }
 
    if(numberOfKnocks >=3){
      locked = false;
      myServo.write(0);
      delay(20);
      digitalWrite(greenLed, HIGH);
      digitalWrite(redLed, LOW);
      Serial.println("The box is unlocked!");
      numberOfKnocks = 0;
    } //end of if(numberOfKnocks..)
  } //end of if(locked==true)
} //end of loop

boolean checkForKnock(int value){
  if(value > quietKnock && value < loudKnock){
    digitalWrite(yellowLed, HIGH);
    delay(75);
    digitalWrite(yellowLed, LOW);
    Serial.print("Valid knock of value ");
    Serial.println(value);
    return true;
  }

  else{
    Serial.print("Bad knock value ");
    Serial.println(value);
    return false;
  }
}

Este código no está comentado ya que tras haber hecho el resto de prácticas, está bastante claro que hace cada parte, ya que no hay nada especial

El código hará que se se habrá y cierre la cerradura (movimiento del servo) al hacer vibrar el buzzer 3 veces, y que se quede cerrada de nuevo al pulsar el botón, además de que quede indicado su estado mediante las bombillas.

Nos dará el siguiente resultado al simular en circuits.io, sin cambios en el código aunque haya que cambiar el buzzer por un botón, ya que el buzzer no puede ser usado como entrada en la simulación.

Nos dará el siguiente resultado al simular en circuits.io:

Y el funcionamiento, ya construido en formato físico, es el siguiente:

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: