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.

lunes, 8 de noviembre de 2010

Radio control Memo car

XD antes que nada, tremendo el título del artículo. Este proyecto trata de manejar nuestro coche radio control, mediante un PC. con las teclas AWSD por ejemplo y poder memorizar el camino que hemos hecho.

Lo primero es el material del que disponemos. Utilizaremos un coche de juguete tyco, aunque cualquiera nos vale ya que no vamos a tocar el coche para nada, simplemente puentearemos el mando para poder manejarlo con arduino.



El coche va sin su carcasa, no es que esté roto... , y el mando ya en su acabado final con sus cables de conexión a la placa de control.

La placa de control:

Para poder comunicar el arduino con el mando he construido un pekeño shield que ahora explicaré su funcionamiento.



El circuito es bastante simple, se compone de 4 transistores BC337 con los cuales conmuto el circuito entre la tierra y las conexiones del mando. Con 4 pines de arduino controlaré digitalmente si acciono cada uno de los interruptores del mando.
Cabe destacar que este coche es digital, no tiene aceleración gradual ni giro gradual, todas sus acciones son binarias.

PD: yo no sabía como funcionaba un transistor como este pero es bastante fácil, tienen 3 patas, las de los lados las conectas al circuito y la del medio al arduino, y si el arduino mete voltaje por ahi, el circuito se abre. Es como un interruptor pero en lugar de botón para encender o apagar, se le manda una señal por la pata del medio.




El montaje del sistema es facil y rápido.

El mando y sus conexiones:

Llevó su tiempo buscar los puntos donde le hacía cosquillas al mando pero al final gracias a Isra en gran parte encontramos el funcionamiento básico del mando y como puentearlo:



Como vemos en las imágenes, hemos tenido que abrir el mando y acceder por la parte posterior a las soldaduras. En la foto de la derecha, los cables rojo y negro de arriba izquierda, son los conectores para girar el coche, los de arriba derecha es el acelerador y la marcha atrás. Y abajo donde coincide con el cable azul, es la tierra, que es muy importante que la tierra del mando esté conectada a la tierra de arduino.

La programación de Arduino:

En arduino simplemente tendremos un programa que dado un numero que nos viene por serie, hace una acción u otra por los pines de control.

const int ledPin = 9; // the pin that the LED is attached to

void setup()
{
// initialize the serial communication:
Serial.begin(9600);
// initialize the ledPin as an output:
pinMode(2, OUTPUT); //up
pinMode(3, OUTPUT); //down
pinMode(4, OUTPUT); //right
pinMode(5, OUTPUT); //left
digitalWrite(2, B0);
digitalWrite(3, B0);
digitalWrite(4, B0);
digitalWrite(5, B0);
}

void loop() {
byte val;
int WEST = 8;
int SOUTH = 4;
int EAST = 2;
int NORTH = 1;

if (Serial.available()) {
val = Serial.read();
(val & NORTH)?digitalWrite(2, B1):digitalWrite(2, B0);
(val & EAST)?digitalWrite(3, B1):digitalWrite(3, B0);
(val & SOUTH)?digitalWrite(4, B1):digitalWrite(4, B0);
(val & WEST)?digitalWrite(5, B1):digitalWrite(5, B0);
}
}


La programación de Processing:

Processing es el que tiene la miga, este se encarga de enviarle a arduino las teclas que estámos pulsando, para que arduino mueva el coche. Pero además llevará un sistema de log de teclas que irá guardando en un fichero para poder reproducir la secuencia programada.

Teclas:
ASDW : teclas de dirección
R: Empezar a grabar camino
P: Reproducir secuencia grabada (la secuencia se reproducirá en bucle infinito)
U: Stop, tanto para grabar como para reproducir



final static int NORTH = 2;
final static int EAST = 4;
final static int SOUTH = 1;
final static int WEST = 8;
final static int TURBO = 16;

boolean record = false;
boolean play = false;
int result;
import processing.serial.*;
Serial port;
PrintWriter output;
String[] lines;
int index = 0;

void all(int colori){
izq(colori);
der(colori);
arr(colori);
aba(colori);
}

