Página a revisar.

Capítulo 5: Usando Pines digitales


 Como se explicó en el capítulo 2, los pines digitales en el Arduino solo tienen dos estados, o están en On o en Off. El comando actual para estos dos estados en el Arduino es 1 para on y 0 para off, y esto es por lo que los llamamos pines digitales. Normalmente usamos las constantes HIGH y LOW ya que hacen más fácil leer el código comparado con usar 0 y 1. Recuerda que los pines digitales siempre dan una potencia de salida de 5V cuando están en HIGH y 0V cuando están en LOW. No conectes nada directamente a los pines digitales a menos que estés seguro que puede manejar 5V.

1: Prototipado textil con LEDs

Cosiendo un LED

Este dibujo ilustra como coser tu circuito a una pieza de tela. Tu puedes usar cualquier pieza de tela siempre que no sea conductiva. En este ejemplo hemos hecho unos círculos en las patas de una resistencia y círculos y cuadrados en las patas del LED. Esto no es solo por razones cosméticas, es también práctico – hace más fácil coser los componentes en su sitio y las diferentes formas son también buenas para mantener la pista de las patas largas y cortas del LED. Para la conexión del voltaje y la tierra hemos usado cables, cosidos en su lugar con hilo conductor. Esta es una buena técnica para usar mientras pruebas tu prototipo. Para prototipos finales es recomendado el coser tu placa arduino en la tela. Dependiendo de tu diseño el camino del hilo conductor desde tu Arduino hasta tu LED puede ser tan largo que no necesites la resistencia de 220 Ω en tu circuito. Mide la resistencia de tu camino de hilo conductor y mira si es suficientemente largo para reemplazar a la resistencia.

Programando un LED parpadeante

Antes de conectar tu Arduino tu puedes probar si tu código funciona y que no hay no daños a tu placa Arduino. El Arduino tiene una pequeño LED incorporado junto al pin digital 13 al que está conectado, así, el código siguiente debería hacerlo parpadear:

int ledPin = 13;
        /* una variable entero para el LED conectado al pin digital 13 */

void setup(){
        pinMode(ledPin,OUTPUT);
        /* configura el ledPin como salida */
}

void loop(){
        digitalWrite(ledPin,HIGH);
        /* enciende el ledPin */
        delay(1000);
        /* espera un segundo */
        digitalWrite(ledPin,LOW);
        /* apaga el ledPin */
        delay(1000);
        /* espera un segundo */
}

Este programa encenderá el LED durante un segundo, entonces lo apagará durante otro segundo y volverá a comenzar. Una vez has escrito el programa en el IDE de Arduino, pulsa el botón de verificar y el mensaje “Done compiling” debería aparecer en la ventana negra.

Si no hay errores de compilación comprueba que tienes seleccionado el Puerto Serie y la placa correctos en el menu tools. El paso siguiente es subir el código a tu placa Arduino pulsando el botón upload. Hay dos LEDs en el arduino: RX y TX. Cada vez que tu intentes subir un programa al Arduino estos dos LEDs deberían empezar a parpadear. Si no lo hacen, mira en el menu tools y comprueba que están seleccionados el Puerto serie y la placa correctos.

Si no hay errores en la subida, el programa está ahora almacenado en la memoria del Arduino y ahí se quedará hasta que lo reemplaces por otro nuevo y después de 5 segundos el programa empezará. Si el LED al lado del pin 13 de la placa empieza a parpadear es seguro asumir que el programa fue correctamente subido y que no hay nada mal en la placa Arduino. Este programa de LED parpadeante es bueno para usarlo si experimentas problemas mientras estás haciendo prototips y quieres excluir un fallo del hardware de la lista de posibles problemas.

Ahora es seguro conectar el arduino a tu circuito textil. En el siguiente dibujo hemos usado rojo para el cable que va del pin 13 y negro para el cable que vuelve hacia el puerto GND en el Arduino.

Así es como comunmente codificarás con colores los cables mientras trabajas con electrónica. El rojo es usado para marcar un cable que conecta a la colrriente y el negro es usado para marcar los cables como tierra. Todos los siguientes ejemplos usados en este libro seguirán el mismo esquema de colores. Notar que los cables rojos no siempre conectan a pines digitales. En este ejemplo estamos cambiando 5V on y off en los pines digitales y por eso hemos usado el rojo para marcar el cable.

'Programando un LED desvaneciente

