Go Down

Topic: proyecto para una instalación interactiva con arduino (solucionado) (Read 2236 times) previous topic - next topic

irati

hola,

primero quiero decir que soy una alumna de bellas artes, que con unas compañeras estoy haciendo un proyecto interactivo en el que usamos arduinos.

Nuestro proyecto trata de un espacio oscuro donde hemos colocado unas placas de metal en el suelo, que al pisar y según con la intensidad que pisemos, varia la intensidad de la luz del techo, donde hemos colocado unos leds, y por otro lado el sonido. Es decir contra mas fuerte pisemos mas luz pero a la vez mas sonido.

La parte del sonido lo hemos solucionado, pero con la luz, en un inicio habíamos colocado como sensores unos piezos simplemente, pero no hemos conseguido controlar los valores, ya que son muy sensibles, y no conseguíamos ni que la habitación estuviera a oscuras.

Lo cual pensamos en la posibilidad de usar basculas de peso digitales como entrada. Ya que estas basculas ya nos darían unos valores exactos con los que trabajar.

Un compañero me ha ayudado y me ha dicho que es posible, solo hay que hackearlos, y que tendría que ver que bascula es posible de hackear.

El problema es que no tengo conocimientos como para saberlo, he visto en un foro que iban a usar este prototipo pero no se si para el mio vale.

"Hola,
tal vez podrías hackear una báscula de baño como esta, que los chinos venden por unos 9€
http://www.ebay.es/itm/150-x-0-1KG-Portable-Digital-Bathroom-Body-Weight-Scale-/320634364268?pt=US_Pocket_Digital_Scales&hash=item4aa74c216c#ht_3800wt_977
Tiene cuatro células de carga, mide hasta 150kg, con precisión de 100g. Creo que es lo más barato para esos pesos
"


si me pudierais ayudar seria perfecto

gracias y un saludo

ionhs

Kaixo Irati

Primero bien venida. Lo que comentas en frió parece complicado sobre todo que alguien te pueda responder. Porque no creo que mucha gente tenga esa báscula, encima tiene que coincidir que la hayan hackeado y lean tu post.

En teoría se puede y parece una buena solución para vuestro proyecto. Otra cosa es lo de hackearla para sacar los datos de la medición, para eso hay que abrirla y comprender en parte como funciona para pensar de donde sacar los datos. Recuerdo que alguno de este foro ha hackeado su báscula pero cada báscula supongo que será un mundo.
Yo veo 2 soluciones posibles, tal vez la mejor es que preguntes a los que en el foro ese querían usarla. La segunda es que te la compres vayas sacando fotos de las tripas y la gente te vaya guiando. Pero para esto sin conocimientos de usar un polímetro veo un arduo trabajo. Suerte

irati

Aupa,

gracias por responder, una duda, cualquier bascula puede ser hackeada, o tengo que tener algun tipo de caracteristica en cuenta?

digo, para pillarme unas basculas baratas, y ponerme a lo que dices, lo del polimetro, siempre tengo la opcion de que me ayuden.

eskerrik asko

arduinoadrian

Hola:

Hackear la balanza va a ser un termendo problema como ya mencionaron. Ademas de que los "strain gauges" que usa necesitan calibracion, alineacion, pegamentos especiales, etc. Sinceramente no te recomiendo ese camino. Creo que mejor seria que uses un sensor optico en una de estas 2 formas:

La placa que pisan tine una barra con agujeros solidamente montada en el centro de forma transversal y hacia abajo, por supuesto. Los agujeros estan igualmente espaciados ( eso crea una respuesta no lineal; pero no importa por ahora).

La barra agujereada interrumpe la luz de un optoacoplador. Cuentas las interrupciones y determinas cuanto se ha movido el piso lo cual depende de la fuerza aplicada. La respuesta probablemente va a ser no lineal porque la deformacion es no lineal con el peso; pero eso lo puedes resolver encontrando la ecuacion con las muestras obtenidas para diferentes pesos y despues utilizando esa equacion en el programa para realizer la correccion. Parece complicadfo pero no lo es. Si te decides yo te digo como hacer eso que es bastante facil.