void izq(int colori){
fill(colori);
rect(10,50,30,40);
}
void der(int colori){
fill(colori);
rect(80,50,30,40);
}
void arr(int colori){
fill(colori);
rect(40,10,40,40);
}
void aba(int colori){
fill(colori);
rect(40,90,40,40);
}
void setup() {
size(400,200);
frameRate(30);
result = 0;
port = new Serial(this, Serial.list()[0], 9600);
background(0);
all(33);
}
void draw() {
if (record) {
output.println(result);
output.flush();
}
if (play) {
if (index <>
result = int(lines[index]);
index = index + 1;
} else index = 0;
}
switch(result) {
case NORTH:
port.write(NORTH);
arr(255);
aba(33);
break;
case TURBO|NORTH:
port.write(SOUTH|NORTH);
arr(150);
aba(33);
break;
case TURBO|NORTH|WEST:
port.write(SOUTH|NORTH|WEST);
arr(150);
der(33);
izq(150);
aba(33);
break;
case TURBO|NORTH|EAST:
port.write(SOUTH|NORTH|EAST);
arr(150);
der(150);
izq(33);
aba(33);
break;
case EAST:
port.write(EAST);
der(255);
izq(33);
break;
case SOUTH:
port.write(SOUTH);
aba(255);
arr(33);
break;
case WEST:
port.write(WEST);
izq(255);
der(33);
break;
case NORTH|EAST:
port.write(NORTH|EAST);
arr(255);
der(255);
izq(33);
aba(33);
break;
case NORTH|WEST:
arr(255);
der(33);
izq(255);
aba(33);
port.write(NORTH|WEST);
break;
case SOUTH|EAST:
arr(33);
der(255);
izq(33);
aba(255);
port.write(SOUTH|EAST);
break;
case SOUTH|WEST:
arr(33);
der(33);
izq(255);
aba(255);
port.write(SOUTH|WEST);
break;
default:
port.write(0);
all(33);
break;
}

}
void keyPressed(){
switch(key) {
case('w'):case('W'):result |=NORTH;break;
case('d'):case('D'):result |=EAST;break;
case('s'):case('S'):result |=SOUTH;break;
case('a'):case('A'):result |=WEST;break;
case('t'):case('T'):result |=TURBO;break;
case('r'):case('R'):
output = createWriter("save.txt");
record = true;
play = false;
break;
case('u'):case('U'):record = false; play = false;break;
case('p'):case('P'):
play = true;
record = false;
output.flush();
output.close();
lines = loadStrings("save.txt");
index = 0;
break;
}
}
void keyReleased(){
switch(key) {
case('w'):case('W'):result ^=NORTH;break;
case('d'):case('D'):result ^=EAST;break;
case('s'):case('S'):result ^=SOUTH;break;
case('a'):case('A'):result ^=WEST;break;
case('t'):case('T'):result ^=TURBO;break;
}
}

Video:

miércoles, 7 de julio de 2010

Sun tracking mini edition

Oh hi!, ayer miré al "motor paso a paso", el me miró a mi y coincidiendo que yo llevaba un panel solar en mis manos, se me ocurrió una idea absurda con la que unir ambas cosas. Nada más y nada menos que un super inutil buscador del sol, como los lindos girasoles que hay en los campos.

Lo que más me costó fué ingeniarmelas para poner el panel en el motor, pero al final di con la solución gracias a la parte de goma que tienen los bolis estos caros. he aki una foto de lo bien que encaja.



El motor y las demás piezas las he encajado en un carton para que no se muevan, que sinó, vaya fiesta.

En cuanto al control del motor, he seguido el mismo esquema que en el post anterior.



He tenido que hacerme unas funciones nuevas específicas para girar el motor una cantidad determinada de grados.

La energia del motor la saco de la salida de 5v del arduino, pero tambien se podría meter una fuente externa, o si pusieramos mas paneles , alimentarse a si mismo y al arduino.

En cuanto a la placa solar, he conectado el cable positifo la entrada analogica 0 y la otra a tierra, y así puedo leer la cantidad de energia que pilla la plaquita.

Una vez montado todo esto, gracias a un superelavorado algoritmo , XD , podremos hacer que el panel gire hacia donde haya más luz. Increíble xD

Aki el algoritmo para el arduino


int motorPin1 = 8;
int motorPin2 = 9;
int motorPin3 = 10;
int motorPin4 = 11;