En el ejemplo previo hemos cambiado un LED entre on y off. Como habrás notado, el led estuvo puesto al máximo en on (reducido a 5V con una resistencia) y luego a completamente off (0V). Como hemos mencionado antes, los pines digitales solo tienen dos modos, HIGH y LOW. Pero los pines digitales 3,5,6,9,10 y 11 tienen una función especial llamada PWM. Con el modo PWM podemos transformar los 5V de salida en un rango de 255 posibles niveles. Para aprender más acerca de la función PWM ir a la página 97. En el siguiente ejemplo vamos a probar como desvanecer un LED hacia arriba y abajo:

int ledPin = 5;
        /* conecta tu led al pin digital 5 */

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

void loop(){
        for(int i = 0; i < 255; i++){
        /* mientras que i sea menor que 255, incrementar i en una unidad        */
        analogWrite( ledPin , i );
        /* desvanecer el led a  i */
        delay(30);
        /* pequeña pausa para que podamos ver cada paso */
}

for(int i = 255; i > 0; i--){
        /* mientras que i sea mayor que 0, decrementar i en una unidad */
        analogWrite(ledPin,i);
        /* desvanecer el led a  i */
        delay(30);
        /* pequeña pausa para que podamos ver cada paso */
}}

En el ejemplo anterior estamos usando el comando analogWrite(), el cual es el comando para PWM en el LED. También usamos dos bucles for, el primero comienza contando desde 0 hasta 255. Para cada iteración se incrementa el voltage en el LED. En lugar de ir directamente de 0V a 5V, va de 0V a 5V en 255 pasos, lo que causa que el led se desvanezca. El segundo bucle for hace lo contrario, va de 5V a 0V en 255 pasos. El retraso de 30 milisegundos nos da tiempo a ver los pasos.

Ahora podemos conectar el led como hicimos en el ejemplo previo, subir el código a la placa arduino y disfrutar del desvanecimiento. Deberías poder ver como el LED se desvanece arriba y abajo una y otra vez.

2: Botón pulsador

Hay diferentes formas de hacer tus propios botones pulsadores. Todas ellas están basadas en el principio de crear un circuito desde y hacia el Arduino con un punto de ruptura en alguna parte del circuito. Un punto de ruptura es donde podemos reconectar el circuito, pudiendo determinar si el botón pulsador están pulsado o no.

Para hacer este botón pulsador, comienza cortando dos pequeños trozos de tela conductora y pégalos en dos piezas separadas de tela no conductora. Entonces cose un cable hasta el final de ambas piezas y cose una conexión a cada una de las telas conductoras.

Toma una pieza de espuma y corta un agujer a través. Si no tienes espuma puedes usar un puñado de capas de tela normal. Una vez el agujero está cortado, péga una de las telas conductoras en cada lado de la espuma:

Cuando tengas el botón pulsador preparado podemos comenzar con el programa:

int myButton = 4;
        /* declara el pin digital 4 en el Arduino como myButton */
int ledPin = 13;       
        /* declara el pin digital 13 en el Arduino como ledPin */

void setup(){
        pinMode(ledPin,OUTPUT);
        /* poner ledPin como OUTPUT */
        pinMode(myButton,INPUT);
        /* poner myButton como INPUT */
        digitalWrite(myButton,HIGH);
        /* activar la resistencia interna en el pin 4 */
}

void loop(){
        if(digitalRead(myButton) == LOW ){
        /* comprueba si el botón ha sido pulsado */   
        digitalWrite(ledPin,HIGH);
        /* si el botón es pulsado, iluminar el led */
        }else{
        digitalWrite(ledPin,LOW);
        /*  si el botón no es pulsado, apagar el led */
}}

Ahora subimos el programa a nuestra placa arduino y conectamos el botón pulsador. Un final se conecta al pin digital 4 y el otro es conectado al puerto GND. El programa de arriba comprobará si el botón pulsador el pulsado y encenderá el LED al lado del pin 13. Si el botón no es pulsado el LED permanecerá apagado.

3: Botón pulsador oculto

Las siguientes son dos formas simples de hacer botónes pulsadores ocultos, los cuales son apropiados cuando necesitas una entrada discreta en una prenda. Puedes usar el mismo código de arriba para probarlo. El primero está hecho con dos botónes de metales que pueden ser comprados en cualquier mercería. Cose los botónes en el lugar usando hilo conductor y conecta dos cables al final.

Le último botón oculto es hecho como un botón normal . El truco es usar otra vez hilo conductor para coser el botón en el lugar y coser alrededor del agujero del botón usando el mismo hilo. La mayor parte de las máquinas de coser modernas tienen una función preprogramada para hacer agujeros de botón y funcionará perfectamente para esto. Solo carga tu máquina con hilo conductor y corta un agujero en la tela. Este ejemplo funciona igualmente con botón de coser o de jeans.

