[de cara a la presentación..] Contextualización del proyecto.

De cara a las presentaciones de los proyectos de curso de PSEM del día 29, nos vemos condenados a contextualizar nuestro proyecto. En la asignatura hemos hecho hincapié en el desarrollo de aplicaciones para dispositivos empotrados basados en microcontroladores, sensores, actuadores,.. Para ello empleamos soluciones de prototipado específicas y entornos y lenguajes de programación basados en Java, como por ejemplo Wiring y Mobile Processing. De hecho, el trabajo de documentación también lo basamos en ello.
La idea original nos la sugirió Marco. Un despertador con ruedas que siguiera una ruta previamente especificada. El prototipo incorporaba los ejes y motor de un coche teledirigido, y el circuito y display de un despertador digital. Solamente utilizábamos la tecnologia Wiring en el proceso de almacenaje de la ruta que recorrería el rejojcochecito. Después descubrimos que ya existía un prototipo comercial que se parecía [demasiado para nuestro gusto] a nuestro proyecto, por lo que nuestro trabajo simplemente consistiría en incorporarle la placa Wiring. Finalmente la idea original se transformó en el que resultará nuestro "clocky" particular [que presentaremos el 29]

Producto comercial parecido a nuestro prototipo:

Clocky

• Dimensiones: 5.25" x 3.5" x 3.5" [12,7cm x 7,62cm x 7,62cm]
  
• Colores: blanco almendra, agua, coco y mostaza.
• Advierte de bateria baja.
• Señales sonoras aleatorias.
  
• Se pueden inhabilitar las ruedas, para mantenerlo fijo.
• Repetición de alarma configurable, de 0 a 9 minutos.
• Puede saltar desde más de 90 cm.
• Se mueve sobre madera y alfombra.
  

Página web:
http://www.nandahome.com/

Videos YouTube:
_demo:
http://es.youtube.com/watch?v=3zYO7HNbPl4&eurl=http://www.thinkgeek.com/homeoffice/lights/91f2/
_My Idea will make Milions:
http://es.youtube.com/watch?v=hLS20pWMs6Q&feature=related

Parte de Mobile Processing

Todavía no conseguimos la detección del módulo de bluetooth de la placa wiring, pero hemos conseguido crear el software que tendrá que instalarse en el móvil mediante el que transmitiremos a la placa wiring la orden de inicio.

Por el momento, el programa es un simple reloj con alarma. Pones la hora de la alarma y empieza una canción cuando coinciden alarma y reloj. Aquí teneis unas capturas y el código para mobile!

Imagen: capturas de pantalla del emulador en diferentes momentos del código

CÓDIGO MOBILE PROCESSING:

import processing.sound.*;

Sound cancioncilla = new Sound("alarma.wav");

PFont pFont; //fuente
PButton button; //botón
boolean control_alarma; //control de si está activada o no la alarma

//variables donde se guarda la alarma
String [] alarma = new String[2]; //donde guardaremos alarma
String [] alarm = new String[2]; //string editable
void guarda_alarma()
{
alarm[0]=""; //horas
alarm[1]=""; //minutos
int num=2;
alarma[0]=textInput("introduce hora", alarm[0], num);
alarma[1]=textInput("introduce minutos", alarm[1], num);

}

void setup()
{
background(204);
button = new PButton("Alarma");
// coge y mostrará la fuente por defecto del sistema
button.calculateBounds(0,0,width,height);
button.setBounds((width-button.width)/2,height-button.height,button.width,button.height);

button.initialize();

pFont = loadFont();
textFont(pFont);
//alinea el texto en el centro
textAlign(CENTER);

}

void draw() {
background(204);
//inicializamos variable de diferencia horaria respecto la máquina
int diferencia =1;

int s = second(); // Values from 0 - 59
int m = minute(); // Values from 0 - 59
int h = diferencia + hour(); // Values from 0 - 23
//ellipse(width/2,height/2-10, width-30,height-70); //esfera del reloj
String horas = str(h);
String minutos = str(m);
//muestra hora actual por pantalla
fill(0);
textAlign(LEFT);
text("EL RELOJ-ALARMA DEFINITIVO", 30,40);
text("hora actual--> "+horas+":"+minutos, 80,80);

button.draw();
if (!control_alarma)
{
fill(180,0,0);
textAlign(LEFT);
text("alarma NO activada", 80, 100);
}
if (control_alarma)
{
fill(0,180,0);
textAlign(LEFT);
text("sonará a las "+alarma[0]+":"+alarma[1], 80, 100);

}

// compara hora actual con la de la alarma
if(horas.equals(alarma[0])&& minutos.equals(alarma[1]) == true)
{
cancioncilla.volume(100);
cancioncilla.play();
//conectar con cochecito
fill(0,0,180);
textAlign(LEFT);
text("ahora suena", 80, 120);
}

}

