Comunicación inalámbrica con Arduino

Una de las dudas que, irremediablemente, tarde o temprano nos asalta cuando empezamos a trabajar con Arduino es ¿Y cómo puedo intercambiar datos con un Arduino sin necesidad de usar cables? Las necesidades para conseguir esto son de lo más variopintas, desde controlar el comportamiento de nuestro Arduino a distancia ya que lo estamos usando para leer datos de un sensor en un lugar apartado del PC, hasta permitir la comunicación inalámbrica de dos Arduinos.

Existen varias alternativas, cada una con sus pros y sus contras, así que voy a comentar aquí mis experiencias con este tema para que no os volváis locos haciendo pruebas como me pasó a mí :)

Zigbee

En realidad Zigbee es una especificación de protocolos de comunicación inalámbricos definidos por la Zigbee Alliance y enfocados a entornos de bajo consumo. Varios fabricantes producen módulos compatibles, como el que aparece en la siguiente foto:

Módulo XBee, compatible con el protocolo Zigbee

Es la opción más elegante y la que mayor alcance y tasa de transferencia de datos garantiza, de todas las que veremos en este artículo. Su uso es bastante sencillo, pues en última instancia nos provee de un puerto serie por donde enviaremos y recibiremos los datos intercambiados con otros módulos Zigbee.

Para aquellos que se decidan por Zigbee, existe gran cantidad de documentación y ejemplos para las distintas plataformas de microcontroladores existentes en el mercado. Nuestro querido Arduino no podía ser menos y, como era de esperar, disponemos incluso de shields para poder usar módulos Zigbee en nuestros proyectos:

Shield de Arduino para un módulo XBee similar al visto anteriormente

Como os podréis imaginar, esta opción tiene una pega importante y es el alto coste que implican estos módulos, mucho mayor que el del resto de opciones que veremos.

Módulos con codificación OOK

Existen unos módulos de envío y recepción de datos basados en codificación OOK (On/Off Keying) los cuales nos permiten enviar pequeñas cantidades de datos como grupos de unos y ceros. Estos módulos son realmente simples, por lo que no incorporan en el hardware ningún tipo de mecanismo de control de errores, señalización ni direccionamiento; simplemente envían aquello que se les manda a todo aquel que se encuentre a su alcance. Al no disponer de control de flujo ni errores, deberemos ser nosotros los que, mediante código, implementemos dichos controles para garantizar un envío y recepción correctos. Estos módulos se utilizan principalmente en mandos a distancia por radiofrecuencia, ya que su coste es realmente bajo y para pequeños paquetes de datos son más que suficiente, además de que al no necesitar ningún tipo de secuencia de establecimiento de conexión, pueden empezar a emitir rápidamente y finalizar en un corto espacio de tiempo, con lo que el gasto en batería es ínfimo. Podemos encontrar estos módulos, por ejemplo, en eBay:

http://www.ebay.com/sch/i.html?_trksid=p2050601.m570.l1313.TR12.TRC2.A0.X433mhz+module&_nkw=433mhz+module&_sacat=0&_from=R40

Aquí os dejo una foto de la pareja de emisor/receptor que tengo yo:

Es importante que busquéis módulos que operen en la frecuencia dde 433 Mhz u 868 MHz, que son las frecuencias habilitadas en Europa para uso libre por los ciudadanos. Veréis que hay disponibles módulos de 315 MHz, que se usan en Estados Unidos y otros países.

Estos módulos tienen 3 pines:

1. Vcc, que debe ser alimentado con 5V, por lo que deberá conectarse al pin de 5V de Arduino.
2. GND, que debe conectarse a cualquier pin GND de nuestro Arduino.
3. DATA, que será el pin a través del cual enviaremos o recibiremos los datos.

Existe en ambos módulos un pad donde podremos soldar una antena apropiada, para aumentar así el alcance de los módulos. El tipo de antena más simple que podemos utilizar es un trozo de cable recto de aproximadamente unos 16 centímetros y medio (en caso de que sean módulos de 433 MHz). En esta imagen podéis apreciar otros tipos de antena:

El módulo de envío no tiene mucho misterio y sólo hay que alternar el pin de datos entre 0 y 1, dejando una pausa determinada entre las transiciones del pin. Es muy recomendable que los bits de los datos a enviar se representen con varias transiciones entre cero y uno, por ejemplo aquí podemos ver una codificación bastante típica:

Se observa como un valor se representa mediante un pulso corto seguido de otro pulso largo, mientras que el otro valor se representa con dos pulsos cortos seguidos.

El módulo de recepción sí que tiene más miga, puesto que estos aparatos no traen circuitería de filtrado y las bandas de frecuencia libres como la de 433 MHz están llenas de ruido, por lo que cuando no estemos transmitiendo nada, recibiremos gran cantidad de transiciones entre cero y uno en el pin de datos, las cuales son erráticas y no siguen ningún patrón aparente, como podéis comprobar en esta imagen:

Se ve claramente y a simple vista la diferencia entre los periodos donde se está transmitiendo información y los tramos donde sólo hay ruido, pero esto complica un poco la discriminación que deberemos realizar nosotros por software para filtrar todo aquello no deseado.

Lo más sencillo para manejar un receptor de este tipo es declarar una interrupción y conectar el pin de datos del módulo RF al pin correspondiente del arduino (D2 o D3, dependiendo de la interrupción declarada). De este modo, sólo tendremos que medir el tiempo transcurrido entre las transiciones para saber si se ajusta a nuestro patrón o no.

Los pros de este sistema os los podéis imaginar: un precio realmente bajo con un alcance considerable (con la antena adecuada he alcanzado sin problemas distancias de unos 100 metros a campo abierto). Las pegas, sin embargo, son importantes, porque por un lado necesitaremos 2 módulos (uno de envío y uno de recepción en cada arduino, salvo que queramos comunicación en un único sentido) y, por otra parte, no se consiguen buenas tasas de transferencia de datos, además del mayor "coste" en términos de programación que requieren estos módulos debido a tener que controlar los errores, el reenvío de paquetes perdidos o erróneos, etc.

Módulos Nordic RF

Hace tiempo, investigando una alternativa intermedia entre los Zigbee y los módulos OOK que comentamos anteriormente, di con estos transceptores poco conocidos y que tenían un precio atractivo, por lo que decidí comprar un par para probarlos y ver su desempeño.

Este modelo concreto es el NRF24L01 y dispone de una librería para Arduino que podemos usar en nuestros desarrollos: http://playground.arduino.cc/InterfacingWithHardware/Nrf24L01

La comunicación con estos módulos se realiza mediante SPI, por lo que deberemos conectarlo a los pines SCK, MISO y MOSI de nuestro arduino preferido (pines 13, 12 y 11) y dos pines digitales de I/O (por defecto, la librería utiliza los pines D7 y D8), además de alimentación (3.3V). En esta imagen podéis ver el esquema de conexionado:

Antes de poder conectar el módulo RF a una protoboard para poder hacer las primeras pruebas, deberemos construir un pequeño adaptador con un par de tiras de pines y un trozo de pcb perforada, ya que estos módulos utilizan como conexionado dos tiras de 5 pines en paralelo. En esta foto podéis ver uno de mis módulos y el adaptador que construí:

Por ahora, no he tenido la oportunidad de usar estos módulos en una aplicación real, simplemente he cargado los sketches de ejemplo de la librería y los he probado. Tan pronto como pueda ponerlos a prueba y realice algunas mediciones de distancia, velocidad, etc. publicaré aquí los resultados.

¡Hasta la próxima!

Arduino Standalone

O lo que es lo mismo, hacer funcionar el atmega328 sin necesidad de la placa del arduino.

Razón de hacer esto:
- ahorro de espacio
- el atmega por separado es mucho más barato
- para proyectos dedicados no merece la pena perder una placa arduino