En estos ejemplos hemos puesto cables al final para hacer más fácil el testeo rápido. Para finalizar los prototipos cosemos cada botón con hilo conductor hasta nuestro Arduino.

4: Sonido

La forma más sencilla de hacer sonido con el arduino es usar un altavoz piezoelectrico. La piezoelectricidad es la abilidad de los materiales de generar un campo eléctrico en respuesta a una excitación mecánica. Un altavoz piezoeléctrico consiste de dos placas metálicas, y cuando la electricidad es aplicada al altavoz piezoeléctrico, se causa que el metal se atraigan y se repelan, generando rápidas vibraciones las cuales se vuelven sonido. Los altavoces piezoeléctricos están disponibles en una amplia variedad de tamaños y formas. En el ejemplos solo vamos a usar la membrana del alatavoz piezoelectrico. Puedes comprar altavoces piezoeléctricos de membrana en la mayoría de tiendas de electrónica o puedes romper la carcasa de un altavoz piezoeléctrico y sacarlo. Si eliges romper uno, ten cuidad de no doblar la membrana mientras lo extraes. Una vez tengas la membrana, comienza a preparar una pieza de tela.

Cose dos cables de longitud 1/3 el ancho de cada lado de la tecla. Pega el final de el cable sin el plástico protector con el hilo conductor, y entonces cose la parte restante del cable con hilo normal. No uses hilo conductor cuando juntes el resto del cable con la prenda ya que puede crear un cortocircuito una vez que el altavoz piezoeléctrico esté en su lugar. Las uniones con hilo normal sirven para mantener los cables en su sitio. Coloca el elemento sobre un lado y dobla el otro lado sobre el, y une todo junto con hilo normal. Es aconsejable coser alrededor de la membrana, ya que necesita estár ajustado para conectar los cables en ambos lados de la membrana.

Ahora tenemos un altavoz piezo que es más flexible que uno normal, y podemos empezar con algunos programas para generar sonidos. Para hacer las vibraciones que generarán el sonido vamos a pulsar el piezo con tensión. Para hacer estos pulsos lo suficientemente rápido para generar vibrarciones no podemos usar el delay() normal, ya que la pausa no es suficientemente rápida.

En su lugar vamos a usar delayMicroseconds(). En el siguiente ejemplo vamos a generar una vibración que crea el tono A:

int piezoPin = 9;
        /* conecta el piezo al pin 9 */

void setup(){
        pinMode( piezoPin,OUTPUT);     
        /* declara el pin del piezo como salida */
}

void loop(){
        digitalWrite(piezoPin,HIGH);
        delayMicroseconds(1136);
        /* el tiempo aquí determinará el tono */
        digitalWrite(piezoPin,LOW);
        delayMicroseconds(1136);
        /* el tiempo aquí determinará el tono */
}

En el ejemplo anterior conectamos y desconectamos el piezo a 5V y entre medias ponemos una pausa de 1136 microsegundos. Esta pausa es lo que determina que tono es generado. Si por ejemplo nosotros hacemos una pausa de 1911 microsegundos, podríamos en su lugar obtener el tono C.

5: Sensor de inclinación

Comienza conectando el sensor de inclinación y una resistencia de 1kΩ a una pieza de tela. Usando hilo normal, cose unas pocas vueltas sobre el sensor de inclinación para mantenerlo en su sitio. Une tres cables a la tela usando hilo conductor y haz las siguientes conexiones según muestra la siguiente ilustración:

Ahora podemos empezar con nuestro programa. En este programa vamos a encender el LED de la placa del Arduino cuando inclinamos el sensor.

int myTilt = 4;
        /* declarar el pin para el sensor de inclinación */
int ledPin = 13;
        /* declarar el pin para el led de la placa */
int tiltStatus = 0;
        /* declarar la variable para almacenar la inclinación del sensor */

void setup(){
        pinMode(myTilt,INPUT);
        /* declarar el pin de inclinación como INPUT */
        pinMode(ledPin,OUTPUT);
        /* declarar el pin del LED como OUTPUT */
}

void loop(){
        tiltStatus = digitalRead(myTilt);
        /* leer el pin de inclinación y almacenar su valor */
        if(tiltStatus == HIGH){
        /* comprobar si el sensor de inclinación está inclinado */
        digitalWrite(ledPin,HIGH);
        /* encender el LED si el sensor está inclinado */
        }else{
        digitalWrite(ledPin,LOW);
        /* apagar el LED en cualquier otro caso */
}}

