ESTOY CONSTRUYENDO UNA WEB NUEVA

Siento no poder actualizar ultimamente el foro. Estoy creando una pagina web para poner todo lo que hay hasta el momento y lo que vaya haciendo mas adelante de modo que, puedo controlar mejor el diseño, contenido y todo lo que tengo que agregar. Ademas le voy a poner un foro (phpbb3) donde podamos publicar mensajes y buscar solucion a cualquier problema que tengamos con este proyecto o con cualquier otro. Tambien tengo en mente agregar un "Wikiproyectos", donde quien quiera pueda publicar sus proyectos sin necesidad de moderacion (estilo wikipedia). Por el momento estoy bastante liado entre la creacion de la web y el trabajo, pero prometo que pronto estará listo todo y podremos terminar con el proyecto, que le queda muy poco, pues lo basico ya está publicado.

Realmente la construccion del controlador midi es simplemente un modulo de multiplexacion para obtener las E/S que se necesitan para los potenciometros y pulsadores (quizas podamos agregar mas cosas, como sensores de distancia, de luz...). Al modulo hay que agregarle cada componente que quedamos usar y por ultimo, a traves del codigo convertir la variacion de cada componente en una canal, nota y volumen.

He encontrado una tienda donde se pueden obtener potenciometros con un 40% de tolerancia, eso si, a unos 3€ cada uno, pero yo desde luego, para mi mesa pienso implementarlos. Estoy a la espera de terminar con la lista de componentes para hacer el pedido. Por el momento no voy a publicar la direccion de la pagina mientras no compruebe que efectivamente la calidad es la necesaria. Cuanto que tenga la lista y el dinero hago el pedido y los pruebo haber que tal. Valen el doble que los potenciometros normales, pero la suavidad, fiabilidad y duracion deben ser bastante mejores.

Un saludo.

4 - AMPLIANDO LOS PINES ANALOGICOS DE ARDUINO (DOS POTENCIOMETROS A TRAVES DE UN MULTIPLEXOR 4051 CON 8 ENTRADAS)

Ufff, ya está listo el tutorial del multiplexor.

NOSOTROS VAMOS A UTILIZAR EN PRINCIPIO UN MULTIPLEXOR 4051 PARA CONVERTIR EL PIN 0 ANALOGICO EN 8 PINES. ESTE NO ES EL LIMITE, EN PRINCIPIO VAMOS A EMPEZAR POR ESTO, UTILIZANDO SOLO 2 ENTRADAS, PERO SI LEES BIEN EL TUTORIAL SABRAS QUE ES MUY SENCILLO CONECTAR 8 POTENCIOMETROS EN UN SOLO PIN. MAS ADELANTE UTILIZAREMOS DE NUEVO 2 POTENCIOMETROS PERO UTILIZANDO 3 MULTIPLEXORES, DE MODO QUE A TRAVES DE 6 BITS PODEMOS CONTROLAR PERFECTAMENTE 64 POTENCIOMETROS. Y POR ULTIMO TERMINANDO CON ESTE TEMA UTILIZAREMOS MULTIPLEXORES DE 16 ENTRADAS Y 4 BITS DE CONTROL CADA UNO PARA LOGRAR LOS 132 PINES QUE YO NECESITO PARA MI MESA DE MEZCLAS MIDI.

POR EL MOMENTO TENEMOS QUE IR POCO A POCO. HOY VOY A SUBIR EL TUTORIAL PARA CONECTAR DOS POTENCIOMETROS A TRAVES DE UN MULTIPLEXOR A UN SOLO PIN ANALOGICO DE ARDUINO. YO CREO QUE NO ES MUY DIFICIL SABER COMO CONECTAR EL RESTO DE POTENCIOMETROS, PERO DE TODOS MODOS, PROXIMAMENTE PONDRE EL CIRCUITO Y CODIGO DE 8 POTENCIOMETROS.

Comenzamos por definir un multiplexor:

Un multiplexor es un circuito integrado (una pastilla con patas) que nos permite utilizar múltiples entradas, seleccionando cada una de ellas a través de unos pines que, en este caso son 3: A, B y C; con los que indicamos cual es la entrada de datos que queremos utilizar.

En este primer caso vamos a utilizar un solo multiplexor para entender su funcionamiento. Tengo que confesar que he tenido que hacer muchas pruebas, aun conociendo este componente mas que de sobra, porque yo en vez de montarlos en una placa utilizo "Multisim", un programa de simulación de circuitos reconocido internacionalmente como uno de los mejores. El caso es que muchas veces lo que montaba no funcionaba bien y después se me metió en la cabeza que teniendo 3 cables para seleccionar las entradas, lo mas que podría hacer es poner 4 multiplexores, con lo que tendría 8x4=32 entradas. Después leí por la red algo de conectar multiplexores en cascada y no conseguía entender como se hace. Estaba hechandome para atrás, porque yo necesito 132 entradas analógicas para potenciometros y pulsadores. De buenas a primera, cuando volví de jugar unas partidas al billar de carambolas para relajarme, se me vino a la cabeza el circuito necesario para poder manejar 9 o mas multiplexores de 16 entradas, con lo que consigo las que necesito e incluso me sobran. Pero eso lo veremos en el siguiente ejercicio, que desde luego, no va a tardar tanto como este. Tenéis que disculparme un poco porque estoy saturado de trabajo y apenas tengo un rato libre. Vamos al lío.

El multiplexor que vamos a utilizar es el HEF4051BP, que proporciona 8 entradas.

Podéis descargar el datasheet en pdf desde aquí: http://pdf1.alldatasheet.com/datasheet-pdf/view/173652/UTC/4051/++043WWFuPPzZ-Jt-++/datasheet.pdf

Está en ingles y en ese documento está toda la información del integrado, aunque quizás no entiendas muchas cosas en el.

Nosotros vamos a seguir con lo nuestro. A la hora de conectar el circuito integrado debemos tener en cuenta que tiene una mueca en uno de los extremos. Esa mueca se utiliza para saber cual es el pin numero 1 del circuito integrado (en adelante solo diré integrado). Podéis ver la numeración de las patillas en el siguiente dibujo:

En el dibujo podemos ver que es cada patilla. Podemos ver que tenemos en la patilla 1 -> X4. Esto significa que esa es la entrada numero 4, de modo que tenemos la siguiente estructura:

Patilla Entrada

13 x0

14 x1

15 x2

12 x3

1 x4

5 x5

2 x6

4 x7

Después tenemos en la patilla 16 -> VDD. Esta patilla tiene que ir siempre a 5 Voltios, porque es la que alimenta al integrado.

Las patillas 6 -> INH, 7 -> VEE, 8 -> VSS serán conectadas a GND o masa.

La patilla 3 -> X es la patilla donde obtenemos el valor dependiendo de la selección que tengamos hecha.

Por ultimo, las patillas 11 -> A, 10, -> B, 9 -> C son las que se utilizan para seleccionar la entrada.

Situarse del siguiente modo: En cada patilla de entrada X0...X7, conectamos el cursor de un potenciometro, es decir, la patilla central. En un extremo conectamos 5V y el otro extremo lo conectamos a masa. Cada potenciometro enviá un valor a una de las 8 entradas y, con A,B,C, que son como interruptores, seleccionamos la entrada que vamos a usar, colocando cada una de estas letras en tensión alta (5V) o tensión baja (Gnd).

