lunes, 27 de diciembre de 2010

Pequeña alarma anti-robo

Hi again :)

Hoy volveremos a hacer un proyecto sencillo, pero resultón ;) Una sencilla alarma anti-robo, haciendo uso de un tilt sensor, es decir, un sensor de inclinación/vibración/movimiento... Este sensor, se comporta a efectos prácticos como un botón normal y corriente (ON/OFF).

Lo montaremos con ayuda de nuestra protoboard, de forma que cuando alguien mueva la protoboard, un LED se iluminará y un zumbador hará ruido. Para este proyecto necesitaremos:

- 1 tilt sensor.
- 1 resistencia de 10k Ohms.
- 1 zumbador piezo.
- 1 LED.


El circuito, que es bastante simple, se puede ver en la siguiente imagen:
















Como vemos, hemos conectado el tilt sensor al pin 2, y el buzzer al 7.


El código que hemos usado es el siguiente:


int ledPin = 13; // PIN del LED
int inPin = 2; // PIN del pulsador
int value = 0; // Valor del pulsador

void setup() {

pinMode(ledPin, OUTPUT); // Inicializa el pin 13 como salida digital
pinMode(inPin, INPUT); // Inicializa el pin 2 como entrada digital
Serial.begin(9600); // use the serial port

}

void loop() {

value = digitalRead(inPin); // Lee el valor de la entrada digital

if (digitalRead(inPin) == 1) {
value = 0;
noTone(7);
}
else {
value = 1;
tone(7, 150, 500);
}
digitalWrite(ledPin, value);
Serial.println(value);

}


El pequeño “arreglo” que hemos hecho en el loop, poniendo value a 0 cuando por el pin 2 se lee 1, y poniéndolo a 1 cuando se lee 0, es porque así el LED estará apagado en estado de reposo.


El resultado, una vez conectado todo y habiendo subido el programa al Arduino, se puede ver en el siguiente vídeo (por cierto, comentar que mi tilt sensor está un poco suelto, ya que las patillas son demasiado cortas, y no me apetecía ponerle alargadores, por eso lo aprieto contra la protoboard cuando levanto todo ;)):




Y esto ha sido todo. Espero que os haya gustado.

Un saludo :)

domingo, 26 de diciembre de 2010

Controlando la intensidad de un LED

Hola de nuevo :)

Siguiendo con nuestros proyectos para principiantes, a continuación veremos dos que nos permitirán controlar la intensidad de un LED (y ver los datos resultantes también en el Serial Monitor). Empecemos...


Control de intensidad de un LED con un potenciómetro

En este sencillo proyecto controlaremos la intensidad de un diodo LED mediante un potenciómetro que usaremos como manivela. Necesitaremos:

- 1 LED.

- 1 potenciómetro.

Conectaremos una de las patillas del potenciómetro que van juntas (hay dos en un lado y una sola en el otro) a tierra (negativo), y la otra a 5V (positivo). La patilla que va sola en su lado, la conectaremos al pin analógico (A0) de Arduino.

Por otra parte, conectaremos el negativo del LED a tierra, y el positivo al pin digital 9 de Arduino.

El resultado, con la ayuda de nuestra protoboard, es el siguiente:











El código que hará que podamos controlar la intensidad con el potenciómetro se expone a continuación:


int knobValue, fadeValue;

void setup() {

// initialize the serial port

Serial.begin(9600);

}

void loop() {

// read the value from the input

knobValue = analogRead(knobPin);

// remap the values from 10 bit input to 8 bit output

fadeValue = map(knobValue, 0, 1023, 0 , 254);

// use the input value to fade the led

analogWrite(ledPin, fadeValue);

// print the input value to the serial port for debugging

Serial.println(fadeValue);

}


Como veis es muy simple. El resultado se puede ver en este vídeo:



Control de intensidad de un LED con un botón

Ahora vamos a controlar la intensidad del LED mediante un botón. Cuando se pulsa el botón, la intensidad del LED va aumentando, y cuando se suelta, va disminuyendo.