Otro metodo aun mas facil es utilizando una barra semitransparente en lugar de agujereada.La transparencia de la barra la haces variable a lo largo de esta, es decir pones lineas de differentes tonos de gris que dejen pasar mas o menos la luz. Asi detectas la cantidad de luz en el sensor midiedo el voltage y ya tienes una indicacion correspondiente a la deformacion del piso la cual depende de la fueza aplicada. estos metodos opticos son muy sencillos y eficaces. si usas infrared es aun mas confinable.

No te metas en lo de la balanza digital, crème, eso es una tremenda candela. La cantidad de electronica analogica que tienen no es de juego.

Se pueden utilizar bobinas tambien; pero es mas complicado; porque tienes que enviarle un voltage de polarizacion de corriente alterna y depues detectar la respuesta. Estudia "Linear Variable Differencial Transformer" si quieres saber como es. Tampoco te lo recomiendo.

Suerte.
Perseverance is 90% of the solution. The remaining 10% is more perseverance.

arduinoadrian

Otras variants:

Tambien puedes hacer un agujero de forma triangular en la barra que a medida que avanza por el sensor optico deje pasar mas o menos luz y asi no tuine que ser translucida que es mas dificil.

Tambien puedes poner agujeros de diferentes tamanos en la barra que dejen pasar diferentes cantidades de luz.

Otra via es poner un reflector en la pista por debajo y y un sensor optico emisor-receptor de 45 grados de inclinacion (en forma de "v") mientras mas se acerque el sensor mas luz refleja hacia el receptor. Este pienso sera un poquito mas dificil de calibrar; pero como la construction es mas sencilla vale la pena darle una prueba a ver que obtienes de salida.
Perseverance is 90% of the solution. The remaining 10% is more perseverance.

irati

muchas gracias!!!

De verdad que me parece muy buena solución, me pondre a ello, y bastante mas simple de lo que habiamos planteado.

Me pondre a trabajar con esta opción, y os digo que tal me va, y si tengo cualquier problema pues vuelta. :)

Un abrazo

arduinoadrian

Si es una forma sencilla de hacerlo.

Nunca posteaste los detalles de lo que ya hiciste con los sensors piezoelectricos. Ya lo tines hecho y a lo major el problema es sencillo y no te has dado cuenta. Si lo posteas quizas podamos resolverlo.

Las especificaciones del sensor y el montaje que hiciste son relevates, fotos y esquematicos ayudarian mas.

Suerte.
Perseverance is 90% of the solution. The remaining 10% is more perseverance.

lo mas sencillo seria con los sensores piezoelectricos, que como ya dijeron antes las bascula suelen ser complicadas por la calibracion, igual y seria que con los piezos te pusieras a hacer prueba y error hasta definir un valor estandar minimo o maximo, no se a lo mejor me voy por el camino mas largo y feo, pero en mi caso es lo que haria.

irati

aupa

vuelvo, no he podido contestar antes por que he andado liada. Al final vamos a intentarlo con los piezos o si no con estos sensores que hemos encontrado.

http://www.cooking-hacks.com/index.php/shop/sensors/force-sensitive-resistor-small.html

y os meto el codigo por que quizas lo mas probable sea que el error se del codigo, ya que no sabemos mucho de programacion.

El problema que nos daba era que no conseguiamos un valor estable, ni tan siquiera que las luces estubieran apagadas.
si alguien puede hechar un ojo a este codigo, y ver que enorme aberración hemos podido cometer.


codigo:

/* codigo sacado a partir del codigo de Andres Duarte,
de la pagina "www.andresduarte.com"*/

//////variables y constantes
int ledPin = 9;
int altavoz = 11;
int analogread = 0;
int contador = 0;