Voy a poneros la tabla de verdad a continuación y después os comento lo que significa cada cosa, aunque estoy seguro de que tu mismo puedes entenderlo sin que te lo explique:

|A| |B| |C| |X|

|0| |0| |0| |0|

|0| |0| |1| |4|

|0| |1| |0| |2|

|0| |1| |1| |6|

|1| |0| |0| |1|

|1| |0| |1| |5|

|1| |1| |0| |3|

|1| |1| |1| |7|

A, B y C pueden tener dos estados: 0 y 1. El primero es cuando lo conectamos a GND o masa. Valdrá 1 cuando lo conectemos a 5 Voltios, ¿sencillo no?. Ahora fijate otra vez en la tabla. Si coloco A, B y C a GND o masa le estaría indicando al multiplexor que la entrada que voy a utilizar es la entrada x0.

Ahora tu solo, piensa que combinación seria necesaria para utilizar la entrada x1.

Efectivamente, tendríamos que poner A -> 5V, B -> GND, C -> GND. ¿Lo habrás hecho bien no?, es muy importante que comprendas esto.

En este tutorial vamos a utilizar solamente las entradas X0 y X1. Por esto, voy a poner el circuito final, pero solo con dos entradas, para evitar tener que poner tantos cables que no vamos a utilizar y cargar el dibujo de lineas que acabarían por ser medio incomprensibles. El resto de patillas no las he conectado a ningún sitio, las he dejado sin conectar. Si alguien cree que esto es un error que comente y lo cambio, pero a mi así me va perfecto.

Recordar que cuando un cable pasa por encima de otro se puede observar que hay un arco. De todos modos ningún cable está cruzado con ninguno.

Después tenemos que subir el siguiente código a la placa de arduino:

int bitA = 2;

int bitB = 3;

int bitC = 4;

int analogPin = 0;

int midiChannel0 = 1;

int lastAnalog0 = 0;

int analogSmooth0 = 6;

int midiChannel1 = 1;

int lastAnalog1 = 0;

int analogSmooth1 = 6;

void setup()

{

Serial.begin(115200);

pinMode(bitA,OUTPUT);

pinMode(bitB,OUTPUT);

pinMode(bitC,OUTPUT);

}

void loop()

{

/* CODIGO PARA ENTRADA 0 */

digitalWrite(bitA,LOW);

digitalWrite(bitB,LOW);

digitalWrite(bitC,LOW);

int reading0 = 0;

reading0 = analogRead(analogPin)/8;

if (abs(reading0-lastAnalog0) > analogSmooth0)

{

lastAnalog0 = reading0;

controlChange(midiChannel0,10,reading0);

}

/* CODIGO PARA ENTRADA 1 */

digitalWrite(bitA,HIGH);

digitalWrite(bitB,LOW);

digitalWrite(bitC,LOW);

int reading1 = 0;

reading1 = analogRead(analogPin)/8;

if (abs(reading1-lastAnalog1) > analogSmooth1)

{

lastAnalog1 = reading1;

controlChange(midiChannel1,127,reading1);

}

}

void controlChange(byte channel, byte controller, byte value)

{

midiMsg(channel+0xB0, controller, value);

}

void midiMsg(byte cmd, byte data1, byte data2)

{

Serial.print(cmd, BYTE);

Serial.print(data1, BYTE);

Serial.print(data2, BYTE);

}

RECUERDA, EN EL S2MIDI HAY QUE INDICARLE LA VELOCIDAD EN BAUDIOS, QUE EN ESTE EJEMPLO ESTAMOS PONIENDOLA A 115200.

¿Quillo ke has hesho aki?

Tranquilo, no es complicado.

En las primeras cuatro lineas declaro 3 variables para indicarle a la placa cuales son los pines de A, B y C, que son 2, 3 y 4 (digitales) respectivamente. Después declaro otra variable donde le diré a la placa que el pin 0 (analógico) es donde vamos a colocar el valor de cada potenciometro.

Después vienen otras 6 variables, que ya deberías conocer de anteriores códigos. midiChannel0 para indicar el canal midi donde trabaja el potenciometro 0 (canal 1), lastAnalog0 que almacena el ultimo valor que daba el potenciometro 0 y después analogSmooth0 que es el que usamos para comprobar la diferencia del valor anterior con el valor nuevo y detectar el cambio. Esto mismo lo aplicamos a midiChannel1, lastAnalog1 y analogSmooth1.

Después viene la función setup() en la que indicamos la velocidad de envío de los datos al puerto usb e indicamos a la placa arduino que ponga los pines bitA, bitB y bitC como salida, porque poniéndolos como HIGH o LOW indicaremos si se trata de un 1 o un 0.

Llegamos al loop() y aquí viene lo complicado, aunque no es muy difícil de comprender. las 3 primeras ordenes ponen el pin A, B y C a LOW, o lo que es lo mismo, pone A = 0, B = 0 y C = 0. A continuación tenemos el trozo de código que coge el valor que hay en la variable analogPin (pin analógico 0) y comprueba si ha variado en 6 unidades (según analogSmooth0). Si varia entra dentro de la condición if para poner el nuevo valor a la variable lastAnalog0 y enviar los datos a través de la función controlChange al ordenador.

Si no hubiera una diferencia de 6 unidades se saltaría el if y seguiría con la segunda parte, que no la voy a explicar porque es igual que la primera parte del loop() solo que los nombres de las variables cambian de terminar en 0 a terminar en uno.

Solo diré que en a partir de donde pone /* CODIGO PARA ENTRADA 1 */, en las 3 primeras lineas indicamos a la placa de arduino que ponga A = 1, B = 0 y C = 0, con lo que estaríamos indicando al multiplexor que ahora debe leer la entrada 1, que es donde tenemos conectado el otro potenciometro.

Una vez terminado de hacer todo esto, como siempre, el loop() se repetiría hasta que quitáramos la placa del puerto usb.

Nada mas. Siento haber tardado tantísimo en actualizar. He estado trabajando un tiempo y apenas he tenido un rato para hacer pruebas. El siguiente tutorial no tardara en venir. En el vamos a utilizar 3 multiplexores 4051 de modo que tengamos 64 entradas analógicas. Para ello conectaremos las salidas de 2 de ellos a 2 entradas del tercer multiplexor y utilizaremos 6 opciones para seleccionar la entrada que queramos.

Como siempre os ruego que si hay algún error podéis comentarlo y se corregirá. Ademas, como siempre digo, me vienen bien los comentarios para saber que hay alguien en el otro extremo de mi conexión. Saludos.

MIDI - CAPITULO 3 - ENVIANDO SEÑALES MIDI VARIABLES CON DOS POTENCIOMETROS

Hola de nuevo. He avanzado un poco mas y, por si no se te ocurre como colocar dos potenciómetros, en este ejercicio vamos a llevar la tarea a cabo.

Tengo que comentar que si he tardado tanto en ponerlo es porque yo he tenido problemas a la hora de recibir los datos en el ordenador, y en algunas ocasiones giraba el potenciómetro 0 y cuando veía los datos en el programa s2midi me salía entre medio una nota del potenciómetro 1. En este código que coloco mas adelante no me ha pasado, pero me extraña, porque he modificado varias veces los datos y siempre me pasaba lo mismo. No se, quizás me faltaba algo por cambiar en el código.

Edito: EL MOTIVO POR EL QUE ME SALIA UNA NOTA DEL POTENCIOMETRO 1 ENTRE MEDIO DE LA DEL POTENCIOMETRO 0 Y VICEVERSA, ES DEBIDO A LA TOLERANCIA DEL POTENCIOMETRO.