int angle = 90;
float val = 0;

int step = 0;

void derecha(int delayTime,float angulos){
//96 pasos de 3,75 grados son 360 grados
if (angulos + angle > 180) return;
angle = angle + angulos;
angulos = angulos / 3,75;
for (int i=0; i < angulos ; i++) {
digitalWrite(motorPin1, step==0?HIGH:LOW);
digitalWrite(motorPin2, step==1?HIGH:LOW);
digitalWrite(motorPin3, step==2?HIGH:LOW);
digitalWrite(motorPin4, step==3?HIGH:LOW);
delay(delayTime);
step = (step+1)%4;
}
}

void izquierda(int delayTime,float angulos){
//96 pasos de 3,75 grados son 360 grados
if (angle - angulos < 0) return;
angle = angle - angulos;
angulos = angulos / 3,75;
for (int i=0; i < angulos ; i++) {
digitalWrite(motorPin4, step==0?HIGH:LOW);
digitalWrite(motorPin3, step==1?HIGH:LOW);
digitalWrite(motorPin2, step==2?HIGH:LOW);
digitalWrite(motorPin1, step==3?HIGH:LOW);
delay(delayTime);
step = (step+1)%4;
}
}

void buscabusca(){
float der = 0;
float izk = 0;
float now = 0;
int last = 0;

val = analogRead(0); // lee el valor de tensión del pin
val = val * 6 / 1300;
Serial.println(val);
for(;;) {
now = analogRead(0);
if (last > 0){
derecha(55,5);
der = analogRead(0);
Serial.print("der");
Serial.println(der);
if (abs(der - now)<3) delay(1000);
if (der > now) last = 1;
else last = 0;
} else {
izquierda(55,5);
izk = analogRead(0);
Serial.print("izk");
Serial.println(izk);
if (abs(izk- now)<3) delay(1000);
if (izk > now) last = 0;
else last = 1;
}
}
}

void setup() {
pinMode(motorPin1, OUTPUT);
pinMode(motorPin2, OUTPUT);
pinMode(motorPin3, OUTPUT);
pinMode(motorPin4, OUTPUT);

Serial.begin(9600); // Inicialización del modulo Serial.

}

void loop() {
buscabusca();
}



Como vemos , la lectura del panel, se hace por el pin analogico 0 , y los pines digitales 8,9,10,11 los usamos para mover el estepper.

El programa muestra por el puerto serie información sobre lo leido , por si hay ke debugear. XD

Subiría un video de como se mueve pero ya mejor ke lo averigue cada uno.

Aunque si tuviera que poner un video pondría uno que he visto por youtube que se parece bastante a esto pero en mayor escala xDD


domingo, 4 de julio de 2010

Motor paso a paso con arduino

Esta tarde he desmontao un scanner viejo que tenía por ahi y me he encontrado dentro con esto:


Tachaaann!! que coño es esto? verdad?

pues ya me sonaban un poco asi de oidas lo de los stepper motor , o en castellano, motores paso a paso (PaP).

He investigado por ahi los tipos de motores y resulta que estos tipos de motores funcionan como si tuvieran 4 imanes dentro, uno a sus 12 otro a las 3 , 6 y 9, osea, norte sur este y oeste. Entonces dependiendo de el iman que esté encendido es un paso u otro.

Por ejemplo, para darle una vuelta a este motor, tendríamos que encender el motor del norte, solo, luego el del este solo, luego el del sur solo y por ultimo el del oeste solo, y norte again.

voy a robar unas imagenes explicativas que me han gustao xDD









y si queremos girar en sentido opuesto pues imagina, los enciendes en el otro sentido.

También se puede hacer los giros en lugar de en 4 pasos, en 8 encendiendo tambien 2 imanes a la vez, lo cual hace que se quede en medio del A y B por ejemplo

Bueno lo básico ya está claro, si tienes más interés en los motores puedes verlo en este link:
http://www.x-robotics.com/motorizacion.htm

Seguimos, el tema es que una vez desmontado, te vienen 5 cables y no tienes ni idea de para que es cada uno xDD

En mi caso me venían 4 seguidos y uno separado, usando la lógica, el separado es para meterle los voltios y los otros cuatro son para controlar los cuatro imanes ke lleva. Así que si hay ke controlar cosas, que mejor que el multiusos chip ULN2003 que también nos había servido para el ambilight casero.