Una vez que has acabado con el código, subelo a la placa Arduino y conecta el sensor de inclinación como se muestra en la ilustración de la página anterior. Ahora cuando inclinas la tela el LED anexo al pin 13 de la placa Ardunio debería encenderse. Como se describe en la seción del sensor de inclinación del Capítulo 2 página 27, puedes usar este tipo de sensor de inclinación para detectar movimiento. Es una cuestión de estimar cuantos hits obtienes del sensor de inclinación durante un cierto tiempo. Digamos que el sensor de inclinación cambia de on a off 2 veces por segundo, entonces es seguro asumir que la prenda en la cual el sensor está puesto se está moviendo.

6: La cremallera digital

Hay dos formas en las que podemos usar una cremallera metálica como sensor de entrada. La diferencia entre ellas es como las leemos desde el Arduino. En este capítulo vamos a leer nuestra cremallera de forma digital. La ventaja de usar esta cremallera comparado con la cremallera digital de la página 51-54, es que la cremallera digital será más precisa en sus lecturas pero la desventaja es que tendremos un rango menor de valores para leer. El rango dependerá de cuandos pines digitales uses. En este ejemplo vamos a usar seis de los pines digitales de nuestro Arduino.

Comienza cosiendo un cable rojo al final de un lado de la cremallera con algo de hilo conductor. Entonces pon una resistencia de 10kΩ en el otro extremo del cable rojo. Haz una conexión con hilo conductor desde el otro lado de la resistencia y desde el mismo lado de la cremallera hasta arriba. Asegurate de que lo coses entre todos los dientes de la cremallera. En el otro lado de la cremallera cose seis cables al lado. Una vez que los seis cables estén en su lugar comienza a coser una linea desde el cable hasta el diente de metal de la cremallera y haz unas pocas costuras entre el diente, hacia arriba, en la cremallera.

Asegurate de dejar un hueco entre las costuras de un cable al siguiente. Ninguno de los seis cables debería estar conectado a otro con hilo conductor. Una vez que la cremallera está cosida podemos comenzar con nuestro código:

int pin2 = 2; // declaración de pin digital
int pin3 = 3; // declaración de pin digital
int pin4 = 4; // declaración de pin digital

int pin5 = 5; // declaración de pin digital
int pin6 = 6; // declaración de pin digital
int pin7 = 7; // declaración de pin digital


void setup(){
        pinMode(pin2,INPUT);
        /* pone el modo del pin a INPUT */
        pinMode(pin3,INPUT);
        /* pone el modo del pin a INPUT */
        pinMode(pin4,INPUT);
        /* pone el modo del pin a INPUT */
        pinMode(pin5,INPUT);
        /* pone el modo del pin a INPUT */
        pinMode(pin6,INPUT);
        /* pone el modo del pin a INPUT */
        pinMode(pin7,INPUT);
        /* pone el modo del pin a INPUT */
        Serial.begin(9600);
        /* comienza la comunicación serie y establece la velocidad en 9600 baud */
}
void loop(){
        if(digitalRead(pin2) == HIGH){
        /* comprueba si el pin está en HIGH */
        Serial.println(2);
        /* si está, envía el número de ese pin */
}
if(digitalRead(pin3) == HIGH){
        /* comprueba si el pin está en HIGH */
        Serial.println(3);
        /* si está, envía el número de ese pin */
}

if(digitalRead(pin4) == HIGH){
        /* comprueba si el pin está en HIGH */
        Serial.println(4);
        /* si está, envía el número de ese pin */
}
if( digitalRead(pin5) == HIGH){
        /* comprueba si el pin está en HIGH */
        Serial.println(5);
        /* si está, envía el número de ese pin */
}
if( digitalRead(pin6) == HIGH){
        /* comprueba si el pin está en HIGH */
        Serial.println(6);
        /* si está, envía el número de ese pin */
}

if(digitalRead(pin7) == HIGH){
        /* comprueba si el pin está en HIGH */
        Serial.println(7);
        /* si está, envía el número de ese pin */
}

delay(200);
        /* hace una pausa */
}

Sube el código a tu placa Arduino y conecta la cremallera. El cable rojo va a el pin de 5V de la placa y el resto de los cables se conectan a los pines digitales 2 a 7. Una vez que todo esté en su lugar puedes abrir el monitor del puerto serie y probar tu cremallera. Moviendo arriba y abajo, deberías obtener números del 2 al 7 en el Arduino. Lo que estamos haciendo aquí es medir donde está localizada la cabeza da la cremallera, ya que conecta 5Va un pin digital, enviando la corriente a ese pin, haciendo el valor HIGH y entonces, en el código, transformando esa información en un número, diciéndonos cual de los pines está comunicando.

Share