- ¿QUE QUIERE DECIR? PUES QUE SI EL POTENCIOMETRO TIENE UNA TOLERANCIA DEL 5% SIGNIFICA QUE SU RESISTENCIA PUEDE VARIAR LIGERAMENTE EN CUALQUIER MOMENTO.

- ¿COMO ME AFECTA ESTO? PUES AFECTA PORQUE AL VARIAR LIGERAMENTE CAMBIA EL VALOR Y EL PROGRAMA ENTIENDE QUE HEMOS GIRADO EL POTENCIOMETRO, POR ESO ENVIA ESA NOTA.

- ¿COMO SE PUEDE ARREGLAR? PUES LIGERAMENTE SE PUEDE ARREGLAR AL ESTILO CHAPUZA, VARIANDO EL VALOR DE LAS VARIABLES analogSmoothx = 2; por analogSmoothx = 6; CON ESTO ES MAS DIFICIL DE QUE SALGA ESA NOTA, PERO TIENE UNA DESVENTAJA, TENEMOS QUE GIRAR MAS EL POTENCIOMETRO PARA QUE SE DETECTE EL CAMBIO.

- ¿HAY OTRA SOLUCION? SI, PUEDES GASTARTE MAS DINERO EN COMPRAR POTENCIOMETROS DE MAS CALIDAD, O PUEDES ESPERAR A QUE ENCUENTRE UN CODIGO QUE EVITE ESTO, PERO DE MOMENTO NO SE ME OCURRE NINGUNO.

ES TODO.

Bien, la colocación de dos potenciómetros es igual que cuando colocamos uno, solo que la patilla central del segundo potenciómetro tiene que ir a 1 analógico.

Después subimos el siguiente código a la placa y listo.

int midiChannel0 = 1;

int analogPin0 = 0;

int lastAnalog0 = 0;

int analogSmooth0 = 2;

int midiChannel1 = 1;

int analogPin1 = 1;

int lastAnalog1 = 0;

int analogSmooth1 = 2;

void setup()

{

Serial.begin(31250);

}

void loop()

{

Potenciometro0();

Potenciometro1();

}

void Potenciometro0()

{

int reading0 = 0;

reading0 = analogRead(analogPin0)/8;

if (abs(reading0-lastAnalog0) > analogSmooth0)

{

lastAnalog0 = reading0;

controlChange(midiChannel0,10,reading0);

}

}

void Potenciometro1()

{

int reading1 = 0;

reading1 = analogRead(analogPin1)/8;

if (abs(reading1-lastAnalog1) > analogSmooth1)

{

lastAnalog1 = reading1;

controlChange(midiChannel1,127,reading1);

}

}

void controlChange(byte channel, byte controller, byte value)

{

midiMsg(channel+0xB0, controller, value);

}

void midiMsg(byte cmd, byte data1, byte data2)

{

Serial.print(cmd, BYTE);

Serial.print(data1, BYTE);

Serial.print(data2, BYTE);

}

Cualquier programador normalito sabrá que este código se puede reducir mucho, pero después de lo que he sudado para llegar aquí no tengo muchas ganas de ponerme a recortarlo. Se que es muy importante recortar código para que tengamos espacio suficiente en la placa donde meterlo, pero por el momento no tengo ganas de complicarme mas la existencia. Por suerte, la versión duemilanove con el ATMEGA 328 tiene mucho espacio, y Serra cuestión de tiempo que tengamos placas con mucho mas donde almacenar, de hecho, ya hay placas arduino con muchísimo mas espacio y mucha mas velocidad de procesamiento, pero no podemos comprarnos una cada dos por tres.

Seguimos. He puesto en color rojo el código que forma parte del potenciómetro 0 (que es el 1º potenciómetro) y en verde el del potenciómetro 1 (que es el 2º potenciómetro). El resto del código es común a los dos y creo que con esto deberías saber como conectar mas de dos.

Ahora pasamos a describir el código.

Como puedes observar, al principio del código tenemos las cuatro variables que son del potenciómetro 0 y después las otras cuatro que son del potenciómetro 1.

A continuación configuramos el puerto serial a 31250.

Seguimos con el código y entramos en la función loop(), donde llamamos primero a la función Potenciometro0(). Una vez allí leemos el potenciómetro y si lo hemos variado llamamos a la función controlChange y le pasamos el canal (1), la nota (10) y por ultimo el valor del potenciómetro. La función controlChange() hace una pequeña modificación de los datos recibidos y llama a midiMsg() pasándole los datos y esta ultima coloca los 3 datos en el puerto usb uno detrás de otro. Aquí es donde S2Midi entra en acción, convirtiendo los 3 datos en señal midi y enviándolos al puerto midi virtual.

(En el código del articulo anterior olvide comentaros que la división entre 8 que se hace en la línea "reading0 = analogRead(analogPin0)/8;" es para convertir el valor del potenciómetro en un numero entre 0 y 127, es decir, en el volumen de la nota)

¿Por donde íbamos? Si, ya me acuerdo, habíamos terminado de comentar lo que pasaba si se había movido el potenciómetro 0. Si no lo hubiéramos movido sencillamente hubiéramos vuelto a la función loop() y seguiríamos por la segunda instrucción, que llama a la función Potenciometro1() y hace exactamente lo mismo que en la anterior, es decir, si varia, llama a controlChange pasándole los datos, después controlChange llama a midiMsg tras hacer una modificación de los datos y esta por ultimo envía las tres señales al puerto usb.

Todo esto sucede a una velocidad bastante alta y se estaría ejecutando constantemente para comprobar si hay algún cambio en los potenciómetros.

Por ultimo quiero indicaros que en este código estamos mandando los datos del siguiente modo:

Potenciometro0 -- Canal 1 -- Nota 10 -- Valor del potenciometro0/8

Potenciometro1 -- Canal 1 -- Nota 127 -- Valor del potenciometro1/8

Por esto, podemos observar que en la línea controlChange(midiChannel0,10,reading0); de la función Potenciometro0() estamos mandando la nota 10, en cambio, en la de la función Potenciometro1() mandamos la nota 127.

Es todo por hoy. Saludos y por favor, si alguien me lee que me deje un comentario, aunque sea un saludo o algo para saber que no estoy escribiendo para que nadie me lea :D

MIDI - CAPÍTULO 2 - ENVIANDO SEÑALES MIDI VARIABLES CON UN POTENCÍOMETRO

Hoy avanzaremos un poco mas en el tema del midi, aunque aun no puedo explicaros como funciona el lenguaje, al menos, voy a poneros un ejemplo muy sencillo de cómo mover una resistencia variable, o mejor dicho, un potenciómetro y que al girarlo varie el volumen de una nota midi determinada. Por falta de tiempo no puedo poneros las imágenes de como funciona esto en un programa, pero podéis verlo en vuestra pantalla cuando ejecutéis S2Midi y variéis el potenciómetro.

Para poder seguir este sencillo tutorial es necesario tener instalado el entorno de programación de arduino, los drivers de la placa, entender el entorno y saber como subir un código a la placa y por ultimo, haber seguido el tutorial anterior a este con el que tendrás configurado tu ordenador para poder recibir mensajes midi por el puerto usb de arduino. Todo esto ha sido explicado ya, por lo que yo voy a continuar adelante. Si tienes dificultades para continuar mira los tutoriales anteriores, que los encontraras a la izquierda de este texto, en un menú de opciones que coloqué con todos los tutoriales, noticias, descargas y demás.