He usado las primeras 4 patillas del chip para los cuatro cables de control y están conectadas a los pines 8, 9, 10,11. El de voltaje no va enchufado al chip, pero lo enchufaremos más tarde directamente a los 12v de una fuente.



Como se vé los colores amarillo, negro, naranja y marron son de control y el rojo es el del voltaje.
según la especificación del motor el motor se le supone ke va con 24v, pero con 12v o incluso con 5 a mi me ha ido a la misma velocidad...




Para terminar de hacer la gracia , he puesto el motor donde estaba y ahora manejo el carrusel del scaner con el arduino xDDD, la verdad esque me esperaba poder ponerle más velocidad, pero es lento de cojones... aunque bastante potente.


Ah!, por último el código del arduino para hacer maravillas con este motor xDD

PD: mi motor en concreto tiene un giro de 3 grados por cambio de fase

Step Angle
3.75º/step

eso pone en la DATASHEET xDD

osea que por ejemplo para dar una vuelta entera deberemos cambiar de fase unas 360 / 3,75 = inicio, ejecutar, calc y nos dá un resultadod de 96 cambios

en el codigo voy a hacer dos funciones, una que de una vuelta pa un lao y otra ke haga exactamente lo contrario.




int motorPin1 = 8;
int motorPin2 = 9;
int motorPin3 = 10;
int motorPin4 = 11;

int step = 0;

// Up Down Left Right


void derecha(int delayTime,int vueltas){
//96 pasos de 3,75 grados son 360 grados

vueltas = vueltas * 96;
for (int i=0; i < vueltas ; i++) {
digitalWrite(motorPin1, step==0?HIGH:LOW);
digitalWrite(motorPin2, step==1?HIGH:LOW);
digitalWrite(motorPin3, step==2?HIGH:LOW);
digitalWrite(motorPin4, step==3?HIGH:LOW);
delay(delayTime);
step = (step+1)%4;
}

}

void izquierda(int delayTime,int vueltas){
//96 pasos de 3,75 grados son 360 grados

vueltas = vueltas * 96;
for (int i=0; i < vueltas ; i++) {
digitalWrite(motorPin4, step==0?HIGH:LOW);
digitalWrite(motorPin3, step==1?HIGH:LOW);
digitalWrite(motorPin2, step==2?HIGH:LOW);
digitalWrite(motorPin1, step==3?HIGH:LOW);
delay(delayTime);
step = (step+1)%4;
}

}


void setup() {
pinMode(motorPin1, OUTPUT);
pinMode(motorPin2, OUTPUT);
pinMode(motorPin3, OUTPUT);
pinMode(motorPin4, OUTPUT);
}

void loop() {
derecha(2,1);
izquierda(2,1);
derecha(3,1);
izquierda(3,1);
derecha(4,1);
izquierda(4,1);
derecha(5,1);
izquierda(5,1);
}



Y este codigo hace una vuelta pa un lao y otra pa otro xDD lo mas rápido posible, ya que si le metes un delay de 1 se vuelve loco y no se mueve xDDD

OJO! Las funciones se llaman up down left y right, pero no significa que el up sea pa arriba y right sea derecha, tendría que cambiar los nombres, para hacer funciones para girar 90 grados, osea 6 cambios seguidos.

Ah están hechas las funciones de los pasos diagonales, si hicieramos los 4 pasos solo con diagonales el motor sería mas powerfull ya que el motor gira con la fuerza de dos imanes por paso.


Fuentes:
http://www.mitsumi.co.jp/latest/Catalog/compo/motor/m42sp4_e.html
http://www.x-robotics.com/motorizacion.htm
http://www.arduino.cc/en/Tutorial/StepperUnipolar


Ambilight casero para PC

Holas, aquí va el segundo tema util que hacer con arduino. En este caso montaremos un ambilight casero con las tiras de leds RGB del IKEA. Personalmente no recomiendo comprarlas, no porque sean malas, todo lo contrario, funcionan perfectamente, pero son un pelin caras para mi gusto.

Hay otra alternativa en Dealextreme, más económica, y servirá perfectamente.

Hardware

Las tiras de leds que tengo son así:


