ELECTRÓNICA MAKER DE ARDUINO UNO.

Necesitamos dispositivos que ajusten el bajo consumo de 40mA que proporcionan los puertos de Arduino cuando conectemos un motor eléctrico. Y entran en juego los transistores. En esta practica construiremos un control de corriente de motor con un MOSFET de IFR520 de canal N de enriquecimiento.

Puedes ver que el circuito no conlleva mucha complicación en su montaje, por lo que voy a montar el circuito paso a paso.

Primero observa que la batería se conecta a la parte superior de la protoboard. Eso hará que la tensión necesaria que requiere el motor salga de la pila y no de la placa. Pero ten en cuenta que las masas tanto de la pila como de la placa estan unidas la mismo terminal.

El transistor de la protoboard observa su colocación. El protector de metal del MOSFET va hacia la línea de alimentación superior. En esta posición a la izquierda está la compuerta que se conectará al pin 9 de Arduino. El cambio de voltaje en la compuerta establece la conexión entre las otras dos clavijas. La central es el drenador, y será la que se conecte al ánodo del diodo rectificador. Para terminar, la fuente se conecta a masa.

Como mencione en la clase teórica, el diodo absorbe cualquier copia de voltaje generada por el motor eléctrico (fuerza contraelectromotríz autogenerada) y evitará que se reinyecte al sistema del Arduino.

Código para el control.

En consideración con las placas de Arduino, los motores son especiales ya que una placa no puede proporcionar la corriente necesaria que necesita un motor para moverse en óptimas condiciones. Por eso se recurre al uso de transistores que protegen a la placa y además regulan corrientes superiores a las que permite tu Arduino.

Así que si unimos, un motor, un transistor y un puerto digital PWM, obtenemos un circuito que puedes regular la velocidad del motor o controlar la potencia.

const int pulsador = 2;
const int motor = 9;
int estado = 0;
void setup() {
pinMode(motor, OUTPUT);
pinMode(pulsador, INPUT);
}
void loop(){
estado = digitalRead(pulsador);
if (estado == HIGH){
digitalWrite(motor, HIGH);}
else {digitalWrite(motor, LOW);}
}
						

El producto final del circuito lo puedes ver a continuación.

Puente H.

El motor gira en una sentido porque así lo hemos conectado. Pero si lo conectamos inversamente girará en el otro sentido. Por lo que si queremos que gire en un sentido y otro tendremos que desconectarlo y conectarlo a voluntad. Pero existe una forma de crear eso con un circuito eléctrico sencillo y gracias a un integrado llamado puente H o L293DNE.

El siguiente circuito conecta un motor eléctrico, pero además le permite cambiar el sentido de giro y podemos incluso controlar la velocidad de giro. ¿Empezamos?

Control de velocidad y giro.

Montaje.

Con el potenciómetro haces lo mismo. Los dos terminales los conectas a positivo y negativo y el terminal central lo conectas al puerto analógico A0.

Ya solo nos queda conectar el L29. Como puedes ver solo conectamos uno de los lados del integrado (aunque también alimientamos el otro lado del mismo). La configuración de los pines y la conexión de los puertos es la siguiente:

También deberás de conectar la batería al otro extremo de alimentación y unir las masas de ambas fuentes (la pila y la placa Arduino). Es importante que conectes el terminal de alimentación del integrado correctamente al pin que le corresponde como se muestra en la imagen.

Proceso de montaje.

En las siguientes secuencias puedes ver como se produce la secuencia del montaje del circuito anterior.

Aprovecharemos el punto medio de la placa protoboard para insertar el integrado L293DNE. Fijate que la configuración que vamos a hacer es la de un lado del integrado, por lo que podríamos generar también una configuración en el otro lado para mover dos motores eléctricos.

Los pulsadores estarán conectados cada uno a una toma de corriente. Las resistencias pull-down de 10KΩ en serie con las clavijas de toma de tierra y salida, servirán para controlar la dirección y el encendido y apagado del motor.

Los pulsadores se conectan al pin 4 y 5 por uno de sus extremos mientras que por el otro se conectan a positivo de alimentacion del Arduino.

El potenciómetro estará conectado a masa y a la alimentación de Arduino. Además conectaremos los terminales 4 y 5 del integrado a masa del Arduino.

Ahora viene cuando tenemos que empezar a conectar los terminales. El pin 8 del puente H, se conectará directamente a positivo de la pila de 9V. El pin 16, al positivo de la placa Arduino. Y empezando con los pines de control, el pin 1 del integrado al pin digital 6 de la placa Arduino.

Lo siguiente es conectar el pin 2 del integrado al pin 3 de la placa Arduino. También conectarás el pin 7 al pin 2 de la placa Arduino. Para ir terminando también conectarás el conector de la pila en la parte superior de la placa protoboard.

Para finalizar, ya solo nos queda conectar las masas de ambos generadores (pila y Arduino), y sacar un cable que alimente desde el Arduino al otro extremo de la placa board. El circuito final ya está montado y a la espera de que crees un nuevo sketch.

Código del puente H.

El código que ha hecho posible el anterior circuito lo puedes descargar desde el menú inferior, o copiar y pegar en tu proyecto Arduino UNO.

/*CODIGO DESCARGADO DESDE MIRPAS.COM */
/*#variables#*/
const int controlPin1 = 2;
const int controlPin2 = 3;
const int enablePin = 6;
const int directionSwitchPin = 4;
const int onOffSwitchStateSwitchPin = 5;
const int potPin = A0;

/**************************************/

int onOffSwitchState = 0;
int previousOnOffSwitchState = 0;
int direccionSwitchState = 0;
int previousDirectionSwitchState = 0;

/***************************************/

int motorEnabled = 0;
int motorspeed = 0;
int motorDirection = 1;

void setup() {
  // put your setup code here, to run once:
pinMode(directionSwitchPin, INPUT);
pinMode(onOffSwitchStateSwitchPin, INPUT);
pinMode(controlPin1, OUTPUT);
pinMode(controlPin2, OUTPUT);
pinMode(enablePin, OUTPUT);
digitalWrite(enablePin, LOW);
}

void loop() {
onOffSwitchState = digitalRead(onOffSwitchStateSwitchPin);
delay(1);
direccionSwitchState = digitalRead(directionSwitchPin);
motorspeed = analogRead(potPin)/4;
if (onOffSwitchState != previousOnOffSwitchState){
  if (onOffSwitchState == HIGH){
    motorEnabled = !motorEnabled;
  }
}

if (direccionSwitchState !=previousDirectionSwitchState){
  if (direccionSwitchState == HIGH){
    motorDirection = !motorDirection;
  }
}

if (motorDirection == 1){
  digitalWrite(controlPin1, HIGH);
  digitalWrite(controlPin2, LOW);
}else {
  digitalWrite(controlPin1, LOW);
  digitalWrite(controlPin2, HIGH);
}

if (motorEnabled ==1){
  analogWrite(enablePin, motorspeed);
}else {
  analogWrite(enablePin, 0);
}
previousDirectionSwitchState = direccionSwitchState;
previousOnOffSwitchState = onOffSwitchState;
}