El H Bridge L293D

El L293D, es un pequeño integrado que incluye dos puentes H-Bridge que podemos usar para gobernar simultáneamente dos motores.


Si buscáis el manual del L293D, veréis que aunque el funciona a 5V internamente, puede conmutar tensiones de hasta 36V para tus motores.

El patillaje del chip es así:

Veamos que son los diferentes pines del L293D:
  • El pin 16, Vcc1, son los 5V con los que alimentamos el chip y el pin 8, Vcc2, es la tensión con la que alimentamos el motor. 
  • Los pines del 1 al 7 controlan el primer motor y los pines 9 a 15 controlan el segundo motor. 
  • El pin 1, Enable1, Activa el uso del motor 1. Con un valor HIGH, el motor puede girar dependiendo del valor de 1A y 2A. Si es LOW se para independientemente de los valores del resto de pines 
  • Los pines 2 y 7 son los pines de control para el motor 1, e irán conectados a nuestros Arduino para controlar el sentido de giro.
  • Los pines 3 y 6 son la salida a la que se conecta el motor 1, cuya polaridad se invierte en función los valores de 2 y 7. En el diagrama de arriba veis que hay pines equivalentes para el motor 2 y cuales son. 
  • Los pines 4, 5,12 y 13 van a GND.

Podemos hacer una tabla para mostrar la lógica que sigue el giro del motor en función de los tres pines:

Por tanto tenemos que activar el pin enable para que el motor gire y después usamos los pines Input1 e Input2 con valores opuestos para hacer girar el motor en una dirección o en la contraria. Veamos cómo hacer el montaje con Arduino.

Esquema de protoboard

El diagrama de protoboard del chip L293D a nuestro Arduino será algo así:

El programa que vamos a usar para controlar este motor será el siguiente:

Vamos a usar los 3 pines de la tabla anterior. Arduino Pin 10 es el enable del

Motor 1 y usamos los pines 8 y 9 para controlar el sentido de giro. Por tanto:

//Control del sentido de giro de un motor de CC

#define E1 10 // Enable Pin para el motor 1
#define I1 8 // Control pin 1 para el motor 1
#define I2 9 // Control pin 2 para el motor 1

void setup()
 {
   for (int i=8; i<=11; i++)
   pinMode (i, OUTPUT);
 }

void loop ()
{
digitalWrite (E1, HIGH); //Activar el motor 1
digitalWrite (I1, HIGH);  //Iniciar el giro
digitalWrite (I2, LOW);
delay (3000);

digitalWrite (E1, LOW); //Parar el motor 1
delay (1000);

digitalWrite (E1, HIGH); //Activar el motor 1

digitalWrite (I1, HIGH);  //Iniciar el giro con cambio de dirección
digitalWrite (I2, LOW);
delay (3000);


digitalWrite (E1, LOW); //Parar el motor 1
delay (1000);
}

Descripción del programa

Activar el Enable1 para arrancar Motor 1, y luego usar I1 e I2 con valores invertidos. El motor arranca y se para a los 3 segundos. Transcurrido un segundo se activa de nuevo el Enable1 y al intercambiar los valores de I1 e I2 el giro del motor se inicia y en la dirección contraria.

En el taller de tecnología el control del sentido de giro de un motor de CC, se usa en multitud de ocasiones, he aquí un ejemplo de una grúa construida con barritas de papel reciclado, automatizada con Arduino y un L293D.

Para el control del sentido de giro del motor (subida o bajada), se han utilizado dos pulsadores.



Programa


//Control del sentido de giro de un motor de CC

#define E1 10 // Enable Pin para el motor 1
#define I1 8 // Control pin 1 para el motor 1
#define I2 9 // Control pin 2 para el motor 1
int estadoPulsadorSubir=0;
int estadoPulsadorBajar=0;
int pinPulsadorSubir=0;
int pinPulsadorSubir=0;

void setup()
 {
   for (int i=8; i<=11; i++)
   pinMode (i, OUTPUT);

 }