Necesitaremos:

- 1 LED.

- 1 botón.

- 1 resistencia de 10k Ohms.

Conectaremos los componentes del siguiente modo:











Como se puede ver, usamos el pin digital 8 con el botón, y el 9 con el LED.

El código que hemos empleado es el siguiente:


const int fadeTimerFreq = 30;

// fadeTime is the total time it will take to complete the ease (in milliseconds)

const int fadeTime = 3000;

// <<

// additional variable for the timer

int currentTime, fadeTimerLast;

// these constant variables store the pin numbers

const int ledPin = 9;

const int buttonPin = 8;

const int fadeRange = 254;

// the amount to step the fade; must be between 1 and the fadeRange

const float fadeStep = (float(fadeTimerFreq) / (fadeTime)) * fadeRange;

int buttonValue, fadeTarget, fadeValueTweened;

float fadeValue;

void setup() {

// initialize the serial port; needed for debugging below

Serial.begin(9600);

// initialize the LED pin

pinMode(ledPin, OUTPUT);

// initialize the input pin

pinMode(buttonPin, INPUT);

}

void loop() {

// for all timers

currentTime = millis();

// checks to see if the number of milliseconds has passed

if ( abs(currentTime - fadeTimerLast) >= fadeTimerFreq) {

fadeTimerLast = currentTime;

// read the value from the input

buttonValue = digitalRead(buttonPin);

// step the fading

if(buttonValue == 1){

// if the button is pressed, increase the fade

fadeValue = fadeValue + fadeStep;

}

else{

// if the button is not pressed, decrease the fade

fadeValue = fadeValue - fadeStep;

}

// constrain the fadeValue so it can't go off toward infinity

fadeValue = constrain(fadeValue, 0, fadeRange);

// get the tweened value -- i.e. the smooth value

fadeValueTweened = Quad_easeInOut(fadeValue, 0, fadeRange);

// use the tweened value to set the brightness of the LED

analogWrite(ledPin, fadeValueTweened);

// print the values to the serial port for debugging

Serial.print(buttonValue);

Serial.print(", ");

Serial.println(fadeValue);

}

}

// Quad easing thanks to Robert Penner

// variables used are type "float" so that you can throw smaller numbers at it and it will //still work well

float Quad_easeInOut(float t, float fixedScaleStart, float fixedScaleEnd){

// float b = 0, c = 1, d = 1;

float b = fixedScaleStart;

float c = fixedScaleEnd - fixedScaleStart;

float d = fixedScaleEnd;

if ((t/=d/2) <>

return -c/2 * ((--t)*(t-2) - 1) + b;

}


El resultado se puede ver aquí:


Y... eso es todo :)

Un saludo.

sábado, 25 de diciembre de 2010

Sensor de temperatura

Siguiendo con los proyectos sencillos, vamos a ver cómo podemos hacer con Arduino un sensor de temperatura simple, que puede servirnos para algo tan útil como una alarma anti-incendios =) Lo que hará esta alarma será iluminar un LED y hacer que suene un pitido cuando la temperatura sea superior a la que nosotros consideremos como “peligrosa”. Si la temperatura vuelve a un nivel aceptable, la alarma para. Además, se irá mostrando por el Serial Monitor (Tools->Serial Monitor) la temperatura actual que se va detectando.

Para realizar este proyecto hemos utilizado lo siguiente:

- 1 buzzer piezo.

- 1 termistor de 4.7k.

- 1 resistencia de 220 Ohms.

- 1 resistencia de 10k Ohms.

Lo primero que haremos será conectar un LED en el pin 13 de Arduino (tal y como vimos en el proyecto Blink del post anterior).

Seguidamente, conectaremos el buzzer a tierra y al pin digital 7 (puede ser otro, sin problema ;)), y usaremos la resistencia de 220 Ohms..

Por último haremos uso del termistor y la resistencia que nos queda, conectándolos del siguiente modo:

(Tierra) --- (R 10k) ------|------ (Termistor) --- (+5v)
|
                  Entrada Analógica 0 (A0)