Bien, comenzamos por explicar el potenciómetro:

Un potenciómetro es un resistor al que se le puede variar su resistencia, es decir, permite controlar la intensidad de corriente que circula a través de ella. Tienen 3 patillas, dos que son las de los extremos y la central que se llama cursor.

La conexión de nuestro circuito es muy sencilla, conectaremos un extremo del potenciómetro de 1 Mega Ohmio (tiene que ser exactamente 1 MO, no conectes ninguno de otro valor) a 5V, el que está en la parte de los pines analógicos, la patilla central o cursor a 0 analógico y la otra patilla del extremo a GND (masa). Quedaría así:

En este primer ejemplo solo conectamos 1 potenciómetro de 1 Mega Ohmio, por lo que solo podremos mover una opción en resolume.

Bien, una vez que tenemos montado el circuito hay que cargar el código del programa en la placa arduino. Es el siguiente:

int midiChannel0 = 1;

int analogPin0 = 0;

int lastAnalog0 = 0;

int analogSmooth0 = 2;

void setup()

{

Serial.begin(31250);

}

void loop()

{

Potenciometro0();

}

void Potenciometro0()

{

int reading0 = 0;

reading0 = analogRead(analogPin0)/8;

if (abs(reading0-lastAnalog0) > analogSmooth0)

{

lastAnalog0 = reading0;

controlChange(midiChannel0,10,reading0);

}

}

void controlChange(byte channel, byte controller, byte value)

{

midiMsg(channel+0xB0, controller, value);

}

void midiMsg(byte cmd, byte data1, byte data2)

{

Serial.print(cmd, BYTE);

Serial.print(data1, BYTE);

Serial.print(data2, BYTE);

}

Básicamente en nuestro programa hemos declarado al principio el canal (1), el pin en el que leemos el valor para comprobar si cambia el potenciómetro (0), una variable que almacena el ultimo valor que tuvo el potenciómetro (lastAnalog0) y la ultima que es utilizada durante la comparación para comprobar que la diferencia entre el valor anterior y el actual sea mayor de 2 (analogSmooth).

Después configuramos la velocidad de envió a 31250 y mas adelante, en la función loop() llamamos a otra función que he creado yo llamada Potenciometro0().

Dentro de esta se comprueba si el valor del potenciómetro ha variado, si es así se llama a la función controlChange() y se le pasa los datos Canal (1), Nota (10) y valor (que depende del valor que indique el potenciómetro).

Bien, pero ¿como se que esto funciona?. Pues muy sencillo, conectas el montaje como he indicado, cargas el código desde el entorno de programación de arduino, sin desconectar el cable cierras el entorno, cargas el S2Midi y le indicas el puerto y la velocidad (si no está 31250 en la lista se lo puedes poner tu con tu teclado) y le das a Start. Cuando varíes el potenciómetro veras que a la izquierda te muestra la información de lo que va leyendo en el puerto.

En el programa que yo suelo utilizar, que es Resolume 2.3, ahora tendría que abrirlo e irme a la configuración, a la pestaña del mapeo midi y hacer doble clic en la lista para configurar por ejemplo el control de la opacidad de la capa 1. Al hacer doble clic en el y mover el potenciómetro ya lo tendría configurado y tras cerrar la configuración podría mover la capa con el potenciómetro en vez de con el ratón.

Saludos y perdonar que no pueda poner una imagen ahora mismo, pero tengo poquísimo tiempo últimamente.

MIDI - CAPITULO 1 - INSTALACIÓN DEL SOFTWARE NECESARIO PARA ARDUINO Y MIDI

Este tutorial es para aquellas personas que no tengan puertos midi (de los redondos). Nosotros utilizaremos el mismo puerto Usb que utiliza arduino para enviar y recibir datos midi.

Para ello usaremos dos programas, uno es MidiYoke, que crea puertos midi virtuales y otro que se llama S2Midi que sirve para convertir los datos serie que se envia por el puerto usb a midi y enviarlos a MidiYoke.

En este primer capítulo vamos a instalar el software necesario para poder enviar señales midi al ordenador desde el arduino. Gracias a estas señales, podemos controlar software a través de arduino.

La instalación de este software puede parecer a primera vista muy larga, pero realmente no se tarda mucho y no tiene mayor complicación que descargar el software, instalarlo y configurarlo.

Vamos a empezar por el primer programa que debemos instalar. Se llama MidiYoke. Para descargarlo nos vamos a nuestro navegador y tecleamos: www.midiox.com

Cuando cargue la pagina pulsamos el enlace “MIDI Yoke” y cargará el frame con todo lo que hay en la página sobre el programa, desde noticias, hasta la instalación en windows 3.1, que ya es antigüito.

Nosotros vamos haremos clic en “Download” y nos moverá un poco más abajo dentro de la misma página donde podremos descargar el programa para windows xp. Nosotros vamos a descargar la versión que pone “midiyokesetup.msi”, porque la instalación es mucho más sencilla que si lo descargamos en formato zip, donde tendremos que instalarlo a mano y no me apetece, la verdad. Fijaros en la siguiente imagen, he puesto en rojo en el caso de Internet Explorer donde podemos ver el archivo que es con extensión msi.

Al hacer clic en el enlace nos preguntará qué queremos hacer y le diremos “Ejecutar”, o al menos, eso es lo que voy a hacer yo, porque una vez que se instale no quiero el programa de instalación para nada.

Cuando lo descargue temporalmente nos preguntara si estamos seguros de querer ejecutarlo y le volvemos a decir que si, ejecutar.

Seguimos los pasos del asistente, en esta primera pantalla pulsamos “next”

En la siguiente volvemos a hacer clic en “next”.

Comenzará la instalación, solo nos queda esperar a que termine de copiar los archivos.

En la siguiente ventana nos dice que tenemos que reiniciar el equipo para que los cambios surtan efecto, desde luego lleva razón, pero nosotros antes de reiniciar vamos a configurar el programa para evitar tener que reiniciar dos veces. Pulsamos “Next”.

Ya hemos terminado la instalación de MidiYoke, así que pulsamos “Close” pero no vamos a reiniciar nuestra maquina todavía.

Vamos a abrir la ventana del panel de control, que normalmente está en el menú inicio/panel de control.

Ahora hacemos doble clic sobre MyokeNT y se nos abre la ventana de configuración del programita.

Nosotros vamos a cambiar la opción “Number of Ports” que por defecto está en 8 y le marcaremos en la lista el 2, para no tener tantísimos puertos.

Por último pulsamos “Ok” y procedemos a reiniciar nuestra maquina. Cuando termine de reiniciar vuelvo. Hasta ahora.

Bien, ya tenemos hecho lo mas difícil de este asunto. Ahora vamos a seguir con la segunda aplicación que necesitamos, se llama S2MIDI y es un programa muy sencillo de instalar, solo hay que descomprimir el archivo en una carpeta de nuestro disco duro y darle doble clic al ejecutable. Comenzamos.

Para descargar este programa vamos a ir a: http://code.google.com/s2midi/downloads/list

Hacemos clic en la última versión que hay en la pagina, que actualmente es la 1.01 y nos saldrá el cuadro de dialogo de “Descarga de archivo”, donde yo pulsare “Abrir” para que se abra automáticamente el archivo cuando se descargue y se borre cuando termine.

