Página a revisar.

Capítulo 8: Ejemplos complejos 1: Oscilación con una cremallera

La oscilación es la variación en el tiempo de un valor central o entre dos o más estados. Con un oscilador podemos cambiar manualmente el tono de nuestro altavoz piezoeléctrico del ejemplo anterior. La cremallera analógica funcionará perfectamente como un oscilador dado que nos da un buen rango de valores que pueden ser reasignados a otro rango de tonos diferentes.

El siguiente programa leerá el valor de la cremallera, reasignará los valores y los usará para establecer el tono que será reproducido por el altavoz piezoeléctrico:

int piezoPin = 10;
        /* declara el pin al que el altavoz piezoeléctricos está conectado */
int analogPin = 2;
        /* declara el pin al que la cremallera está conectada */
int myTemp = 0;
        /* declara una variable temporal para almacenar */
int myRemapValue = 0;
        /* declara una variable para el valor reasignado */

void setup(){
        pinMode(piezoPin,OUTPUT);
        /* declara piezoPin como OUTPUT */
}

void loop(){
        myTemp = analogRead(analogPin);
        /* lee y almacena el valor de la cremallera */
        myRemapValue = map(myTemp,100,300,0,2000);
        /* reasigna el valor de la cremallera para que coincida en el rango de 0 a 2000 */
        digitalWrite(piezoPin,HIGH);
        /* envía 5V al altavoz piezoeléctrico */
        delayMicroseconds(myRemapValue);
        /* pausa con el valor reasignado */
        digitalWrite(piezoPin,LOW);
        /* envía 0V al altavoz piezoeléctrico */
        delayMicroseconds(myRemapValue);
        /* pausa con el valor reasignado otra vez */
}

Este ejemplo implementa la función map(). Para aprender más acerca de la función map() ve a la página 86-87. Tu cremallera podría dar valores que son suficientemente buenos para poner algunos tonos directamente, pero tendrían un rango menor que lo que queríamos, ya que un sensor analógico no da valores por encima de 1023.

Una vez que tu código está completo, prueba a conectarlo todo a la placa Arduino como se muestra en la figura y prueba el oscilador cremallera.

2: El sintetizador flexible

Usa el mismo método para crear un botón pulsador que se muestra en el ejemplo de las páginas 41-42. Para este ejemplo usaremos una gran pieza de tela para hacer espacio suficiente para todos los botones pulsadores.

En un lado de los botones conecta 5 cables y cose una conexión a una pieza de tela conductoradesde un cable a otro para todos los botones pulsadores. Desde el otra lado de los botones pulsadores, hasta la otra pieza de tela conductora, cose una conexión a un trozo largo de hilo y al final de este hilo conecta un cable negro. Esto actuará como conexión tierra para todos los botones, ya que no hay suficientes puertos GND en el arduino para todos los botones.

Ahora que tenemos listos los botones pulsadores para nuestro sintetizador flexible, podemos empezar con nuestro programa. Pon especial atención a la función de setup. Aquí configuramos los 5 botones a 5V. Podemos hacer esto porque el Arduino tiene resistencias internas de pullup. Esto significa que añadiendo estas líneas de código no necesitamos usar resistencias extra para poder leer los valores de los pines digitales:

int piezoPin = 10 ;
        /* declara el pin al cual el altavoz piezoeléctrico está conectado */
int keyOne = 2;
        /* declara el primer botón pulsador */
int keyTwo = 3;
        /* declara el segundo botón pulsador */
int keyThree = 4;
        /* declara el tercer botón pulsador */
int keyFour = 5;
        /* declara el cuarto botón pulsador */
int keyFive = 6;
        /* declara el quinto botón pulsador */
void setup(){
        pinMode(piezoPin,OUTPUT);
        /* declara piezopin como output */
        pinMode(keyOne,INPUT);
        /* declara el primer botón pulsador como input *
        pinMode(keyTwo,INPUT);
        /* declara el segundo botón pulsador como input */

        pinMode(keyThree,INPUT);
        /* declara el tercer botón pulsador como input */
        pinMode(keyFour,INPUT);
        /* declara el cuarto botón pulsador como input */
        pinMode(keyFive,INPUT);
        /* declara el quinto botón pulsador como input */
        digitalWrite(keyOne,HIGH);
        /* envía 5V al primer botón pulsador */
        digitalWrite(keyTwo,HIGH);
        /* envía 5V al segundo botón pulsador */
        digitalWrite(keyThree,HIGH);
        /* envía 5V al tercer botón pulsador */
        digitalWrite(keyFour,HIGH);
        /* envía 5V al cuarto botón pulsador */
        digitalWrite(keyFive,HIGH);
        /* envía 5V al quinto botón pulsador */
}