Cada tira tiene 4 conectores, uno para cada canal R, G y B (Rojo, Verde y Azul) y un cuarto por donde le entran los 12v que pide.

Tenemos que fijarnos si hay alguna leyenda por las tiras donde lo indique ya que en mi caso, el orden está cambiado y es RBG en lugar de RGB, la W será de power.



En cuanto al circuito necesario para que funcione la cosa, aquí pongo un esquema hecho a mano para que quede clara la cosa.



Como se puede apreciar, usamos un chip ULN2003 para controlar la potencia que pasa por los distintos canales.

Este chip soporta bien los 12v pero está limitado a 0.5A de salida, así que asegurate que las tiras de leds no consumen más de eso si no quieres salir ardiendo XDD

El resto es simplemente conectar a las salidas PWM de arduino por un lado y por el otro a las tiras de leds.

Los 12v se los meteremos a ambas tiras directamente por su pin.

Las X marcadas significa que no se usan.

Una vez montado en una placa prototipo o en un proto shield (como es mi caso) nos quedará algo como esto



El interruptor y las resistencias y tal podeis ignorarlas porque no son parte de esto, solo son para poder resetear el arduino con el shiel montado



Software

En cuanto a la parte de programar el arduino, debemos cargar el siguiente programa:

// This sketch translates Boblight commands to control RGB LEDs via PWM.
// Implements LTBL serial protocol (http://blogger.xs4all.nl/loosen/articles/420470.aspx)
// 2009-11-27 (c) Szymon Kobalczyk (http://geekswithblogs.net/kobush/)
// http://opensource.org/licenses/mit-license.php

#define DEBUG 0 // set to 1 to send debug to SoftSerial (2,4)

#define checkByte1 0x55
#define checkByte2 0xAA

int ledPin = 13; // debug led

#define channelCount 6
word channels[channelCount]; // holds current color values
int channelPins[channelCount] = { 6, 3, 5, 11, 9, 10 }; // PWM pins to control LED strips (2x RGB)

#if DEBUG
#include
int rxPin = 2;
int txPin = 4;
NewSoftSerial xSerial(rxPin, txPin);
#endif

void setup() {
digitalWrite(ledPin, HIGH); // say we're alive

Serial.begin(9600); // open serial

#if DEBUG
xSerial.begin(57600);
xSerial.print("[boblight] ");
#endif

for (int i =0; i < channelCount; i++)
{
channels[i] = 0; // reset all channels
pinMode(channelPins[i], OUTPUT); // setup channel pin
}
setLight();

#if DEBUG
xSerial.println("Setup finished.");
#endif

digitalWrite(ledPin, LOW);
}

void loop()
{
// continuously looks to the serial port
// if there is data it processes it
pollSerialPort();
}

void setLight() {
word val;
byte high, low;
for (int i=0; i < channelCount; i++)
{
val = channels[i];
high = val >> 8;
//low = val & 0xFF;
analogWrite(channelPins[i], high);

#if DEBUG
xSerial.print(channelPins[i]);
xSerial.print(":");
xSerial.print(high, DEC);
xSerial.print(" ");
#endif
}
#if DEBUG
xSerial.println();
#endif
}

// process incoming data
void pollSerialPort() {
int data;
if (Serial.available() >= 4) { // if at least 4 bytes are in the buffer
data = Serial.read();
echo(data);
if (data == checkByte1) { // check first prefix byte 0x55
data = Serial.read();
echo(data);
if (data == checkByte2) { // check second prefix byte 0xAA
digitalWrite(ledPin, LOW); // signal prefix recognized
data = Serial.read();
if (data < 127)
readChannels(data);
else
readCommand(data);

return;
}
}
// error
digitalWrite(ledPin, HIGH); // signal unrecognized sequence
}
}

void echo(int data) {
#if DEBUG
xSerial.print((byte)data, HEX);
xSerial.print(" ");
#endif
}