void keyPressed()
{
//// let the button handle any keypresses
button.keyPressed();
}

void keyReleased()
{
//// let the button handle any keyreleases. this is
//// important as PButton sends its event on release!
button.keyReleased();
}

void libraryEvent(Object library, int event, Object data) {
if (library == button) {
//// if the button sent a library event, it was pressed!
guarda_alarma();
control_alarma = !control_alarma;
}
if (library == cancioncilla) {
text("suenas", 80,140);
}
}

Debemos añadir la parte de la transmisión bluetooth del programa y solucionar la excepción de java cuando acaba el archivo de audio. Estamos en ello!!!

pausado....

.... por examenes

Módulo bluetooth (II)

Ejecutamos código y montaje y no obtenemos ningún resultado, el pc no detecta el dongle de la wiring. así que la pregunta es: puede conectarse un dongle? no será necesario un modem bluetooth como en el tutorial de wireless??

Módulo Bluetooth

Antes de tratar de conectar la placa wiring con el móvil, efectuaremos una prueba con Processing desde un ordenador portátil con Bluetooth. Vincularemos el dongle con el portátil mediante una conexión de puerto serie del ordenador (por defecto un COMx). Una vez esten vinculados los dispositivos y sepamos que puerto COM usa nuestra máquina, modificamos esta variable en el código de processing. [ver punto 3]

Requisitos de Hardware

Necesitamos conectar un Dongle de bluetooth a la placa Wiring. Como el dongle se conecta mediante un USB, conectaremos un adaptador de usb a la placa Wiring.

¿Cómo?

1. Usaremos las posibilidades de los puertos serie de wiring. Usamos el puerto serial1 (situado en los pins 2 y 3).

2. Buscamos cuales son las conexiones y requisitos de un USB. En resumen:
Pin Nombre Color del Cable Descripción
1 VCC Rojo +5V
2 D− Blanco Data −
3 D+ Verde Data +
4 GND Negro Tierra


3. Partiendo del tutorial de wireless de wiring y del ejemplo de serial input. Hemos basado nuestra primera versión del código en estos 2 ejemplos.


----------------------------------------------------------------CÓDIGO EN PROCESSING
import processing.serial.*;

Serial port;

void setup()
{
size(200, 200);
noStroke();
framerate(10);

// Listamos todos los puertos series disponible en el panel output
// Debemos escoger a que puerto tenemos conectada la placa wiring.
//En esta máquina habiamos conectado el usb en el puerto COM4 normalmente,
//ahora que pasamos a vincular el dongle con nuestro bluetooth debemos indicarle //al programa por qué puerto tx y rx. Normalmente los COM de bluetooth se me crean en el COM40
// verificar con la siguiente instrucción
println(Serial.list());

// Debemos abrir el puerto al que la placa se conecta
// Debemos poner a la misma velocidad el puerto y la placa !!!! (9600bps)
port = new Serial(this, Serial.list()[?], 9600);
}