void loop(){
        if(digitalRead(keyOne) == LOW){
        /* comprueba si el primer botón pulsador es pulsado */
        digitalWrite(piezoPin,HIGH);
        /* envía 5V al altavoz piezoeléctrico */
        delayMicroseconds(1911);
        /* espera 1911 microsegundos (crea una C) */
        digitalWrite(piezoPin,LOW);
        /* para de enviar 5V al altavoz piezoeléctrico */
        delayMicroseconds(1911);
        /* espera otros 1911 microsegundos */
}

if(digitalRead(keyTwo) == LOW){
        /* comprueba si el segundo botón pulsador es pulsado */
        digitalWrite(piezoPin,HIGH);
        /* envía 5V al altavoz piezoeléctrico */
        delayMicroseconds(1703);
        /* espera 1703 microsegundos (crea una D) */
        digitalWrite(piezoPin,LOW);
        /* para de enviar 5V al altavoz piezoeléctrico */
        delayMicroseconds(1703);
        /* espera otros 1703 microsegundos */
}

if(digitalRead(keyThree) == LOW){
        /* comprueba si el tercer botón pulsador es pulsado */
        digitalWrite(piezoPin,HIGH);
        /* envía 5V al altavoz piezoeléctrico */
        delayMicroseconds(1517);
        /* espera 1517 microsegundos (crea una E) */
        digitalWrite(piezoPin,LOW);
        /* para de enviar 5V al altavoz piezoeléctrico */
        delayMicroseconds(1517);
        /* espera otros 1517 microsegundos */
}

if(digitalRead(keyFour) == LOW){
        /* comprueba si el cuarto botón pulsador es pulsado */
        digitalWrite(piezoPin,HIGH);
        /* envía 5V al altavoz piezoeléctrico */
        delayMicroseconds(1432);
        /* espera 1432 microsegundos (crea una F) */
        digitalWrite(piezoPin,LOW);
        /* para de enviar 5V al altavoz piezoeléctrico */
        delayMicroseconds(1432);
        /* espera otros 1432 microsegundos */
}

if (digitalRead(keyFive) == LOW){
        /* comprueba si el quinto botón pulsador es pulsado */
        digitalWrite(piezoPin,HIGH);
        /* envía 5V al altavoz piezoeléctrico */
        delayMicroseconds(1276);
        /* espera 1276 microsegundos (crea una G) */
        digitalWrite(piezoPin,LOW);
        /* para de enviar 5V al altavoz piezoeléctrico */
        delayMicroseconds(1276);
        /* espera otros 1276 microsegundos */
}
}

Este programa comprueba todos los botones. Tan pronto como uno de ellos es pulsado comenzará a reproducir el tono de esa tecla. En este ejemplo vamos a usar los tonos C,D,E,F y G. Al final de este capítulo puedes encontrar una tabla de tonos y sus correspondientes tiempos de retardo.

Una vez que el programa está listo, súbelo a tu placa Arduino y conecta tu teclado flexibe y altavoz piezoeléctrico como se ve en la siguiente ilustración:

El altavoz piezoeléctrico podría estar también implementado en el teclado de tela para hacer tu diseño más estético.

Tabla de tonos y sus correspondientes tiempos de retardo:

Tono Retraso
C 1911
D 1703
E 1517
F 1432
G 1276
A 1136
B 1012
C 0956

3: Controlando un servo normal con una cremallera

En este ejemplo usaremos la cremallera analógica de las páginas 51-54 para controlar la rotación de un motor servo normal. La siguiente ilustración muestra como conectar ambos, el servo y la cremallera:

Para escribir el programa primero tienes que saber los valores máximo y mínimo de tu cremallera. Ve a las páginas 51-54 si no recuerdas como leer los valores de un sensor analógico.

