Tutorial Válvula Solenoide con un BJT

En este tutorial continuamos aprendiendo sobre como controlar solenoides.  En el anterior lo hicimos via un FET pero esta vez lo hacemos via un BJT.

Requisitos:

1. Computadora (mac)
2. Arduino UNO
3. Válvula Solenoide de 12V
4. TIP120 Transistor
5. Diode
6. 2 baterias de 9V
7. Breadboard
8. Arduino IDE (https://www.arduino.cc/en/Main/Software)

Una válvula solenoide no es mas que una válvula controlada por un electromagnet, que es esencialmente un motor invertido.  Sabemos entonces que los motores generan contra corrientes.  Como podemos ver en el diagrama de arriba, debemos alimentar la válvula de una fuente y proteger el cerebro (Arduino) de las contra corrientes a través de un diodo.

Al mismo tiempo debemos controlar el flujo de corriente a la válvula a través de un transistor.  Para esto es posible usar un TIP120, enviarle una señal por medio del GATE o BASE.  Podemos ver el siguiente diagrama:

Aquí vemos como una señal desde el pin 13 hacia el Gate del TIP120 abre el flujo para que la solenoide complete el circuito a tierra y como el diodo controla dicho flujo en una sola dirección.

Como seleccionar un BJT:

VCB

VCE

VEB

IC

VBEon

El código:

[code]
/* BJT TIP-120
This sketch will blink a LED and at the same time, use the MOSFET to open a 12V solenoid.
Arduino D10 : To LED (Through 330 Ohm Resistor)
Arduino D02 : To MOSFET Gate
*/
int ledPin = 10; // Connect the pin to Arduino pin 10
int mosfetPin = 2; // Connect the MOSFeT Gate (first pin on the left, when writing on the chip is facing you) to Arduino pin 2
void setup(){
pinMode(ledPin, OUTPUT);
pinMode(mosfetPin, OUTPUT);
}
void loop(){
digitalWrite(ledPin, HIGH);
digitalWrite(mosfetPin, HIGH);
delay(60000); // Will turn both the LED and the MOSFET on for 60s, it gives you plenty of time to see if water is flowing as expected!
digitalWrite(ledPin, LOW);
digitalWrite(mosfetPin, LOW);
delay(5000); // Will shut down everything for 5s and restart.
}
[/code]

 

Controlar el flujo de un liquido puede ser muy util para regar plantas y muchas otras aplicaciones mas.

Tutorial Motores

Ya sabemos controlar flujo de electricidad a luces.  Ahora lo vamos a hacer con motores.  Al igual que con luces hay algunos detalles importantes.

Requisitos:

1. Computadora (mac)
2. Arduino MEGA (u otra variante Arduino) o incluso Arduino clone, Edison, Raspberry…  Este tutorial en particular usa una Arduino MEGA.
3. Motor DC & Servo
4. Breadboard
5. Arduino IDE (https://www.arduino.cc/en/Main/Software)

Terminología

Motor DC es un tipo de motor continuo.  Es decir que rota continuamente o infinitamente en la misma dirección.

Motor Servo es un tipo de motor que gira o rota de manera escalonada dependiendo del valor eléctrico pasado al mismo.

Comencemos sencillo.  Vamos a conectar primero 1 motor DC a la MEGA y usaremos el Monitor Serial para enviar datos de electricidad a la MEGA para determinar cuanta enviar al motor.

Conozcamos los componentes

Que son estos 3 componentes extraños?

El primero de arriba a abajo es el transistor.  El de en medio lo habíamos usado antes y es un resistor.  El de abajo es un diodo.

Un transistor…

Un Resistor resiste el flujo de corriente en el circuito.

Un diodo controla que el flujo eléctrico solo avance en una dirección.

Ahora entendamos el circuito.

:

Primero veamos el bosque. La corriente fluye de la MEGA 5V por el cable naranja que cruza del centro a la derecha de la imagen.  El cable amarillo cierra el circuito, GND.  El otro cable naranja sale del pin 3 de la MEGA hacia la breadboard.

Veamos estas conexiones en mayor detalle:

Ok, comencemos con la 5V proveniente de la MEGA.  Este cable conecta en la fila 5 de la breadboard (tiene una manga negra en cada punta).  Aquí mismo conecta a la terminal (+) del motor.  Aquí también hace conexión con el diodo, el cual restringe el flujo en una sola dirección.

Luego ese flujo pasa al transistor en una de sus patas extremas que resulta estar conectada a la terminal (-) del motor.  La otra pata del transistor se conecta al cable amarillo proveniente del GND en la MEGA.  Esto deja unicamente la pata central del transistor.  Esta se conecta al resistor quien hace la conexión al pin 3 de la MEGA.

El código es lo mas simple:

int motorPin = 3; // definimos el pin 3 en la MEGA como el del motor
void setup() {
pinMode(motorPin, OUTPUT);  //declaramos ese pin de tipo output
Serial.begin(9600);         // iniciamos el monitor serial
while (! Serial);           // mientras no hay nada en serial, imprimimos un mensaje
Serial.println("Speed 0 to 255");
}
void loop() {
if (Serial.available()){    // Si hay un valor en el Serial, lo leemos...
int velocidad = Serial.parseInt();  //convertimos a un int almacenado en velocidad
if (velocidad >= 0 && velocidad <= 255) // Si dicho valor esta entre 0 y 255...
{
analogWrite(motorPin, velocidad); // lo escribimos al pin del motor
}
}
}

Aquí el video:

Ahora cambiemos el tipo de motor…conozcamos al servo-motor.  Un servo no genera rotación continua sino discrecional y en valores concretos.  Es decir, en lugar de usar la corriente para girar el motor hasta que se retire la corriente, un servo es mas preciso y puede girar exactamente una cantidad determinada dependiendo de la corriente enviada.  Hay servos que giran 180 grados en una dirección y luego 180 en la dirección contraria.  Estos son los mas comunes pero no son los únicos ya que también hay servo motores que giran 360 grados y se usan comúnmente en juguetes como robots y carros.

Hagamos girar un servo-motor y luego podremos jugar un poco con un…juguete. 🙂

Podríamos usar un setup como este:

Aqui vemos como usar el pot para controlar el servo.  Los 5V van al + del pot y la GND va al – del pot.  Habíamos visto que el pin central del pot es el que genera la señal de cuanta corriente fluye dependiendo del dial.  Es decir que aqui lo que hariamos es leer el pin analogo y escribir al pin digital.  De hecho aqui esta el sketch para este proyecto:

#include  
Servo myservo;  // Creamos objeto servo 
int potpin = 0;  // definimos A0 como pin del pot
int val;    // variable para almacenar valor del pot 
void setup() {
myservo.attach(9);  // Pegamos el servo al pin digital 9
}
void loop() {
val = analogRead(potpin);            // Leemos el pot (valor de 0 – 1023) 
val = map(val, 0, 1023, 0, 179);     // Mapeamos al servo (valor de 0 – 180) 
myservo.write(val);                  // Escribimos valor al servo 
delay(15);                           // Esperamos un rato para volver a empezar 
}

Lo único nuevo aquí, aparte del hecho que un servo tiene un cable adicional, que es el cable que recibe la señal, es que el servo utiliza una library.  Una library no es mas que un set de código adicional que nos permite interactuar con alguna objeto. En este caso el objeto es Servo y lo creamos en la primera linea del código.  Crear ese objeto en código lo que hace es:

1. Ir al codigo de la library Servo.h y crear un objeto en codigo usando la plantilla del objeto Servo.  Crear uno de estos objetos en codigo nos da propiedades de ese objeto que podemos modificar y funciones de ese objeto que podemos usar.  Por ejemplo la función write que usamos al final nos permite escribir el valor de corriente que queremos al objeto Servo.
2. Una vez creado uno de estos objetos en código, interactuar con ese objeto es mas sencillo.  Podemos usar funciones como .attach() para conectar el servo real en pin 9 al objeto servo virtual que acabamos de crear.  Otra función es la de .write().  Esta función que esta en la Servo library es un set de instrucciones como nuestra función setup() o loop() que define que hacer con los valores que ponemos adentro de los paréntesis write() para que se conviertan en una señal eléctrica que activen el motor.

Es importante familiarizarnos con libraries y sus métodos porque lo estaremos usando en los siguientes tutoriales que involucran LCDs y comunicaciones usando distintas tecnologías.  De hecho las libraries se vuelven complicadas porque hay distintas versiones para una misma library que tienen pequeñas variaciones y a veces pueden hacer que nuestro código falle.  Pero eso lo veremos en su momento.

Ok, repasando lo que aprendimos:

• Convertimos aquella LED en un motor.  Lo mismo aplicaría para cerrojos o válvulas de flujo.
• Convertimos el flujo eléctrico repetitivo a uno condicionado por input del usuario, ie: el ingreso de un valor al Monitor Serial.  Ese input del usuario podría venir de una conexión BT, Wifi, GPRS, NFC etc.
• O aun mas interesante, en lugar de un usuario que debe accionar el sistema, la condición puede venir del resultado computado de un sensor de luz, sonido, calidad de aire, temperatura, huella digital etc…

En el proximo tutorial exploraremos LCD’s para visualizar información de una manera mas amigable.

Tutorial Juguete

Hemos visto como controlar la electricidad.

Requisitos:

1. Un carro electrónico o a control remoto
2. Un voltimetro o amperimetro (incluso puede ser un simple cable)

En juguete electrónico como un carro de baterías no es mas que una tabla de circuitos integrados con una fuente de poder (las baterías AA tipicamente).  El programa para esa tarjeta ya esta cargado en la fabrica y lo único que hace ese programa es controlar el flujo eléctrico a los componentes del carro.

Yo tengo a mi disponibilidad por los momentos este carro:

Este por suerte es un carro sencillo porque no es a control remoto, solo tiene botones (3 color naranja en la parte superior trasera) que cumplen ciertas funciones.  Por ende lo que dispara el programa grabado en el chip de este juguete es la accion de completar algun circuito con uno de esos 3 botones.  Un circuito activa solo el sonido, otro activa solo las luces y un tercero activa los botones, luces, sonido y el motor!

Veámoslo por dentro:

Lo importante a notar aquí es que hay una placa electronica (cafe en el lado derecho) que esta pegada a la parte superior del carro, la tapadera.  Esa placa tiene cables que van hacia la tarjeta principal.  La función de esa placa de completar los circuitos usando los botones naranja de afuera.  En el lado izquierdo podemos ver en la parte superior, un motor DC que mueve las llantas.

Y en la parte inferior de la imagen izquierda podemos ver la placa principal (color blanco) con un parlante para el sonido y unas cuantas terminales visibles de la tarjeta de circuitos.

Aquí podemos ver varios componentes de cerca y lo que mas llama la atención es la fila horizontal de terminales con letras PXX & GND.  Sabemos que solo es cuestión de completar un circuito.  Si recuerdan en todos los totorales que hemos visto hasta ahora, todos tienen pines distintos pero comparten 1 pin en común…GND!

Así que cerremos el circuito entre GND y cualquiera otra terminal a ver que pasa.  Será divertido!  Lo pueden hacer con las dos terminales de un voltímetro pero también lo pueden hacer con un cable.  Lo importante es completar el circuito.

Algo importante a notar es lo siguiente.  Primero se intenta cerrar un circuito uniendo P00 con P01, luego P00 con P02 y P03.  Eso claro no tiene lógica.  Seria como querer conectar un pin 2 con pin 3 en la MEGA.  Claro que no completara ninguna circuito.  Necesitamos el pin de GND para cerrar cualquier circuito.

Bueno hoy fue un break.  Solo repasamos el concepto general de circuitos.  Es importante recordar que eso es todo lo que estamos haciendo.

Nos vemos en la proxima!