Tras una larga tarde buscando por internet como iban las conexiones, he conseguido hacer que funcione el ejemplo de blink y ha quedado así




Ingredientes necesarios:

1x Atmega328
1x 16MHz clock crystal
2x 22 pF capacitors
cable y alimentación a 5v

En el caso que tengas que alimentarlo con un voltaje mayor de 5v necesitarás un

1x L7805CV (este sirve para pasar un voltaje de entrada de hasta 40v a 5v para la alimentación del atmega, ojo que debe ser mínimo 7 u 8v)

OJO. He puesto en el dibujo 2 pilas AA pero sólo para indicar como va la entrada de corriente, que debe ser 5v, el dibujo es orientativo



Esto es lo mínimo que se puede poner, después ya te apañas tu para ponerle lo que necesites, si no te sabes de memoria que es cada patilla, puedes fijarte aquí



Y después de ponerle algo útil. Tenemos nuestro atmega funcionando



Si queremos programar el Atmega sin tener que sacarlo y ponerlo en la placa de arduino debemos hacer la siguiente conexión:



Y ya tenemos el primer paso hecho hacia el siguiente proyecto...

Comenzando con IR (recepción de datos)

Bueno, dada la pereza, haré un breve pero interesante documento sobre lo que llevo hecho. La intención del proyecto es poder controlar cosas con IR así que esta es la primera parte, entender los datos.

Como emisor, usaré un mando a distancia cualquiera. Ya haré otra publicación sobre como hacer uno propio.

Parte del receptor:

He usado un receptor IR que tenía por ahi perdido, pero básicamente todos los receptores tienen 3 pines, uno para la entrada de 5v, otro para la tierra y otro para los datos.

Los 5v y tierra los conectamos a arduino, y el de datos lo conectamos al pin2 de los digitales.

En mi ejemplo he puesto que arduino, según lo leido por IR , controle un led bicolor y los he conectado a los pines 8 y 9






En cuanto al código, me he copiado descaradamente de esta web http://www.ladyada.net/learn/sensors/ir.html, en la cual aparece muy claramente una explicación y el código.

Midiendo inductancias con Arduino

Cuando estas trasteando y aprendiendo en el mundo de la electrónica siempre es interesante mirar circuitos que otras personas han diseñado y probado para realizar funciones específicas que necesitas. Es simple, te bajas el esquema, te haces con los componentes y los sueldas en una placa perfboard o te haces tu propio PCB.

Pero hay un problema que siempre se me presenta con un circuito analógico medianamente complicado, y es ¿y como cojones se que inductancia tiene esta bobina?

Pues bien, acabo de ver en dangerous prototypes un método súper sencillo para medir inductancias usando arduino, echadle un vistazo y si alguno lo prueba, me contáis.

Arduino: The Documentary

Para los fans de este maravilloso proyecto que es Arduino, aquí os dejo un excelente documental realizado por LABoral Centro de Arte y Creación Industrial (link) y filmado en Madrid, Gijón y Nueva York, que muestra los comienzos y la historia de este peculiar proyecto que cambió todos los esquemas en el mundo de la electrónica para aficionados (y no tan aficionados).

Aquí os dejo el trailer de Arduino: The Documentary.



Podéis encontrar el documental completo en su web: http://arduinothedocumentary.org/

Eclipse + avr-gcc + avrdude

Si estais hasta los mismísimos del cutreIDE de arduino, existe una solución perfecta!

AVR-Eclipse

Es un plugin de eclipse que extiende CDT (el componente de C/C++) y te integra avr-gcc (el compilador libre, el mismo que usa arduino), avrdude (para programar el chip, soporta tb el bootloader de arduino) y eclipse, el IDE de programación preferido por los niños

Para rematar el conjunto, podéis incorporar las librerias arduino a vuestros proyectos escritos en C, pero esto ya lo dejo para otro post :P

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 :)

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.

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:















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.

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:

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

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