Los valores mínimo y máximo de la cremallera serán remapeados en nuestro programa usando la función map() a los valores de rotación mínimo y máximo de nuestro motor servo:

int servoPin = 2;
        /* pin digital para el motor servo */
int servoMin = 500;
        /* posición mínima del servo */
int servoMax = 2500;
        /* posición máxima del servo */
int pulse = 0;
        /* cantidad para pulsar el servo */
long lastPulse = 0;
        /* el tiempo en milisegundos de el último pulso */
int refreshTime = 20;
        /* el tiempo necesario entre pulsos */
int myZipper = 0;
        /* el valor devuelto desde el sensor analógico */
int analogPin = 0;
        /* el pin analógico al que el sensor está conectado */

void setup(){
        pinMode(servoPin,OUTPUT);
        /* configura el pin del servo como output */
        pulse = servoMin;
        /* establece la posición del motor al mínimo */
        Serial.begin(9600);
        /* configura la velocidad de comunicación serie */
}

void loop(){
        myZipper = analogRead(analogPin) ;
        /* lee la entrada analógica */
        pulse = map(myZipper,0,1023,servoMin,servoMax);
        /* reasigna el valor de la cremallera al rango de valores comprendido entre servoMin y servoMax */
        if (millis() - lastPulse >= refreshTime) {
        /* si milis (el cual es la cantidad de milisegundos que el arduino ha estado encendido) menos el valor
        desde “lastPulse” es mayor o igual a el
        valor en “refreshTime” entonces esta parte de código es ejecutada */

        digitalWrite(servoPin,HIGH);
        /* enciende el motor */
        delayMicroseconds(pulse);
        /* la longitud del pulso establece la posición del motor */
        digitalWrite(servoPin,LOW);
        /* apaga el motor */
        lastPulse = millis();
        /* guarda el tiempo del último pulso */
}}

Este programa leerá el valor de la creamllera y asignará este valor en el pulso que se usará para establecer la posición del motor. Una vez que hayas acabado con el código, súbelo a tu placa y prueba a mover la cremallera para mover el motor servo. En este programa tienes que añadir los valores máximo y mínimo de tu cremalleraen la función map(myZipper, your zipper min, your zipper max, 500, 2500);.

4: Sensor bordado táctil

En este ejemplo vamos a fabricar un bordado táctil, el cual hará que el bordado actue como un botón. Para hacer bordados necesitarás usar un chip extra. El chip QT118 es un sensor táctil que consta de un circuito integrado y es capaz de detectar proximidad o toque. Hay diferentes tipos de chips QT y el QT118 que vamos a usar somo puede manejar una entrada sensitiva. El chip QT funciona como un interruptor on/off y puedes la sensibilidad táctil desde el chip con cualquier material conductor como un cable o un hilo conductor. La inlustración siguiente muestra las patas de un chip QT118 y donde necesitan ser conectadas.

Para hacer un bordado sensible, necesitamos añadir un condensador. El condensador estabilizará la señal que viene del chip QT hacia nuestro bordado para permitirnos generar un valor de referencia. El chip QT usará este valor de referencia para comparar la señal cuando el bordado es tocado de cuando no. La ilustración en la izquierda muestra como conectar el condensador al chip y donde puedes empezar con tu bordado:

Todas las partes que quieras que sean sensibles al tacto tienen que estar conectadas al hilo que conecta al pin del chip. Conecta los siguientes cables al chip. Una vez que todas las conexiones al chip hayan sido hechas, podemos empezar a escribir nuestro programa. El QT118 enviará una señal de 5V cuando sea tocado. Nosotros podemos leer esta señal en ambos pines, analógicos y digitales, pero si tienes pines digitales disponibles, no tiene sentido usar pines analógicos ya que la señal solo será leida como 0 (el chip no es tocado) o 1023 (el chip es tocado). El siguiente programa es un sketch simple de como encender el LED de la placa cuando el bordado es tocado:

int ledPin = 13;
        /* el LED en el Arduino */
int touchChip = 2;
        /* conecta la señal de salida del chip táctil al pin 2 */
void setup(){
        pinMode(ledPin, OUTPUT);
        /* declara ledPin como OUTPUT */
        pinMode(touchChip, INPUT);
        /* declara touchChip como INPUT */
}