void draw() //simplificamos el ejemplo con un simple ENTER
{
background(#222222);
if(keyPressed)
{
if(key == 'o' key == 'O')
{
port.write('O'); //ENVIAMOS O DE ON PARA EMPEZAR
}
}
}

---------- CÓDIGO EN PLACA WIRING

char val; // variable para recibir datos del puerto serie
int outpin0 = 0; // roda dreta conectada al pinPWN0
int outpin1 = 1; // roda esquerra conectada al pinPWN1

void setup()
{
//pinMode(ledpin, OUTPUT); //crec q les PWN ja estan configurades com sortida // pin 48 (on-board LED) as OUTPUT
Serial.begin(9600); // start serial communication at 9600bps
}

void loop() {
if( Serial.available() ) // si está disponible para leer
{
val = Serial.read(); // lee el puerto serie y lo guarda en val
}
if( val == 'O' ) // si recibimos O = ON empezamos programa
{
Empezar el código del prototipo!!!!!!!!!!!!!!!!
}
delay(100); // espera 100ms para la siguiente lectura del puerto
}

• Empezaremos las pruevas esta tarde y colgaremos posteriormente la versión de código definitiva, también los puertos y un esquema.

Cogiendo impulso!!

Incorporamos al proyecto dos jumpers gentileza de Xavi Costa, que estañamos a los servos, consiguiendo una buena conexión de los exservosaramotorsDC a la placa Wiring:

Cuando le intentamos dar autonomía al invento, advertimos que con una alimentación de 9V no tenemos suficiente. Desechamos la idea de poner dos pilas de 9V en serie, ya que la placa Wiring sólo soporta 13V de alimentación, por lo que le conectamos en serie el portapilas de 4x1,5V, previamente adaptado para 2x1,5V. El resultado és el siguiente:


Dado los precios abusivos de las cajas de metacrilato, decidimos darnos un capricho y utilizar de carcasa la caja de una famosa marca de bombones...El resultado es tan cuco como se muestra a continuación[tacháaaaaan] :

Controlando!!

Ueeee!!! Por fin controlamos velocidad, tiempo de ejecución de cada función...etc

El siguiente código hace que el cotxe se mueva durante 10 segundos recto, se pare durante 10 segundos y haga un giro hacia la derecha durante 10s, repitiendose el ciclo indefinidamente.

///////////////////////////////////////////////////////VARIABLES

//Nom pels diferents servos
int outpin0 = 0;
int outpin1 = 2;

//Diferents valors de tensió [0-255]
int val0 = 255;
int val1 = 0;

//Altres
int control =0;

/////////////////////////////////////////////FUNCIONS [de moviment]
void cotxet_run(int pin_esq, int pin_dreta, int atope)
{
analogWrite(pin_esq, atope);
analogWrite(pin_dreta, atope);
}
void cotxet_stop(int pin_esq, int pin_dreta, int parao)
{
analogWrite(pin_esq, parao);
analogWrite(pin_dreta, parao);
}
void cotxet_gir(int pin_esq, int pin_dreta, int atope, int parao)
{
analogWrite(pin_esq, atope);
analogWrite(pin_dreta, parao);
}

////////////////////////////////////////////////////////EJECUTANDO

void setup() {
Serial.begin(9600);
}

void loop() {

cotxet_run(outpin0, outpin2, val0);
delay(10000);//delays necessaris xq no executi totes les funcions alhora [q físicament es tradueix com la divisió del valor de tensió als pins 0 i 2]
cotxet_stop(outpin0, outpin2, val1);
delay(10000);
cotxet_gir(outpin0, outpin2, val0, val1);
delay(10000);
}

módulo de movimiento

FUNCIONAN LOS 2 SERVOS!!!!!!!!!!!!!!!!

han pasado sucesos paranormales otra vez, pero hemos conseguido que funcionen, mañana por la tarde os mostraremos documentos fotográficos!!

Módulo sensor distancia

Finalmente nos decidimos por el módulo detector de objetos C-9607: www.cebekit.es
Características del sensor:

• detecta objetos a 150mm mediante infrarrojos
• según especificaciones:

- canal-1: positivo (V+) [PA]

- canal-2: negativo o masa (GND) [PA]

- canal-3: escribiendo un "0"(ON) --> se activa el detector

- canal-4: si existe objeto --> devuelve "0" [PD]

si no existe objeto --> devuelve "1" [PD]

Para controlarlo con la placa wiring:

pins digitales(PD)

pins analógicos (PA)

acerca del diseño del proyecto (II)

Ya tenemos más claras las funciones del prototipo, así que podemos pensar el código modularmente.

• El cochecito establece la conexión bluetooth con el movil (módulo bluetooth) y detecta la alarma con el software del móvil (todavía sin desarrollar).
• Cuando se detecta el evento alarma se disparan los módulos de movimiento (en desarrollo en el apartado al otro lado del espejo) y de sonido, es decir, empieza a sonar la alarma del cochecito y empieza a moverse.
• Si detecta un objecto, esto viene controlado por el sensor de distancia (código del módulo de sensor de distancia), cambiará el movimiento para evitar el obstáculo (giros, velocidades, paradas...).
• Seguirá efectuando estos módulos hasta que se presione el pulsador (módulo pulsador) lo que hará que se paren los módulos de movimiento y sonido (paramos el cochecito y deja de sonar).

Toda esta descripción del código se puede ver de forma visual en la siguiente figura:

al otro lado del espejo (III)

En nuestro afán de conseguir controlar el cochecito, establecemos un código diferente para cada uno de los pins (PWM), así verificamos las diferentes posibilidades de aceleración, velocidad, etc.

Conclusiones: contra mayor sea "val" con la función, más deprisa y más tensión obtendremos. Con sentencias consecutivas podremos acelerar la función de velocidad constante y añadiremos finalmente una función de frenada.

CÓDIGO:

//Nom pels diferents pins de sortida
int outpin0 = 0;
int outpin1 = 1;
int outpin2 = 2;
int outpin3 = 3;
int outpin4 = 4;
int outpin5 = 5;
//Nom variables per diferents valors 0-255
int val0 = 0;
int val1 = 100;
int val5 = 128;
int val2 = 100;
int val3 = 100;
int val4 = 255;
void setup()
{
}
void loop()
{
//pin 0 //accelerando desde 0?//SENSE cap delay intenta accelerar durant X s //Amb delays de posteriors pins no chuta (delay100, si)
//pin 0 //(SENSE DELAY) sense parar 1 volta/20s GND(2,2V-2,7V) VCC(-2,2V -2,7V)

analogWrite(outpin0, val0); // sets the value of analog pin 0

val0 = (val0 + 10) % 255; // increment value and keep it in the 0-255 range.
//pin 1 //(AMB DELAY 1000)RESET->RUN 7-8s //RUN->STOP 15s 5accel+10velcte //STOP->RUN 10s
//pin1 //(AMB DELAY 100) //RESET-> RUN 7-8s //RUN ->STOP 1-1,5 s //STOP ->RUN 1s
//pin 1// (SENSE DELAY) //sense parar 1 volta/20s GND(2,2V-2,7V) VCC(-2,2V -2,7V)
analogWrite(outpin1, val1);
val1 = (val1 + 10) % 255;

//pin 3 //(DELAY 1000) RESET->RUN 7-8s //RUN->STOP 1s //STOP -> RUN 1s
//pin3 //(SENSE DELAY) //sense parar 1volta/17-18s GND (2,4V-2,5V) VCC(-2,7 - -2,8V) analogWrite(outpin3, val3);
val3 = (val3 + 100) % 255;

//DELAYs
//delay (100);
//delay(1000);
//delay(10000)

//pin 2 velocitat alta i constant RESULTAT: accelera, velocitat constant (10 s ->delay 10000)i despres para durant segons 10s (delay(10000)
//pin 2 //(SENSE DELAY) sense parar 1volta/8s GND (3,3V-3,4V) VCC (-1,6V- -1,7V)
for(int i=0;i<48;i=i+8) style="color: rgb(51, 255, 51);">// delay(5000);
val2 = (val2 + i) % 255;
analogWrite(outpin2, val2);
// sets the value of analog pin 2
//delay(1000);
}
val2= 100; //per tornar a posar el valor a 100, si no te un començament/acavament diferent
//delay (10000); //run durant 10s, stop durant 10s cada cicle més accelerat
//delay (100); //nomes soroll no es mou!!*/
}