Como veis en la siguiente imagen se ha abierto con WinRar. Ahora pulsaré en “Extraer en” y se abrirá el cuadro donde indicarle la ruta donde quiero descomprimirlo. Yo lo voy a poner sencillamente en C:\S2midi

Solo queda pulsar “Aceptar” y comenzara a descomprimirlo. Por último ya solo me queda ir a la carpeta nueva que se ha creado en C: y explorar el contenido. Por supuesto ya puedo cerrar winrar.

Por fin, ahora, por ultimo tenemos que comprobar que todo funciona bien. En mi caso, el puerto que utiliza arduino es el COM3, por lo que debemos tener en cuenta nuestro puerto a la hora de configurar S2Midi. La configuración vamos a verla dentro de un momento, primero voy a cargar un código sencillo en arduino. Como supongo que eso lo sabrás hacer antes de haber hecho todo esto voy a saltarme los pasos. Si aun no sabes cómo se hace esto deberías mirar en este blog, porque no hace mucho que puse las instrucciones. A la izquierda hay un listado de enlaces donde podéis ver todas las entradas del blog, ordenadas, puedes usarlo para localizar el articulo 4 – CONFIGURACIÓN Y DESCRIPCIÓN DEL ENTORNO.

El código es el siguiente:

void setup()

{

Serial.begin(31250);

}

void loop()

{

noteOn(0x90,15,63);

delay(5000);

}

void noteOn(char cmd, char data1, char data2)

{

Serial.print(cmd,BYTE);

Serial.print(data1,BYTE);

Serial.print(data2,BYTE);

}

Es corto ¿verdad?, mejor, aunque por hoy no voy a explicar lo que hace, porque el fin de esta entrada es configurar el ordenador para que pueda trabajar con midi, no para que aprendamos a trabajar con midi :D

Perfecto, una vez que tenemos cargado el programa en la placa midi, sin desconectar el cable de arduino para nada, simplemente CERRAMOS EL ENTORNO DE PROGRAMACION DE ARDUINO y abrimos s2midi, el cual deberemos configurar como en la siguiente imagen, salvo por el puerto COMx, que tendrás que poner el COMx donde está conectado arduino. Esto puede verse del siguiente modo:

Vamos al menú inicio, panel de control. Doble clic en Sistema, Abrimos la pestaña Hardware y le damos al botón que pone Administrador de dispositivos. En esa ventana tenemos que buscar Puertos (Com &LPT) y expandirlo para ver cuál es el puerto de arduino. También podemos verlo en el entorno de programación de arduino, vamos al menú Tools y en el submenú Serial Ports vemos cual es el que tenemos marcado para enviar los datos.

Ahora muestro la pantalla de S2Midi como la tengo configurada yo.

Ahora solo nos queda pulsar el botón “Start” para ver a la izquierda que salen las notas midi que estamos mandando desde arduino.

Debemos tener en cuenta los siguientes aspectos esenciales:

• El entorno de programación de arduino TIENE que estar cerrado para que S2Midi pueda acceder al puerto.
• El puerto COM debe de estar bien puesto.
• El Baud Rate debe de ser el mismo que el que aparece en el código, que en este caso es 31250.
• Lo último, y lo que me ha hecho perder muchísimo tiempo. Cuidado si utilizas dos o más ordenadores, porque yo estoy usando dos a la vez y le cargaba el código desde uno que trabaja con el puerto COM4 y lo conectaba a otro ordenador, que trabaja con el COM3 y no hacía nada, de casualidad, me he dado cuenta que cuando lo conectaba en el segundo ordenador el led de la placa no hacía nada, y era porque de un ordenador a otro se borraba la información que habia grabado en arduino, por lo que tuve que escribir el código otra vez en el mismo ordenador donde hago las practicas y entonces funcionó. Era por eso, porque al conectarlo de un ordenador a otro pierde la información. ¿Qué raro no?.

En fin, esto es todo por hoy, he estado un tiempo desconectado porque tengo muchas cosas encima, de hecho, ahora tendría que estar arreglándole un ordenador a una amiga y en vez de eso estoy aquí haciendo un tutorial, es para matarme a palos. Pues nada, espero que os haya gustado este tutorial y sobre todo que os sea útil. Próximamente empezaremos a sacarle partido a esto. Os cuento mi interés en este tema, tengo ganas de fabricarme un controlador midi para poder controlar programas de Vj sin tener que usar el ratón, así que desde aquí aprovecho para mandarle un saludo a la comunidad de http://www.vjspain.com/ que son muy buena gente.

Nos vemos en el próximo capitulo, si alguien tiene algún problema o quiere solo saludar, los comentarios están abiertos para todo el mundo. Además, con eso se que al menos una persona me ha leído jajaja. Nos vemos en el próximo tutorial.

PROYECTOS INTERESANTES - AIRPIANO, TOCANDO EL PIANO EN EL AIRE.

AirPiano es una innovadora interfaz musical que permite reproducir y controlar instrumentos musicales basados en software simplemente moviendo las manos en el aire.

AirPiano está formado por una matriz de teclas y faders, a los que se les ha asignado mensajes midi listos para ser activados. La duración de una nota depende del tiempo que esté colocada la mano por encima del sensor (supongo que serán sensores de distancia). La pulsación de cada tecla se confirma por unos led que hay bajo la superficie.

El software de AirPiano permite una configuración fácil, cargando y guardando presets.

AirPiano está todavía en su fase de prototipo. AirPiano tiene una patente provisional en E.E.U.U. (Numero 60/989/986).

Os dejo dos videos, en el primero está tocando el piano simplemente y en el segundo está controlando Ableton Live. Saludos.

5 - EL PRIMER EJERCICIO O EJEMPLO

Hoy vamos a realizar nuestro primer ejercicio con la placa arduino. Me gustaría recordaros que estoy utilizando arduino Duemilanove, por lo que debéis tener cuidado de que los pines de vuestra placa sean los mismos.

Para poder comprender mejor este ejercicio, y todos los que vengan, explicare primero los elementos electrónicos que vamos a utilizar, como se conectan y después por ultimo indicare el código o códigos. En este primer ejemplo voy a escribir varios códigos que funcionan sobre el mismo circuito.

En muchos ejemplos que hay por la red, cuando escriben el código fuente suelen poner comentarios del siguiente modo:

Instrucción //comentario

A partir de las dos barras hay un comentario, es decir, una aclaración que a la hora de subir el código a la placa no es tenida en cuenta, por lo tanto no ocupara espacio. En mis ejemplos no voy a utilizar esas barras, porque estas indican que se trata de un comentario de una sola línea, por lo que al copiar y pegar un código de una web a otra puede darse el caso de que sin querer, ese comentario pase a otra línea y nos volvamos locos buscando el error.

Por ello, si pongo algún comentario lo pondré del siguiente modo:

Instrucción /* comentario */

La diferencia de este tipo de comentario a los otros radica en lo siguiente. El comentario empieza a partir de /* y no finaliza hasta que se encuentre con */, por lo que podemos escribir el comentario en 80 líneas si queremos, ya que hasta que no se encuentre con */ el compilador pensará que es un comentario y no lo tendrá en cuenta.

Aclarado esto vamos a comenzar con nuestro primer ejercicio. Solo vamos a necesitar los siguientes elementos:

• Placa de arduino con su cable Usb.

• 1 Diodo Led (da igual rojo, azul, verde, rosa.., mientras sea un led de dos patillas no habrá problema)

• El entorno de arduino debidamente configurado.