pinMode (pinPulsadorSubir, INPUT);
pinMode (pinPulsadorBajar, INPUT);
}
void loop()
{
estadoPulsadorSubir = digitalRead (pinPulsadorSubir); //Leer estado del pusador de subida
estadoPulsadorBajar = digitalRead (pinPulsadorBajar); //Leer estado del pusador de bajada

if ( estadoPulsadorSubir == HIGH && estadoPulsadorBajar == LOW )
 {
   while (estadoPulsadorSubir==HIGH)
   {
    digitalWrite(E1, HIGH); //Activamos giro de subida
    digitalWrite(I1, HIGH); //Se inicia la subida

    digitalWrite(I2, LOW); //Activamos giro de subida
    estadoPulsadorSubir = digitalRead (pinPulsadorSubir);
   }
 }

if ( estadoPulsadorSubir == LOW && estadoPulsadorBajar == HIGH )
 {
   while (estadoPulsadorSubir==HIGH)
   {
    digitalWrite(E1, HIGH); //Activamos giro de subida
    digitalWrite(I1, LOW); //Se inicia la subida

    digitalWrite(I2, HIGH); //Activamos giro de subida
    estadoPulsadorBajar = digitalRead (pinPulsadorSubir);
   }
 }
 digitalWrite(E1, LOW); //Motor desactivado
}

¿Cómo configuramos los pulsadores?

Los  pulsadores

Una señal digital solo tiene dos estados: un valor inferior de tensión 0 V, al que se le asocia el valor lógico LOW o 0; y un valor superior de tensión 5 V, al que se le asocia un valor lógico HIGH o 1.


Los pulsadores producen una entrada digital porque esta puede valer 0 o 1. Su funcionamiento es muy sencillo.

¿Cómo configuramos los pulsadores?

Para utilizar los pulsadores en nuestra placa Arduino, lo primero que hay que hacer es conectar el pulsador a un pin digital por un lado  y a un valor de tensión 0V o 5V por el otro:

Cada vez que accionamos el pulsador el pin 8, queda conectado a un valor alto, 5V.



¿Qué pasa en el pin 8 cuando en ninguno de los dos circuitos accionamos el pulsador?  Si no se acciona el pulsado, el pin 8 se queda sin conexión, al aire y, por tanto, en una situación indeterminada. Unas veces prevalecerá el 1; y otras, el nivel 0.
Esta situación no es deseable y se soluciona añadiendo una resistencia y forzando una tensión en la situación en que el pulsador no está accionado. Si esta resistencia se conecta a 5V,  se llama pull-up; y si se conecta a tierra o a 0V, se llama pull-down.




Las resistencia pull-down y pull-up se conecta entre el  pin digital y una de las tensiones de referencia (0V o 5V) y fuerza el valor de la tensión a 0V o 5V, respectivamente, en caso de no estar activado el pulsador.

Por ejemplo, en la resistencia pull-up, cuando el pulsador está pulsado, no circula intensidad por ella, ya que no hay camino de la corriente hacia tierra. Por ello, en los dos extremos de la resistencia tendremos 5V. Cuando se acciona el pulsador, la corriente atraviesa la resistencia pull-up, los 5V caen en la resistencia, y el extremo que está unido al pin 8 queda conectado a tierra, es decir, a 0V.

Ejemplo

Encender un led con un pulsador

Material necesario

  • Placa protoboard.
  • Diodo led.
  • Resistencia 220 ohmios.
  • Resistencia de 10 k ohmios.
  • Cables de conexión.
  • Pulsador.

1.- Realiza el montaje que se ve en la imagen. Observa que uno de los terminales del pulsador está conectado mediante el cable rojo a 5V; y el otro está conectado a una resistencia de 10K y, a la vez mediante el cable azul, al pin digital 8 de la placa Arduino. La resistencia va conectada a tierra (GND) a través del cable negro.


Por último, el led rojo se conecta con su cátodo ( patilla corta) a una resistencia de 220 ohmios esta a tierra y su ánodo (patilla larga) al pin digital 9.

2.- Conecta la placa al ordenador

3.- Ejecuta el IDE  de Arduino y escribe este código para que, al activar el pulsador se encienda el diodo led:

Código
 
//Encender un led, al acccionar un pulsador

int pinPulsador=8; // Declaramos la variable pinPulsador con el número del pin en qué está conectado
int pinDiodo=9;  //   Igual para el pin del diodo
int estadoDiodo=0; // Estado del diodo


void setup() {
pinMode(pinPulsador, INPUT); // Inicializa el pin  8 como entrada
pinMode(9, OUTPUT); //Inicializa el pin 9 como salida
}