El circuito, una vez montado (ayudándonos de una protoboard), quedaría así:










El código del programa es el siguiente:

#include

double Thermister(int RawADC) {

double Temp;

Temp = log(((10240000/RawADC) - 10000));

Temp = 1 / (0.001129148 + (0.000234125 * Temp) + (0.0000000876741 * Temp * Temp * Temp));

Temp = Temp - 273.15; // Conversión de Kelvin a Celsius

//Temp = (Temp * 9.0)/ 5.0 + 32.0; // Conversión de Celsius a Fahrenheit

return Temp;

}

void setup() {

pinMode(13, OUTPUT);

Serial.begin(9600); // use the serial port

}

void loop() {

int tempCelsius = int(Thermister(analogRead(0))-15);

Serial.println(tempCelsius); // display Celsius

if (tempCelsius > 31) {

digitalWrite(13, HIGH);

tone(7, 150, 500);

delay(1000);

noTone(7);

}

else {

digitalWrite(13, LOW);

digitalWrite(7, HIGH);

delay(1000);

}

}

Como se puede observar, la temperatura la mostramos en Celsius, aunque también se da la posibilidad (está comentada) de mostrarla en Fahrenheit.

Una explicación sobre la instrucción: int tempCelsius = int(Thermister(analogRead(0))-15). El –15 es una aproximación que hemos hecho “a mano”, ya que si no, no mostraba la temperatura real. Desconozco el motivo. Podéis jugar con ese número a vuestro gusto para adecuarlo a vuestro circuito.

Como última nota, decir que hemos puesto que la alarma salte cuando la temperatura es superior a 31 grados, para que saltase rápido y el vídeo, que viene a continuación con el resultado, no fuese demasiado largo. Hemos usado una lámpara para que la temperatura del termistor suba. También podéis probar con los dedos, ya que así se calienta rápido también. Para los más osados, siempre podéis poner la temperatura límite más alta, y pegarle fuego a vuestra casa... y veréis que funciona :P

He aquí el vídeo resultado:

Eso es todo, espero que os haya gustado y os resulte útil.

Un saludo :)

Para principiantes...

Hola a todos, éste es mi primer post en el blog, y estará dedicado a hacer cuatro proyectos MUY sencillos (basados en los propios ejemplos de la web oficial de Arduino) para principiantes en el mundo de Arduino (entre los que me incluyo, con lo que correcciones y sugerencias serán bienvenidas :)), ya que los posts que actualmente hay son un poco más avanzados y no hay ninguno para newbies.

Así que... allá vamos =)


BLINK

Éste es probablemente el proyecto más sencillo que se puede hacer con Arduino, el de hacer parpadear un LED, encendiéndose y apagándose cada segundo.

Lo que haremos será conectar un LED al pin 13. Para ello, conectaremos la "patilla larga" (la positiva, llamada ánodo) del LED al pin 13 de nuestro Arduino. La otra patilla (la negativa, llamada cátodo) irá conectada a tierra (GND).

¿Por qué el pin 13? Pues bien, este pin lleva incorporada una pequeña resistencia, suficiente para evitar daños en el LED, y así nos ahorramos tener que hacer el proyecto en otro pin y ponerle nosotros la resistencia.

Bien, ahora simplemente tenemos que poner este código en nuestro IDE de Arduino:

/*
Blink
Turns on an LED on for one second, then off for one second, repeatedly.

This example code is in the public domain.
*/

void setup() {
// initialize the digital pin as an output.
// Pin 13 has an LED connected on most Arduino boards:
pinMode(13, OUTPUT);
}

void loop() {
digitalWrite(13, HIGH); // set the LED on
delay(1000); // wait for a second
digitalWrite(13, LOW); // set the LED off
delay(1000); // wait for a second
}

Este código lo podéis cargar directamente los ejemplos que vienen ya en el IDE: File->Examples->1.Basics->Blink.

Ahora simplemente, le damos a Upload para pasar el programa a la placa, y observar el resultado.