Vamos a ver lo que es un diodo led.

Un led es un diodo que emite luz cuando la polarización es directa, es decir, cuando se encuentra conectado a una corriente eléctrica que circula del polo positivo al polo negativo. Para poder conectarlo debemos saber cual es el polo positivo y cual el negativo.

El polo positivo es la patilla larga, mientras que el negativo es la patilla corta.

Si las dos patillas son aproximadamente del mismo tamaño porque has rescatado un led de algún aparato, puedes conocer las distintas patillas gracias a un corte que suelen tener en la parte que emite la luz, como podéis ver en la siguiente foto. La patilla que esta en ese lado es la patilla corta, es decir, el polo negativo y, por contra, la otra es el polo positivo.

La patilla positiva se conectara a la fuente eléctrica que lo alimentará, mientras que la negativa se conectará a masa, que en la placa arduino es la que pone GND.

Mas claro todavía, conectamos al pin 13 digital la patilla larga (+) y al GND que esta justo al lado (al menos en Duemilanove) la patilla corta (-).

Puede ser que el ejercicio no te funcione porque alguna de las patillas del led no haga un buen contacto, ya que son muy finas (o porque el led este estropeado). Te recomiendo que utilices una placa protoboar y unos cables para conectar los pines con el led que coloques en la placa de practicas.

Esto es una placa protoboard.

Este es el modo de conectar arduino, el led y la placa protoboard.

Ahora vamos a comenzar con la parte del código. Todo esto lo hemos hecho sin conectar la placa al ordenador, y seguiremos así de momento hasta que hayamos terminado con el código y estemos listos para darle al botón de “Upload to I/O Board”.

El código es bastante sencillo. Recomiendo copiarlo a mano en vez de usar copiar y pegar, porque así aprenderás mejor el lenguaje.

Una cosa muy importante: el entorno de arduino es “case sensitive”, o lo que es lo mismo, diferencia entre mayúsculas y minúsculas, por lo que las palabras “aa”, “Aa”, “aA” y “AA” son completamente diferentes y no tienen nada que ver unas con las otras. Si declaramos una variable como en nuestro código llamada “ledPin” y mas abajo nos referimos a ella como “ledpin” obtendremos algún error o el programa no funcionara como nosotros queremos, por lo que debemos tener mucho cuidado con las mayúsculas y minúsculas.

int ledPin = 13;

void setup()

{

pinMode(ledPin, OUTPUT);

}

void loop()

{

digitalWrite(ledPin, HIGH);

delay(500);

digitalWrite(ledPin, LOW);

delay(500);

}

En la primera línea declaramos una variable llamada ledPin. Una variable es un lugar donde se almacena un valor, ya sea de tipo numérico (integer) o de otra clase. En nuestro código hemos almacenado el valor 13, que es el pin de la placa arduino donde tenemos conectado nuestro led y la hemos declarado de tipo integer, por ello hemos puesto el "int" delante. El ; al final se utiliza para indicar al compilador el final de una instrucción.

La siguiente línea inicia una función. Una función es un conjunto de instrucciones. La función "void setup()" se utiliza para preconfigurar la placa de arduino. Todas las instrucciones de una función se encierran entre la llave { y }.

Continuamos, entre esas dos llaves hay una orden que le dice a arduino que configure el pin 13 como salida. Creo que no es muy difícil de ver, recuerda que al principio habíamos creado una variable llamada ledPin y le habíamos asignado el numero 13, que es el pin de salida.

Después de esta función tenemos otra función que es obligatoria, la función "void loop()". Las instrucciones de esta función se repetirán constantemente.

La primera instrucción le indica que escriba en el pin 13 (variable ledPin) un valor alto, por lo que la placa pondrá tensión en dicho pin.

La segunda instrucción le indica que espere durante 500 milisegundos. 1 segundo tiene 1000 milisegundos, por lo que 500 milisegundos son medio segundo.

Mientras tanto, ese medio segundo el led permanece encendido, porque en el pin 13 sigue habiendo una tensión.

En la siguiente le dice que escriba en el pin 13 un valor bajo, por lo que la placa quitara la tensión del pin.

A continuación la otra instrucción le indica que permanezca así durante otro medio segundo.

Bien, ahora se han terminado las instrucciones, por lo que arduino vuelve a repetir el código de la función "void loop()", es decir, ahora volvería a poner un valor alto, esperaría medio segundo, pondría un valor bajo, esperaría medio segundo, volvería a repetir y así hasta que desconectemos el cable del puerto Usb.

En fin, este es nuestro primer ejemplo, el clásico de toda la vida. Como añadido, voy a modificar un poco el código, solo los tiempos, para que no sea exactamente el mismo ejemplo que enseñan en todos los sitios. Probar el siguiente.

int ledPin = 13;

void setup()

{

pinMode(ledPin, OUTPUT);

}

void loop()

{

digitalWrite(ledPin, HIGH);

delay(500);

digitalWrite(ledPin, LOW);

delay(500);

digitalWrite(ledPin, HIGH);

delay(1000);

digitalWrite(ledPin, LOW);

delay(1000);

digitalWrite(ledPin, HIGH);

delay(500);

digitalWrite(ledPin, LOW);

delay(500);

digitalWrite(ledPin, HIGH);

delay(250);

digitalWrite(ledPin, LOW);

delay(250);

digitalWrite(ledPin, HIGH);

delay(100);

digitalWrite(ledPin, LOW);

delay(100);

digitalWrite(ledPin, HIGH);

delay(100);

digitalWrite(ledPin, LOW);

delay(100);

digitalWrite(ledPin, HIGH);

delay(100);

digitalWrite(ledPin, LOW);

delay(100);

digitalWrite(ledPin, HIGH);

delay(100);

digitalWrite(ledPin, LOW);

delay(100);

}

En fin, esto es todo por hoy, estoy pensando en que podemos hacer en el próximo ejemplo. Nos vemos.

4 - CONFIGURACIÓN Y DESCRIPCIÓN DEL ENTORNO

Para poder trabajar con arduino debemos configurar el entorno de programación. Es muy sencillo, solo tenemos que ir al menú “Tools”, ponernos encima de “Board” y en el siguiente submenú seleccionar nuestra placa. n mi caso tengo marcada “Arduino Duemilanove w/ ATmega328”. Dependiendo de la que tengáis vosotros/as deberéis marcar una u otra.

Nada mas, con esto no creo que tengáis ningún problema a la hora de subir, pero si os da algún error publicarlo en los comentarios y vemos lo que puede estar pasando.

Ahora vamos a pasar a describir lo que mas se utiliza en el entorno de programación.

• Comenzamos por arriba del todo de la imagen y tenemos la barra de titulo, que en la imagen pone “Arduino – 0015”. Nos indica que estamos usando la versión 0015 del entorno de programación.

• Debajo de esta tenemos la barra de menús, donde podemos ver los clásicos menús que suelen tener los programas.

El menú "File" tiene las siguientes opciones:

• New: crea un espacio de trabajo nuevo. Si tenias algún código escrito te preguntara si deseas guardarlo. Aparece en la parte inferior de la pantalla un campo en amarillo con 3 opciones. Si abriste un código y no habías cambiado nada ni siquiera te preguntara.

• Sketchbook: muestra a su vez los documentos recientes, la opción "Open" para abrir algún código que tengamos escrito y "Examples", que contiene un submenú en el que encontraremos los ejemplos que trae el programa.