void loop() {

  estadoDiodo = digitalRead(pinPulsador); // Lee el valor del pin del pulsador y lo almacena en la variable pinPulsador
   if(estadoDiodo == HIGH) { // Comprueba el estado del pulsador está pulsado
     digitalWrite(pinDiodo, HIGH); // Si es así activa el diodo
   } else {
     digitalWrite(pinDiodo, LOW); // Si no, lo mantiene apagado
   }
}

Control de motor de corriente continua con transistor


En este proyecto vamos a mover un motor de corriente continua, motor DC, usando un transistor. Los pines del Arduino sólo nos pueden proporcionar 5 V y a lo más 40 miliamperios de corriente, lo cual es insuficiente para motores de este tipo. Si intentamos usar un motor DC directamente desde un pin del Arduino, podríamos dañar el microcontrolador, por lo que vamos a usar un transistor para hacerlo.
Vamos a usar el transistor 2N222 que es un transistor que por sus características y precio es muy utilizado como un switch para el manejo de un motor DC y el montaje será el siguiente:

Para activar el motor vamos a usar un pulsador. Cuando presionemos el pulsador, la placa Arduino activará el transistor, con lo cual se girará el motor.


Componentes
  • Arduino
  • Placa protoboard.
  • Transistor 2N222.
  • Resistencia de 220 (rojo, rojo, marrón).
  • Diodo rectificador 1N4001.
  • Pulsador.
  • una resistencia de 10 K (marrón, negro, naranja)


Circuito
El transistor es un componente electrónico con tres patas; el colector, el emisor y la base.
En el 2N222, viéndolo de frente, la patilla izquierda es el emisor, que conectamos a masa (GND). La patilla central es la base, que conectamos al pin de Arduino y la patilla derecha es el colector, que conectamos al borne del motor.
La conexión al pin de Arduino, usado para activar el transistor, la hacemos a través de una resistencia, para limitar la corriente de salida del este pin. Una resistencia de 220 es suficiente, dado que la tensión de alimentación va a ser de 4,5 V.
El circuito del motor tenemos que conectarlo a una fuente externa de alimentación, ya que no podemos usar el Arduino para esto. Conectaremos uno de los cables del motor al positivo de la fuente de alimentación y el otro cable, como ya habíamos dicho, al colector del transistor, la patilla de la derecha.
Como el circuito que estamos controlando es un motor, al detenerse puede generar un voltaje que dañaría nuestro transistor y también el Arduino, por esto es muy conveniente agregar un diodo, tipo 1N4001 entre el colector y el emisor.

El pulsador para activar el motor lo conectaremos al pin 8 del Arduino con una resistencia pull-down a tierra.



Código

// Control de un motor DC con un transistor
// Activamos y desactivamos con un sensor digital

int pinPulsador = 8; // Declaramos la variable pinPulsador con el número del pin en qué está conectado

int pinMotor = 9;  //Igual para el pin del motor


int estadoMotor = 0; // para guardar el estado del sensor

void setup() {
   pinMode(pinMotor, OUTPUT); //Inicializa el pin del motor como salida
   pinMode(pinSensor, INPUT); //Inicializa el pin del pulsador como entrada
   digitalWrite(pinMotor, LOW); //Activamos el estado de reposo para el motor
}

void loop() {
   estadoMotor = digitalRead(pinPulsador); // Lee el valor del pin del pulsador y lo almacena en la variable pinPulsador
   if(estadoMotor == HIGH) { // Comprueba el estado del pulsador está pulsado
     digitalWrite(pinMotor, HIGH); // Si es así activa el motor
   } else {
     digitalWrite(pinMotor, LOW); // Si no, lo mantiene en reposo
   }
}



Cómo encolar piezas de madera

En el aula de tecnología utilizaremos cola blanca para unir las piezas de madera, derivados de la madera y cartón. Después de utilizar diferentes marcas de cola blanca para madera, hemos elegido la cola de Carrefour, por los siguientes motivos: permiten realizar uniones duraderas y resistentes y el envase es ideal para su manejo.

Lo primero que haremos antes de utilizar un adhesivo es leer las indicaciones del fabricante, en el caso de la cola de Carrefour son las siguientes:

La cola de carpintero Carrefour permite unir rápidamente todo tipo de madera y derivados sin dejar huellas. Se usa en madera derivados de la madera, cartón y papel.
Modo de empleo
Los soportes deben estar limpio, secos y ligados.
  1. Aplicar una capa fina de cola en una de las superficies que se quiera unir. En superficies grandes extender con ayuda de un pincel.
  2. Unir las piezas y presionar fuertemente. Se pueden reposicionar las piezas durante 5 min .  Dejar secar 10 min. La resistencia máxima se obtiene después de 24 h