void readChannels(int startChannel) {
int numChannels = Serial.read();

// wait for all data to come in (expecting 2 bytes per channel)
while (Serial.available() < numChannels * 2)
delay(10);

#if DEBUG
xSerial.print("SET: ");
// xSerial.print("Reading channels ");
// xSerial.print(startChannel, DEC);
// xSerial.print(" ");
// xSerial.print(numChannels, DEC);
#endif

byte high, low;
word val;
for (int i = 0; i < numChannels; i++)
{
high = Serial.read(); // echo(high);
low = Serial.read(); // echo(low);
val = word(high, low);

if (startChannel+i < channelCount)
channels[startChannel+i] = val;

#if DEBUG
xSerial.print(high, DEC);
xSerial.print(" ");
#endif
}

#if DEBUG
xSerial.println();
#endif

// apply changes
setLight();
}

void readCommand(int command) {
int numBytes = Serial.read();

#if DEBUG
xSerial.print("Reading command ");
xSerial.print(command, HEX);
xSerial.print(" ");
xSerial.print(numBytes, DEC);
#endif

if (command == 0x81) // request current values
{
requestValues();
}
else if (command == 0x83) // open light
{
setLight();
}
else if (command == 0x84) // close light
{
for (int i =0; i channels[i] = 0; // reset all channels
}
setLight();
}

#if DEBUG
xSerial.println();
#endif
}

void requestValues()
{
int startChannel = Serial.read();
int numChannels = Serial.read();

#if DEBUG
xSerial.print(" request current values ");
xSerial.print(startChannel, DEC);
xSerial.print(" ");
xSerial.print(numChannels, DEC);
#endif
Serial.print(checkByte1, BYTE);
Serial.print(checkByte2, BYTE);

if (startChannel >= channelCount || numChannels <=0)
{
// no data to send
Serial.print(0, BYTE);
Serial.print(0, BYTE);
}
else
{
numChannels = min(channelCount - startChannel, numChannels);
Serial.print(startChannel, BYTE);
Serial.print(numChannels, BYTE);

byte high, low;
word val;
for (int i=startChannel; i < startChannel + numChannels; i++)
{
val = channels[i];
high = val >> 8;
low = val & 0xFF;
Serial.print(high, BYTE);
Serial.print(low, BYTE);
}
}
}


Eso por parte de arduino.

Por otra parte debemos configurar un programa llamado boblight en el pc, que es el que se encarga de mirar los colores que hay en la pantalla e indicarle al arduino por el puerto serie cuales debe mostrar por las tiras de colores izquierda y derecha.
El programa consta de 2 ejecutables, uno rojo y otro verde, hay ke ejecutar el rojo y luego el verde.

El punto interesante aquí es el fichero de configuración boblight.conf. En este fichero deberemos configurar lo siguiente:


[device]
name ambilight
type LTBL
output "com11"
rate 9600
channels 6
interval 10000
Como vemos, yo lo tengo configurado para que se comunique con el arduino por el com11, este habrá que cambiarlo al que uses. Puedes saber cual usas desde el compilador de arduino, Tools > Serial port.

En cuanto al resto de fichero, podemos trastearlo también un poquito para que nuestro ambilight tenga unos colores más parecidos a los de la pantalla, por ejemplo:


[color]
name red
rgb FF0000
gamma 1.0
adjust 1.0
blacklevel 0.0


En este texto configuramos tanto el color Rojo como sus intensidades, a veces puede ser que la tira de leds se vea demasiado rojizo y podemos ajustarlo bajandole el adjust, 1.0 = 100% de potencia, así si le keremos bajar un poco ponemos 0.8 o así

Otro punto interesante son los dos últimos trozos


[light]
name left
color red ambilight 1
color green ambilight 2
color blue ambilight 3
hscan 0 50
vscan 12 88

[light]
name right
color red ambilight 4
color green ambilight 5
color blue ambilight 6
hscan 50 100
vscan 12 88


hscan es el la superficie horizontal que vamos a tomar referencia para esa tira de colores, y la vscan es la superficie vertical. En el caso de la primera luz, estamos tomando del 0% al 50% de la pantalla en horizontal, y del 12% al 88% en vertical ( el vertical está recortado para que no tome en cuenta las barras negras de las películas).

Una vez montado todo, cualquier cosa que tengas en la pantalla estará representado por el ambishield, aunque sea el propio escritorio.

Link de mi boblight aqui.
http://www.megaupload.com/?d=7A8RMLFX

Os porngo un video robado de otra persona para que veais como queda.

sábado, 3 de julio de 2010

Enfriando la fonera