acerca del diseño del proyecto

Como en el post anterior explicamos la modificación respecto el uso de los servo motores, también la idea en sí del proyecto ha sufrido ciertas modificaciones

• en lugar de integrar un despertador digital en el artilugio en movimiento, dispararemos la secuencia de movimientos y de sonido desde el movil. http://www.technocracia.com/2007/12/08/super-mini-receptor-bluetooth/ [o un usb parecido] Es decir, efectuaremos una conexión bluetooth entre el movil y la placa wiring. Así cuando suene la alarma en el telefono movil se enviará mediante bluetooth la orden a la placa. Vincularemos previo montaje el emisor (telefono móvil) y el receptor.

• añadiremos un sensor http://www.cebekit.es/Producte.aspx?referencia=1594 que detecte objetos para que el artilugio detecte que hay un obstaculo y modifique su secuencia de movimientos.

Respecto la modificación sobre bluetooth:

• efectuaremos el software concreto para móvil con mobile processing. Este lenguaje tiene 2 librerías específicas (una para bluetooth y la otra para los sonidos) con las que podremos crear un software con las características que necesitamos.

al otro lado del espejo (II)

Hola de nuevo tras las "vacaciones" bien lo típico que si felices fiestas que si feliz año nuevo bla bla

Hicimos una incursión interesante antes de año nuevo (dias 27-28 de diciembre) en el control del servo mediante la placa wiring y ya semi-montado con una rueda.

Finalmente tomamos ciertas decisiones:

- descartamos el motor DC habitual para pasar a una configuración mediante 2 servomotores trucados para que efectue los 360º y directamente engancharlo a los radios de las diferentes ruedas.

- afirmamos que pasaron sucesos paranormales con la placa, el código y los servos.

Empezamos con el montaje del prototipo de movimiento, con unos pequeños soportes de plástico. En cada uno situamos un servo y tras agujerearlos situamos también las ruedas enganchadas por el momento con bluetag para empezar a observar el resultado del código respecto el movimiento de las ruedas (velocidad, aceleración, desaceleración).

CODIGO (aceleración / velocidad constante)

int outpin1 = 2;

int val = 100;

void setup() { }

void loop() {

val=100;

for(int i=0;i<48;i=i+8)>

val = (val + i) % 255;

analogWrite(outpin1, val);

}

delay (10000);

}

Intentando controlar la velocidad del motor nos dimos cuenta que lo podíamos hacer mediante el incremento dentro del módulo de 255 -que es el máximo que asume el pin de voltaje- y el uso de los delay's.

Ahora mismo estamos trucando el segundo servo, porque el anteriormente conocido como segundo servo murió en el proceso de trucaje.