int tiempo_muestreo=300; //cuanto tiene que contar para promediar la entrada y enviar la salida. Se promedian valores de entrada para buscar estabilidad.
int v_media=1;
float dif_cambio= 1; //defino la diferencia mínima de presión para cambiar de luminosidad
int v_anterior=0;

int ledPin3 = 10;

extern unsigned int __bss_end;
extern unsigned int __heap_start;
extern void *__brkval;


static int freeMemory(void){
  int free_memory;

  if((int)__brkval == 0)
  free_memory = ((int)&free_memory)-((int)&__bss_end);
else
free_memory = ((int)&free_memory)-((int)__brkval);

return free_memory;
}


void setup() {
 
  Serial.begin(9600);
 
   //freeMemory();
  pinMode(ledPin, OUTPUT);
  pinMode(altavoz, OUTPUT);

  pinMode(ledPin3, OUTPUT);
}

void loop () {

//freeMemory();
  int valor_pot = analogRead (0);
  int sound = map (valor_pot, 30, 3000, 31, 4000);
 
   for (int i=0; i <= tiempo_muestreo; i++)
   {
      v_media =valor_pot + v_media;
   }
   
   v_media=v_media/tiempo_muestreo; //media de los ultimos 200 valores leidos por el sensor , valor entre 0 y 1023, luego dividiré entre 4 para escalarlo a la salida analogica
     
   if (contador==tiempo_muestreo) //Ya ha contado 200, y procede a enviar valor a LED
    {
     
     if (v_media<2000) //valor de presion muy pequeño
     {
       analogWrite (ledPin, LOW); // si la presion es menor de 100, mantener el LED apagado
       
     
     }
     
      /*if (abs((v_anterior-v_media)>dif_cambio)&&(v_anterior>v_media)) //el valor ha decrecido, baja la luminosidad
       
       {
       analogWrite (ledPin, v_media-dif_cambio);
       
       }
     
     if (abs((v_anterior-v_media)>dif_cambio)&&(v_anterior<=v_media)) //el valor ha aumentado, sube la luminosidad
       { 
       analogWrite (ledPin, v_media+ 500);
     
       }*/
     
     else  // si el cambio no ha sido mayor que dif_cambio
        {
       analogWrite (ledPin, HIGH);
       
        }
     
   contador=0;
   }
  contador++;
 
  v_anterior=v_media;
 

  int valor_luz = map (valor_pot, 0, 3000, 1, 4000); //escala valores de entrada y salida
 
  int valor_pot2 = analogRead (0);
 
  int valor_luz2 = map (valor_pot2,  0, 3000, 1, 4000);

/* Serial.println();
  Serial.print("valor1:");
  Serial.print(valor_luz);
  Serial.println();
 
  Serial.print("valor2:");
  Serial.print(valor_luz2);*/
 
 
//delay(500); // solo lo utilizamos para calibrar el sensor

      if (valor_luz > 0 and valor_luz < 1000)
  tone (ledPin, valor_luz);
  //delay (100);
  noTone(ledPin);
  analogWrite (ledPin, valor_luz/4);
  //delay (20);
 
  //      if (valor_luz2 > 300 and valor_luz < 640)
  //tone (altavoz, valor_luz2);
  //delay (50);
  //noTone(altavoz);
 
 

 
  if (valor_luz < 1000)

 
  tone (ledPin, valor_luz);
  //delay (500);
  noTone(ledPin);
  analogWrite (ledPin, valor_luz);
  //delay (300);
 
  // tone (ledPin2, valor_luz);
  //delay (1000);
  //noTone(ledPin2);
 
  tone (ledPin3, valor_luz2);
  //delay (1000);
  noTone(ledPin3);
  //int valor_pot2 = analogRead (A0);
  //int valor_luz2 = valor_pot;
  //analogWrite (ledPin2, valor_luz2);
  //delay (300);
 
  analogWrite (ledPin3, valor_luz);
  //delay (300);
 
  if(valor_luz > 0 && valor_luz < 1000)
 
 

 

  int valor_pot2 = analogRead (A0);
  //int valor_luz2 = valor_pot;
  //analogWrite (ledPin2, valor_luz2);
  //delay (300);
 
  analogWrite (ledPin3, valor_luz);
  //delay (300);


}
 