Consejos de limpieza
Si la cola todavía está fresca, lavar con agua con agu, preferiblemente caliente. Siesta sec, lavar con agua caliente y vinagre blanco. .
Conservación: Guardar el producto en un lugar fresco

Cómo encolar piezas de madera


Para realizar un buen  encolado es necesario seguir los siguientes pasos:

1.- Se eliminan los restos que tenga la madera, empleando para ello papel de  hija.
2.- Se extiende la cola uniformemente con un pincel o brocha.





3.- Se prensan las piezas con mordazas o sargentos. Es necesario proteger las piezas para que no queden marcas.


4.- Se eliminan los excedentes de cola con un trapo húmedo. En el caso de la imagen se retira la cola con ayuda de un formón.


Led RGB

Un led RGB es la unión de tres leds de colores básicos: rojo, verde y azul, en un mismo encapsulado común, puedes considerar un led RGB como tres leds de colores rojo, verde y azul.

Led RGB

 Ánodo y cátodo.

Todos los leds constan de ánodo y cátodo. El ánodo es el “polo” positivo y el cátodo el negativo. Esto quiere decir que, en el caso de Arduino, el ánodo será la patilla que esté asociada al pin 5V y el cátodo irá a GND. 

Hay leds de cátodo común o de ánodo común.




Montaje básico del led RGB de ánodo común.

 Ahora que conoces un poco mejor las características de tu led RGB, vamos a ver cómo se realizaría un montaje básico.
  1.  La patilla correspondiente al ánodo la podrás identificar fácilmente porque su tamaño es mayor que las demás. Esta patilla es la que debes conectar al pin 5V de tu placa. Aunque también puedes conectar esta patilla a una salida digital, debes tener cuidado ya que éstas te permiten gestionar hasta 20mA (lo que seguramente sea insuficiente para tu LED RGB).
    Esquema led RGB
  2. El resto de patillas (por las que controlarás los colores de tu LED) debe ir asociada a salidas PWM mediante una resistencia (a priori, una de 220Ω por cada patilla debería ser suficiente). Debes tratar tu LED RGB como si fueran tres LEDs distintos, es decir, no basta con poner una única resistencia en el ánodo (patilla común conectada a 5V), lo suyo es que pongas una en cada cátodo.
  3. Las salidas PWM (ancho de pulso modulado) que vienen representadas en tu Arduino con el símbolo “~”, proporcionan 5V (al igual que el resto de salidas digitales) con la diferencia de que oscilan su valor entre 0V y 5V al ritmo que tú le indiques mediante la instrucción analogWrite(), consiguiendo así simular valores de voltaje intermedios.
  4. Cuanto mayor sea el valor de tus salidas PWM (cuanto más se aproxime a 5V), menor diferencia de voltaje habrá en tu LED RGB, menor será la corriente que lo atraviese y, por tanto, menos brillará (apagándose el color al que vaya asociada esa salida llegado cierto punto).
  5. Debes tener en cuenta que la caída de voltaje que se produce en la patilla asociada al color rojo es menor, por lo que, si la resistencia es la misma en todas las patillas, circulará más corriente (recuerda aquí el límite de los 20mA). Ésto también quiere decir que el rojo brillará más (aunque como el ojo humano es menos sensible al rojo, esto es un factor positivo).
Conexiones del diodo led RGB  a la placa Arduino

 Código básico de funcionamiento

/* Control Básico De Un LED RGB De Ánodo Común */

//Se definen las variables que se van a utilizar para establecer los
//colores. Éstas deben estar asociadas a pines digitales PWM e irán
//unidas a los cátodos de cada uno de los colores.

int Rojo = 9;
int Verde = 10;
int Azul = 11;

void setup(){

//Se establecen los pines definidos como salidas para poder
//la diferencia de voltaje con respecto a la alimentación común.

pinMode(Rojo, OUTPUT);
pinMode(Verde, OUTPUT);
pinMode(Azul, OUTPUT);

}

//Se crea un módulo auxiliar que facilitará la tarea de establecer
//los voltajes asociados a cada color.
//El valor de las variables R, G y B debe ser un entero entre 0 y 255
//siendo 255 el valor relativo a la máxima luminosidad de cada color.
//Debe tenerse en cuenta que hasta que no se supere el voltaje umbral
//de cada color este no se presentará en el LED RGB.