• Save: guarda el código que has escrito. Debemos tener en cuenta que el programa guarda tus códigos en Mis Documentos/Arduino/… por lo que si le das a “Save” no te preguntará el nombre del proyecto, lo guarda con el nombre que el le asigna, que no es al azar. En la imagen que puse un poco mas arriba podéis ver que mi proyecto se llama “sketch_090627a”, pero ¿Por qué ese nombre?, fijaros bien, es la fecha de hoy 27/06/09 al revés, porque en ingles se pone primero el año, después el numero de mes y por ultimo el día. ¿Y la letra?, pues lógicamente, la letra “a” es porque es el primer código que he guardado hoy. Si le doy a guardar, cierro el programa y lo vuelvo a abrir, el nombre que me aparece es “sketch_090627b”.

• Save as...: guarda el código que has escrito, pero a diferencia del anterior, este te permite asignarle un nombre y una ubicación.

• Upload to I/O Borrad: sube el código a la placa arduino.

• Page Setup: configura la página para imprimir.

• Print: imprime tu código.

• Preferentes: Te permite modificar algunas preferencias, aunque no vamos a verlas porque por el momento tenemos solo opción de seleccionar donde guardar los proyectos y poco mas.

• Quit: Cierra el programa.

El menú "Edit" tiene las siguientes opciones:

• Undo: Deshacer. Te permite volver atrás si has modificado algo. Seguramente tenga un límite.

• Redo: Rehacer una acción (Undo).

• Cut: Cortar. Almacena el código que tengas seleccionado en el portapapeles para pegarlo en otro lugar y borra el código del programa, por eso es Cortar.

• Copy: Copiar. Almacena el código que tengas seleccionado en el portapapeles para pegarlo en otro lugar, pero no borra ese código del programa.

• Paste: Pega un código que hayas copiado o cortado de otro lugar, como un sitio web, este blog o cualquier otro programa, como bloc de notas, Word...

• Select All: Selecciona todo el código.

• Find...: Busca una palabra en el código.

• Find Next: Vuelve a buscar la palabra que indicaste con “Find…” mas abajo en el código.

El menú "Sketch" tiene las siguientes opciones:

• Verify/Compile: Verifica el código para evitar errores. Se debe hacer antes de subirlo a la placa arduino.

• Stop: De momento no vamos a utilizarlo para nada, porque el stop sirve para detener el monitor de datos por serie, que tardaremos en utilizar. Mas abajo comento para que sirve dicha utilidad.

• Import Library: Sirve para importar librerías externas. Prácticamente nos ahorra escribirlas, porque si pulsas en una de ellas lo único que hace es escribir una línea en el espacio de trabajo. Yo he pulsado una y me sale: “#include ”, con lo que me ahorro escribirlo.

• Show Sketch Fólder: Abre una ventana con la ruta donde está el fichero que estas editando o creando.

• Add File...: Abre otro archivo al lado del que estas creando. De momento no le veo mas utilidad que la de poder trabajar con dos códigos a la vez. Si alguien sabe alguna otra que me lo diga y lo pongo por aquí.

El menú "Tools" tiene las siguientes opciones:

• Auto Format: Sinceramente, todavía no he conseguido que haga nada.

• Copy for Forum: Copia el código seleccionado para pegarlos en foros con etiquetas [quote] y otras para darle el estilo a la hora de ponerlo en algún foro.

• Archive Sketch: Genera un fichero comprimido con la carpeta y el código dentro de ella.

• Board: Sirve para indicarle al programa con que placa estas trabajando.

• Serial Port: Si salen varios puertos aquí deberías indicarle cual es el que esta utilizando tu placa de arduino.

• Burn Bootloader: Sirve para subir el bootloader a la placa arduino. Por el momento no lo he probado nunca, y la verdad, espero no tener que hacerlo.

El menú "Help" simplemente contiene un montón de ayuda interesante, pero no voy a detallar que es cada opción. Recomiendo que la miréis una a una. Básicamente está la información que hay en la pagina web del proyecto, pero en vez de verla online la veis sin conexión, ya que está almacenada en el disco duro.

Siguiendo un poco mas abajo tenemos la barra de herramientas. Hacen exactamente lo mismo que las que estan en el menú, por lo que no voy a volver a describirlas, salvo dos. De izquierda a derecha tenemos:

• Play, que en realidad es Verify/Compile.

• Stop

• New

• Open

• Save

• Upload to I/O Board

• Serial Monitor: esta herramienta sirve para ver los datos que arduino envía al ordenador por el puerto usb o por las patillas TX y RX. Por el momento no vamos a utilizarlo, pero para que lo entendáis mejor os comento: Con arduino duemilanove se pueden enviar datos de tipo “Serie” al ordenador, por el puerto Usb. Puedo escribir un código en el que diga que cuando pulse un botón envié la cadena “Hola” al ordenador u otro tipo de datos. Estos datos se envían a una determinada velocidad que se expresa en “Baudios”. De todos modos no voy a explicar mas ahora mismo porque es muy pronto y ese tema es para hablar largo y tendido.

• A la derecha del todo hay una pequeña flecha que abre un submenú en el que podemos crear una nueva pestaña de código (New Tab), renombrarla (Rename), borrarla (Delete), esconder (Hide), hacer visible (Unhide), movernos a la anterior (Previous Tab), ir a la siguiente (Next Tab) y finalmente ir de una a otra pulsando sobre ella.

Vamos a ver que es lo que sucede con el tema de las pestañas paso por paso.

Primero vamos a ir a la carpeta “Arduino” que se ha creado en mis documentos cuando abriste el programa por primera vez. En mi caso la tengo vacía porque he quitado todo lo que tenia para hacer este ejemplo.

Una vez que vemos que está vacía abrimos el entorno de programación de arduino y nos fijamos en el nombre que le ha dado.

Volvemos a la carpeta de arduino que está en mis documentos y vemos que ha creado una carpeta con el mismo nombre que el que aparece en el entorno de programación, y que a su vez ha creado un fichero dentro de esta carpeta con el mismo nombre y la extensión .pde.

Si ahora cerramos el programa sin escribir nada, automáticamente la carpeta se borra.

Si le damos a “Save” sin tener nada escrito también se borra.

Si escribimos algo y cerramos sin darle a “Save” el programa nos preguntara si queremos guardar los cambios.

Si escribimos algo y sin darle a “Save” lo borramos y le damos a cerrar también nos preguntará si queremos guardar los cambios.

Hasta aquí todo mas o menos bien ¿no?.

Ahora vamos a ver otra cosa. Como hemos podido ver en la imagen anterior, arduino nos había creado una carpeta con un archivo .pde, porque solo teníamos una pestaña.

Si nos vamos al botón que comenté antes, que está a la derecha del todo y tiene pintada una flecha hacia la derecha, se desplegara un submenú con la opción “New tab”, hacemos clic ahí.

En la parte inferior, con fondo amarillo, nos preguntara el nombre que queremos darle a la pestaña.

Le ponemos un nombre y pulsamos ok. Ahora vemos que tenemos dos pestañas, la que el programa creó al principio y la que nosotros acabamos de crear.

Si vamos a la carpeta que tenemos en mis documentos podemos ver que el archivo se ha creado dentro de la misma carpeta. Los dos archivos se han creado en la misma carpeta porque están dentro del mismo proyecto.

Con la pestaña2 pasa lo mismo que comentaba mas arriba, si no le das a “save se borra”…