Ayer me decidí a trastear la maravillosa fonera que tenía ahi sin usar, y pensé, voy a tunearla para conectarla al arduino, y así me ahorro tener un wifi y ethernet shield.

La cosa iba bien , estuve buscando información y tal. Hay bastante información de hacer esto por ahí, pero el tema es que tuve que ir tomando cachitos de varios sitios para poder montarlo todo.

Ah , y cuando lo tenía todo montado, me daba cosa tener la fonera encendida más de 1 hora porque las temperaturas que alcanzaba eran tremendas, así que busqué por ahi y tb solucioné el tema de la temperatura.

Pondré los pasos que he seguido para tener la cosa ya montada:

Flashear la fonera

Este paso no tiene mucha complicación ya que solo es seguir un tutorial que hay por ahi para instalarle el dd-wrt

Podeis encontrarlo aki :
http://www.dd-wrt.com/wiki/index.php/LaFonera_Software_Flashing

Como comentario diré , que tardé unas horas largas

Mi fonera en concreto es la vieja, la primer, el modelo 2100, y encima cuando la resetee, llevaba el firmware 0.7.1 r1 por lo tanto me tocó la via facil.

Lo que mola esque ahora que la tengo ya
flasheada, puedo acceder a ella facilmente por el putty (192.168.1.1) y tener un shell ahi a mi disposicion

PD: como dato extra, para acceder por ssh, te puedes rayar bastante, porque el login y pass es simplemente login: root, y contraseñ
a la que tengas configurada en la administración del router.
Digo esto porque yo le cambié la pass a la fonera, yaque las que venían por defecto (root/admin) eran muy evidentes, y le puse (arduino/arduin
o), pues por ssh, aunque el user sea arduino hay ke entrar como root...

Una vez hecho esto, cuando accedo por el navegador al 192.168.1.1 me sale la administración del dd-wrt, y yastá listo. Supongo que pa
ra que el arduino se conecte a internet, deberémos configurar la fonera para ke sea cliente de otra wifi, pero eso ya lo veremos otro dia xD.

Sacar cables

Para que el arduino se conecte con la fonera , irremediablemente deberá estar conectada a esta mediante cables, puesla cosa está bien sencilla.




Abrimos la fonera y buscamos estos pines, sólo necesitaremos 4 de ellos , aunque el de lso 3,3v no se usa para nada pero puede servir xDD.

El Tx y el Rx se conectan al Tx y Rx del arduino, según he leido por ahi, a veces es al reves, el T al T y el R al R o de la otra forma, es cuestión de probar.

Para facilitar la conexión me he pillado un par de cables que ya tenían sus conectores hembra, pero como era demasiado largo he tenido ke doblar las patas como se ve en la imagen para que quepa.


La verdad esque una vez montados los cables, han kedado bastante bien.




A la derecha se puede ver el conector que he hecho para pichar en el arduino, de los otros dos cables solo se necesita enchufar al arduino el de tierra.


Enchufarle un ventilador

Como el problema de temperatura era palpablemente evidente, ponerle un ventilador es necesario si no queremos tener riesgo de incendio... yo lo he montado así

buscamos los 5v de la placa y le soldamos un par de cables ahi para la alimentación del ventilador. Por cierto, el ventilador lo he pillao de 5v, ke los de 12 van muy lentillos aa 5v




Una vez sacados los cables los soldamos con los del ventilador y listo, en mi caso, un dia se me ocurrión la inteligente idea de ponerle un antirobo a la fonera, cosa que no me ha venido bien ahora porque el espacio para el ventilador es escaso, peeeero, cosas del karma, he pillado un ventilador perfecto tanto por espacio como por disposición de este en la fonera, ya que pilla justo encima del minidisipador que tiene XDDD




Si, el recorte del bujero es super cutre, pero da igual, funciona perfectamente

XDD

Tachannn!!!




Ahora sólo queda la parte del arduino ya que la fonera no hay ke tocarle ya nada hardware. lista y en marcha

PD: la fonera está fria. xDD

Fuentes:

http://www.dd-wrt.com/wiki/index.php/LaFonera_Software_Flashing



http://www.dd-wrt.com/wiki/index.php/LaFonera_Hardware_Cooling-System



http://www.sherkhan.net/blogs/frikadas/?p=420