void EstablecerColor(int R, int G, int B){

//Se utiliza la expresión 255-X para "naturalizar los valores". Dado
//que el mayor brillo está asociado a la mayor diferencia de voltaje
//entre la alimentación y las salidas PWM (lo que implica una salida
//de 0V por el pin PWM, esto es, analogWrite(X, 0);).

analogWrite(Rojo, 255-R);
analogWrite(Verde, 255-G);
analogWrite(Azul, 255-B);

}

void loop(){

//Se representan colores pseudoaleatorios en el LED RGB mediante el
//uso de la instrución random(min,max);.

EstablecerColor(random(127,255), random(127,255), random(127,255));

//Se utiliza un delay para que de tiempo algo observador a apreciar
//los colores.

delay(1000);

}


 Fuente: www.educachip.com

¿Cuándo usamos el bucle for?

La declaración for se usa para repetir un bloque de sentencias un número determinado de veces. Cada vez que se ejecutan las instrucciones del bucle se vuelve a testear la condición. La declaración for tiene tres partes separadas por (;)

Para ello, necesita de una variable con un valor inicial, una condición que debe cumplir esta variable para continuar el bucle, y un incrementador que cambie el valor de la variable.
 
for (variable; condición; incrementador)
 {
   bloque de instrucciones
}

Veamos el ejemplo de su sintaxis:
for (int i=0; i<20 i="" p="">
{
digitalWrite(13, HIGH);
digitalWrite(13, LOW);
}

El ejemplo anterior enciende y apaga un led conectado al pin 13 en un bucle de 20 ejecuciones. Al inicio del bucle se declara una variable entera "i" cuyo valor inicial =0. Justo después se indica que el bucle se ejecutará hasta que la variable "i" tenga un valor inferior a 20 y finalmente se indica cuanto se incrementa la variable cada vez que se repita el bucle. (++ en programación equivale a +1, es decir, la variable pasa a valer un entero mas cada vez que se ejecuta el bucle).

Kit de Luces de Auto Fantastico

Monta el circuito según la imagen. Conecta las patillas largas (ánodos) de los leds a los pines 13,12,11,10,9,8,7,6 de la placa Arduino (salidas digitales). Las patillas cortas (cátodos) se conectan con las resistencias  y estas van todas conectadas a tierra (GND).
Circuito luces Kit

El código del programa será el siguiente:


/*
Luces del coche fantástico.

*/

void setup()
 {
// Inicializar los pins digitales como salidas.
  pinMode(13, OUTPUT);
  pinMode(12, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(10, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(6, OUTPUT);
}

void loop()
 {
   digitalWrite(13, HIGH);
   delay(10);
   digitalWrite(13, LOW);
   delay(10);
   digitalWrite(12, HIGH);
   delay(10);
   digitalWrite(12, LOW);
   delay(10);
   digitalWrite(11, HIGH);
   delay(10);
   digitalWrite(11, LOW);
   delay(10);
   digitalWrite(10, HIGH);
   delay(10);
   digitalWrite(10, LOW);
   delay(10);
   digitalWrite(9, HIGH);
   delay(10);
   digitalWrite(9, LOW);
   delay(10);
   digitalWrite(8, HIGH);
   delay(10);
   digitalWrite(8, LOW);
   delay(10);
   digitalWrite(7, HIGH);
   delay(10);
   digitalWrite(7, LOW);
   delay(10);
   digitalWrite(6, HIGH);
   delay(10);
   digitalWrite(6, LOW);
   delay(10);
}

Una vez montado el circuito y comprobado que funciona correctamente, se puede probar a modificar el tiempo de espera.

Modificamos el código haciendo uso del bucle for, el código del programa será el siguiente:

/*
Luces del coche fantástico.
*/
int pausa=100;
void setup ()
   for(int pinLed=13;<=6;pinLed--)
   {
     pinMode(pinLed, OUTPUT);
   }
}
void loop()
{
   for(int pinLed=13;<=6;pinLed--)
   {
    digitalWrite(pinLed, HIGH);
    delay (pausa);
    digitalWrite(pinLed,LOW);
   }

   for(int pinLed=6;pinLed <=13;pinLed++)
    digitalWrite(pinLed, HIGH);
    delay (pausa);
    digitalWrite(pinLed,LOW);
   }
}