Teniendo marcada una de las dos pestañas puedes hacer con ella todo lo que te indica el submenú, pues borrarla, eliminarla, renombrarla…

Por último, que ya va siendo hora hoy, comentar que si cierras el entorno de arduino y haces clic sobre uno de los dos archivos, se abren ambos, cada uno en una pestaña.

Recordaros que se admiten comentarios. Hasta la próxima.

3 - INSTALACION DEL ENTORNO Y LA PLACA

Para poder trabajar con arduino lo primero de todo es instalar el entorno de programación y la placa.

Esta guía ha sido hecha con un PC portátil Dell Inspiron 510m trabajando con Windows XP actualizado con Service Pack 2. Puede que las ventanas no sean exactamente iguales en otras versiones, pero la diferencia no debe de ser muy grande. Arduino puede trabajar sobre Windows, Mac y Linux. Mi sistema operativo es Windows xp, quizás mas adelante me anime a instalar alguna versión de Linux y haga otra guía, pero de momento estoy escaso de tiempo. Pido perdón a la comunidad de Linux y de Mac por no poder haberla hecho para ellos, pero seguro que si le preguntáis a Google el os pueda decir como instalar arduino en estos sistemas.

Lo primero y más importante: NO CONECTES TODAVIA LA PLACA ARDUINO AL PUERTO USB.

Empezamos por descargar Java Runtime Enviroment desde la siguiente página:

http://java.sun.com/j2se/1.4.2/download.html

puede que, con el tiempo, la versión 1.4.2 sea antigua, por lo que no creo que tengas problemas si descargas una versión superior. Es más, si la hay, hasta te recomendaría instalarla.

Esta es la imagen de la página de descarga. Hacemos clic en ese enlace.

Tenemos que rellenar como mínimo los campos marcados con asterisco y pulsar submit.

Os mostrara una pantalla indicando que os han enviado un email con el enlace de la descarga (vaya coñazo), así que no os molestéis en poner los datos falsos como yo porque sino vais a tener que volver a escribirlos.

Ahora solo tenéis que entrar en vuestra cuenta de correo electrónico y pulsar en el enlace para que comience la descarga. Quizás os tarde un poco en llegar el mensaje, pero paciencia, que al final llega y si no estáis seguros, podéis volver a introducir los datos en la página y pulsar otra vez. Esta es la url que me han enviado, podéis probar para ver si pulsando en esta os ahorráis tener que registraros: http://java.sun.com/javase/downloads/jre/142/

Seleccionamos la plataforma, el lenguaje y marcamos el cuadrito de “I Agree” para indicar que estamos de acuerdo con las condiciones y pulsamos “Continue”.

Ahora hacemos clic en el enlace para descargar el programa: j2re-1_4_2_19-windows-i586-p.exe y el fichero se descargara en donde vosotros indiquéis.

Una vez que se ha descargado vamos a la ubicación que le dijimos y hacemos doble clic en el fichero para empezar con la instalación. Esperamos un poco hasta que nos salga la primera pantalla y marcamos “Acepto los términos del contrato de licencia”, para pulsar a continuación el botón de “Siguiente”.

Volvemos a pulsar siguiente.

Y el programa comenzara a copiar archivos. Cuando termine nos mostrara la siguiente pantalla donde le daremos a finalizar.

Ahora solo nos queda reiniciar para que los cambios surtan efecto. Este paso es necesario, así que no olvidéis de guardar todo lo que estuvierais haciendo y agregar este blog a “Favoritos” del navegador para no perder la dirección y reiniciar el ordenador.

Ahora nos vemos.

Bien, la primera parte ha sido sencilla ¿no?, las demás también son fáciles de todos modos. Continuamos.

Solo quisiera recordaros ahora mismo que la placa de arduino debe seguir desconectada por el momento, pero solo es un recordatorio, pronto la conectaremos.

Ahora nos vamos a ir a la pagina del proyecto arduino y vamos a descargar el entorno de programación junto con los drivers necesarios para que la placa funcione.

La dirección donde bajaremos el entorno es la siguiente:

http://www.arduino.cc/en/Main/Software

Allí haremos clic en el enlace que pone “windows” y la descarga comenzara. Notar que aparece al principio de la página y que siempre viene la ultima versión estable. Aunque esto puede cambiar en el futuro, a fecha de hoy la versión es la 0016. Los que vengáis a este blog en los años próximos diréis –vaya versión utilizaban esta gente, nosotros ya no tenemos ni que escribir código apenas- :D.

Tener paciencia, porque esta versión ocupa comprimida 67 mb. Voy a echar una partidita a algún juego y ahora nos vemos.

Ahora tenemos que descomprimir el fichero que se ha descargado. Os recomiendo descomprimirlo en c:\Arduino. Para ello vamos a la carpeta donde lo hemos descargado y hacemos doble clic al archivo. Dependiendo del programa que tengamos la imagen será una u otra. Yo tengo winzip, y primero he entrado en la carpeta arduino-0016, después he pulsado “extraer en” para luego teclear c:\arduino y pulsar aceptar.

Ahora tenemos descomprimido el fichero. Vamos a ir a la carpeta de arduino, entramos en drivers y después en ftdi usb drivers, donde podemos ver que el contenido no esta comprimido. Ahora podemos comenzar la instalación de la placa de arduino.

Sencillamente conectaremos un extremo del cable usb a la placa de arduino y el otro al puerto usb del PC, y en unos segundos aparecerá el cuadro de dialogo del “Asistente para hardware nuevo encontrado”. Ahí tenemos que marcar “Instalar desde una lista o ubicación especifica” y pulsar siguiente.

Ahora desmarcamos “Buscar en medios extraíbles…” y marcamos “Incluir esta ubicación en la búsqueda”. A continuación usamos el botón examinar y buscamos la carpeta c:\arduino\drivers\ftdi usb drivers, pulsamos aceptar y después en la ventana que estábamos pulsamos siguiente.

Cuando termine de copiar archivos pulsamos finalizar.

Ahora nos volverá a salir otra vez el cuadro de dialogo de “Asistente para hardware nuevo encontrado”, tenemos que seguir exactamente los mismos pasos y la instalación de la placa habrá finalizado. No vuelvo a ponerlos porque creo que es bastante sencillo de hacer, y no quiero hacer mas larga esta guía para nada. Solo tenemos que volver a repetir el mismo proceso, es decir, marcar “Instalar desde una lista o ubicación especifica”, pulsar siguiente, desmarcar “Buscar en medios extraíbles”, marcar “Incluir esta ubicación en la búsqueda”, pulsar examinar, buscar la carpeta c:\arduino\drivers\ftdi usb drivers, pulsar aceptar y después siguiente. Una vez termine de copiar archivos volvemos a pulsar finalizar y se acabo, la placa esta lista para ser utilizada, aunque se recomienda reiniciar el equipo antes de hacer cualquier otra cosa.

(Por otro lado, cuando vayamos a subir el primer codigo a la placa tendremos que ajustar la configuracion del programa para que sepa en que puerto y a que velocidad debe transmitir los datos, asi como indicarle que placa es la nuestra).

Por hoy no creo que me de tiempo a poner nada mas, he tardado casi 5 horas en preparar esta pequeña guía, entre redactar y preparar imágenes se me ha ido mucho tiempo. En la próxima entrada empezaremos con el primer ejemplo, muy sencillito pero muy importante.

Recordar que podéis hacer comentarios. Si encontráis algún error en esta o cualquier entrada indicármelo y lo modificare. Saludos.