void loop(){
        if (digitalRead(touchChip) == HIGH){
        /* comprueba si el bordado es tocado */
        digitalWrite(ledPin, HIGH);
        /* si es así, encender el LED */
        }else{
        digitalWrite(ledPin, LOW);
        /* sino, apagar el LED */
}}

Una vez acabado el código, podemos subirlo a la placa. Entonces conectamos el bordado al el chip como en la ilustración. El bordado será sensible en ambos lados, por eso, si quieres se capaz de llevar un bordado sensible necesitas poner algo de tela protectora dentro de tu prenda. Podrías experimentar con algunos tejidos para ver cual es suficientemente grueso para tu bordado y asegurarte que la tela que estás usando no es conductora.

5: Músculo artificial

Usar músculos artificiales es una forma muy conveniente de crear movimiento en telas sin tener que incorporar pesados motores. Los músculos artificiales están hechos de un metal llamado Nitinol que puede recordar una forma. Cuando tu calientas el cable con un secador de pelo o con electricidad, él vuelve a al forma que se le hizo recordar. Mira si puedes conseguir cable que haya sido entrenado para contraerse en forma de espiral, porque esta forma será la que genere mayor movimiento.

Cose el músculo artificial a mano en la tela. Usa una tela fina, un pequeña pieza de tela o una pieza de tela que solo esté conectada en un lado, como un cordón. Esto asegurará que cuando el cables esté activado, tu todavía podrás el movimiento de la tela cuando estés un podo alejado de él. El músculo artificial no puede ser soldado, así que las anillas son usadas para conectar ambos lados del músculo artificial a los cables normales. Para hacer una conexión sólida pon una lado del músculo artificial y cable normal a través de una anilla y, usando unas tenazas planas, aprétalos juntos.

Comprueba que ambos cables no se escapan de la anilla chafada. Los músculos artificales usan mucha corriente, más que el Arduino puede suministrar. Para que el Arduino pueda encender el músculo artificial desde uno de sus pines tienes que usar un transistor. La ilustración muestra como concetar un músculo artificial a los cables normales, y los cables normales al transistor y al Arduino. Usa este código para hacer que la tela se mueva:

int musclePin = 13;
void setup(){
        pinMode(musclePin, OUTPUT);
}

void loop(){
        digitalWrite(musclePin, HIGH);
        /* enciende el pin para hacer que el músculo artificial se caliente y se contraiga a su forma aprendida */
        delay(4000);
        /* primer retardo */
        digitalWrite(musclePin, LOW);
        /* apaga el pin para permitir al músculo artificial enfriarse y contraerse */
        delay(4000);
        /* segundo retardo */
}

Los músculos artificiales con un grosor de 0.15mm solo tienen un sutil efecto en la mayoría de telas, porque no es muy fuerte. Un músculo artificial más grueso tiene un efecto mayor, pero también necesita más corriente. Si eliges usar un músculo artificial más grueso de 0.15mm asegúrate de que no lo dejas encendida mucho tiempo, ya que podrías sobrecalentarlo.

Los músculos artificiales de 0.15mm o más finos no tienen este problema, y pueden dejarse encendidos el tiempo que se quiera. Si quieres mover un músculo artificial más largo de 25 cm en este ejemplo, necesitas ajustar el primer retardo en el código. Una cable más larto necesita más tiempo para calentarse. Esto significa que en vez de 4000 milisegundos, el retardo podría necesitar ser de 6000 milisegundos. Busca el valor que necesitas para tu configuración probando diferentes retardos. Sabrás que tienes el retardo correcto cuando veas el músculo artificial contraerse totalmente a su forma más pequeña.

Como el músculo artificial se moverá, no es convenientes hacer una conexión eléctrica con hilo conductor ya que el cable mismo puede moverse. Otra razón para no usar hilo conductor es que es resistivo. Un hilo conductor puede facilmente ser más resistivo que el músculo artificial. Esto significa que si tu usas hilo conductor en lugar de cables normales, podrías no conseguir calentar el músculo artificial, porque estarías calentando también el hilo conductor. En general necesitas tener cuidado con el hilo conductor y con grandes corrientes ya que podrías prender fuego a tus prendas.

Share