//////

Heke

#9
Jun 11, 2013, 11:12 pm Last Edit: Jun 11, 2013, 11:14 pm by Heke Reason: 1
Quote
Nuestro proyecto trata de un espacio oscuro donde hemos colocado unas placas de metal en el suelo, que al pisar y según con la intensidad que pisemos, varia la intensidad de la luz del techo, donde hemos colocado unos leds, y por otro lado el sonido. Es decir contra mas fuerte pisemos mas luz pero a la vez mas sonido.

La parte del sonido lo hemos solucionado, pero con la luz, en un inicio habíamos colocado como sensores unos piezos simplemente, pero no hemos conseguido controlar los valores, ya que son muy sensibles, y no conseguíamos ni que la habitación estuviera a oscuras.

Lo cual pensamos en la posibilidad de usar basculas de peso digitales como entrada. Ya que estas basculas ya nos darían unos valores exactos con los que trabajar.


Estas mezclando dos conceptos, vamos a intentar aclararlos...

Si empleas unas basculas para cada placa, la variacion que obtienes es el peso de la persona, no lo fuerte que pisa, a mas gente... mas peso.

Si quieres medir la suavidad de la pisada ya no puedes decantarte por el peso, sino por el impacto del "pisoton"

Para obtener variaciones de peso, es decir persona mas o menos gorda, mas o menos luz, si te vale un sensor de peso de una bascula.

Para obtener variaciones de la intensidad de la pisada, lo mejor un microfono acoplado a la plancha, asi obtienes "pulsos" a cada paso, cuanto mayor sea la pisada mayor amplitud del pulso independientemente del peso de la persona o personas.

La cuestion que desconocemos es si el sonido que empleais interfiere con el sensor de las placas.
CUIDADO !! MIS POST NO SON APTOS PARA MENORES. SI ERES MENOR DE 14 AÑOS DEBES DE LEERLOS ACOMPAÑADO DE UN ADULTO

irati

ok, gracias por esa aclaración, y entrando a lo que dices, cuando te refieres a unos
"microfonos acoplados", podrian servir unos piezos electricos mismos de esos que son como una moneda fina. De estos estamos provando pero no conseguimos que nos de un valor estable.

Lo cual suponesmos que se deve a algun error en el codigo, lo cual si pudierais ayudarnos con el codigo, como hacer para que nos de un valor estable.

Gracias

Heke

#11
Jun 12, 2013, 08:27 am Last Edit: Jun 12, 2013, 08:31 am by Heke Reason: 1
Irati

Puede valer un piezoelectrico, tambien un electrect, todo depende de como implementeis la parte analogica, si la amplificais, si usais un operacional...etc.

He visto tu codigo por encima y lo veo un poco liado, no tengo claro como lo habeis enfocado. (para mejorar la lectura de codigo, cuando posteas hay un boton con el simbolo de la almohadilla que es para insertar codigo en tu conversacion y queda mas limpio y legible en el post)

Para aclararte mejor no te voy a copiar y pegar lo que han hecho otras personas, te mando el enlace y lo ves que ademas tienen ejemplos muy claros, si los sigues tienes el diseño liquidado en un pis pas.

http://www.miguelgrassi.com.ar/arduino/PiezoMIDI.htm



http://www.arduino.cc/es/Tutorial/KnockSensor

CUIDADO !! MIS POST NO SON APTOS PARA MENORES. SI ERES MENOR DE 14 AÑOS DEBES DE LEERLOS ACOMPAÑADO DE UN ADULTO

Go Up