Se puede observar lo anterior en el siguiente vídeo:



Como véis, ha sido muy sencillo.


FADE2

Ésta es una ligera modificación del programa de ejemplo Fade (File->Examples->1.Basics->Fade), en el que se hace parpadear gradualmente un LED, conectándolo al pin 9. En el sencillo proyecto que nosotros haremos, conectaremos tres LEDs en paralelo, y usaremos una protoboard. El circuito queda de la siguiente forma:

















Como se puede ver hemos usado una resistencia (de 220 Ohms), y hemos colocado los tres LEDs en paralelo, de forma que si uno de ellos se quita de la placa de prototipado, los demás seguirán funcionando. Se puede apreciar cómo hemos puesto dos jumpers para unir dos secciones de la protoboard, ya que, pese a que los puntos de la protoboard sólo están conectados verticalmente, las secciones no están conectadas entre sí.

Hemos conectado al pin 9 y a tierra (negativo con tierra).

El código usado es el siguiente:

/*
Fade

This example shows how to fade an LED on pin 9
using the analogWrite() function.

This example code is in the public domain.

*/
int brightness = 0; // how bright the LED is
int fadeAmount = 5; // how many points to fade the LED by

void setup() {
// declare pin 9 to be an output:
pinMode(9, OUTPUT);
}

void loop() {
// set the brightness of pin 9:
analogWrite(9, brightness);

// change the brightness for next time through the loop:
brightness = brightness + fadeAmount;

// reverse the direction of the fading at the ends of the fade:
if (brightness == 0 || brightness == 255) {
fadeAmount = -fadeAmount ;
}
// wait for 20 milliseconds to see the dimming effect
delay(20);
}

(Podemos jugar con el fadeAmount y el delay, para que haga fade a otro ritmo).

El resultado, después de subir el programa a Arduino es el siguiente:




toneMelody_StarWars

En éste proyecto, haremos uso del código que puede verse en el ejemplo toneMelody (File->Examples->1.Digital->toneMelody). Lo que haremos será usar un zumbador piezo (piezo buzzer) y una resistencia (yo uso una de 220 Ohmios, pero si tenéis una de 100 usadla), para sacar el sonido o melodía que nosotros queramos, en este caso una muy breve melodía de Star Wars, usando el pin digital 8. Haremos uso del fichero pitches.h (viene con el programa toneMelody), que define cada nota con el pitch de dicha nota... traduciendo: define cómo debe sonar cáda nota que pongamos. Como nota aclaratoria, decir que las notas vienen en el sistema de notación musical inglés:

C->Do
D->Re
E->Mi
F->Fa
G->Sol
A->La
B->Si

El número que llevan al lado es la "altura" a la que está dicha nota, para variar entre escalas.

El circuito, una vez montado queda así:

















Como se puede ver, es muy simple.

El código de nuestro programa es el siguiente:

/*
Melody

Plays a melody

circuit:
* 8-ohm speaker on digital pin 8

created 21 Jan 2010
by Tom Igoe

This example code is in the public domain.

http://arduino.cc/en/Tutorial/Tone

*/
#include "pitches.h"

// notes in the melody:
int melody[] = {
NOTE_C3,NOTE_C3, NOTE_C3, NOTE_GS2, NOTE_DS3, NOTE_C3, NOTE_GS2, NOTE_DS3, NOTE_C3, NOTE_G4, NOTE_G4, NOTE_G4, NOTE_GS4, NOTE_DS4, NOTE_C4, NOTE_GS2, NOTE_DS3, NOTE_C3 };
// note durations: 4 = quarter note, 8 = eighth note, etc.:
int noteDurations[] = {
4,4,4,4,8,4,4,8,4, 4,4,4,4,8,4,4,8,4};

void setup() {
// iterate over the notes of the melody:
for (int thisNote = 0; thisNote < note =" 1000" note =" 1000/8," noteduration =" 1000/noteDurations[thisNote];" pausebetweennotes =" noteDuration" style="font-style: italic;">melody, y en el array noteDurations ponemos si quieremos que sea una negra, corchea...

Podéis jugar con las notas y duraciones, y hacer cualquier melodía. La mía, de prueba, como dije arriba, es una parte corta de un theme de Star Wars. He aquí el resultado despues de subirlo a Arduino:





KNOCK2

En este último proyecto, usaremos un piezo para detectar vibración (podéis encontrar el ejemplo en File->Examples->6.Sensors->Knock); para ello usaremos el piezo buzzer que usamos anteriormente (no es demasiado bueno), y una resistencia de 1MegaOhm. Entre que mi piezo es malillo, y que no tengo una resistencia de 1MegaOhm, he tenido que hacer ciertos ajustes, pero aún así no capta ruidos desde lejos, y como mejor reacciona es dándole un golpe seco al piezo, para que vibre con fuerza.

Cada vez que detecte vibración, nos lo hará saber mediante un LED que colocaremos en el pin 13 (cambiará su estado cuando esto ocurra), y mediante el Serial Monitor (Tools->Serial Monitor), en el cual escribirá "Knock!".

Veamos cómo hemos montado el circuito:



Negrita











Lo ideal habría sido conectarle una resistencia de 1MegaOhm en paralelo al piezo, pero como no tengo, he tenido que ponerle, como se ve en la imagen, tres resistencias de 330k puestas en serie entre ellas. De nuevo he puesto jumpers para conectar ambas partes de la protoboard. Como vemos, conectamos a tierra y a la entrada analógica A0, ya que por ahí se enviará el resultado a nuestro Arduino.

Por otro lado, vemos como hemos conectado un LED en el pin 13, como ya hicimos en el primer proyecto.

He aquí el código del programa:

/* Knock Sensor

This sketch reads a piezo element to detect a knocking sound.
It reads an analog pin and compares the result to a set threshold.
If the result is greater than the threshold, it writes
"knock" to the serial port, and toggles the LED on pin 13.

The circuit:
* + connection of the piezo attached to analog in 0
* - connection of the piezo attached to ground
* 1-megohm resistor attached from analog in 0 to ground

http://www.arduino.cc/en/Tutorial/Knock

created 25 Mar 2007
by David Cuartielles
modified 4 Sep 2010
by Tom Igoe

This example code is in the public domain.

*/


// these constants won't change:
const int ledPin = 13; // led connected to digital pin 13
const int knockSensor = A0; // the piezo is connected to analog pin 0
const int threshold = 1; // threshold value to decide when the detected sound is a knock or not


// these variables will change:
int sensorReading = 0; // variable to store the value read from the sensor pin
int ledState = LOW; // variable used to store the last LED status, to toggle the light

void setup() {
pinMode(ledPin, OUTPUT); // declare the ledPin as as OUTPUT
Serial.begin(9600); // use the serial port
}

void loop() {
// read the sensor and store it in the variable sensorReading:
sensorReading = analogRead(knockSensor);

// if the sensor reading is greater than the threshold:
if (sensorReading >= threshold) {
// toggle the status of the ledPin:
ledState = !ledState;
// update the LED pin itself:
digitalWrite(ledPin, ledState);
// send the string "Knock!" back to the computer, followed by newline
Serial.println("Knock!");
}
delay(100); // delay to avoid overloading the serial port buffer
}


Como vemos, hemos puesto const int threshold = 1. ¿Qué es el threshold? Es el umbral que queremos poner como sensibilidad de detección del ruido necesario para activar el LED e imprimir por pantalla. Yo he puesto 1, porque como dije antes, no cuento con material de primera. Sin embargo, en el programa venía por defecto 300... es decir, que juguéis con el umbral a vuestro gusto y como mejor véais que funciona.

El resultado, después de subirlo al Arduino, puede verse aquí:





Pues bien, esto es todo por hoy. Como digo son proyectos muy sencillos para gente que está empezando. Cualquier sugerencia, correción o similares, será de gran ayuda.

Un saludo.