4WD Controlado por Bluetooth

      En esta entrada explicare como he realizado un proyecto basado en Arduino. Consiste en un rover terrestre 4x4 controlado por Bluetooth desde cualquier dispositivo Android mediante una aplicación programada en App Inventor. El proyecto es Open Source por lo que dejare más abajo un enlace donde poder descargar todos los archivos del proyecto, incluyendo la App así como el código de Arduino.

      Para la realización de este proyecto necesitaremos los siguientes materiales:
  • Un Arduino Pro Mini o similar (Arduino Nano)

  • Un puente H doble

  • Un módulo Bluetooth HC-06

  • 2 baterías de litio (se pueden reciclar de las baterías de los portatiles)

  • 4 motores DC con reductora y ruedas de goma
  • Cables de conexión
  • Un trozo de tablex 24x17x3mm

      Utilizando pegamento termo-fusible pegaremos el puente H y el Arduino en el tablex. Conectaremos las baterías de litio en serie con el fin de obtener 7.4V nominales. Pegaremos las baterías al tablex también. El módulo Bluetooth se puede colocar fácilmente con cinta de doble cara; en caso de no disponer de cinta de doble cara, se podrá utilizar termo-fusible.


      Los motores se podrán pegar fácilmente con termo-fusible en el otro lado del tablex:

      Una vez montados todos los elementos, procedemos a realizar las conexiones. Los motores de cada lado se conectaran en paralelo, con el fin de que funcionen al mismo tiempo. Nos aseguraremos de que giren en el mismo sentido aplicando voltaje; si no es así, invertimos las conexiones de uno de ellos; hacemos este procedimiento en ambos lados. Cada lado se conectará a una salida del puente H.


      Esquema de conexionado:







Link de descarga: RoverBluetooth.rar

Control digital de velocidad







      Cuando tenemos un motor de corriente continua y queremos variar su velocidad de giro, no hay nada como el PWM. Como ya vimos en la anterior entrada (Control de velocidad PWM) el PWM consiste en variar el ciclo de trabajo de una onda cuadrada y al conmutar un motor con ella, variamos su velocidad.

      En el anterior proyecto utilicé un circuito integrado NE555 para generar la onda cuadrada con ciclo de trabajo variable mediante un potenciometro. Pero ahora traigo un nuevo circuito basado en un microcontrolador PIC12F683. De esta manera podemos obtener un montón de nuevas posibilidades como en mi caso, la incorporación de un sistema de seguridad con el cual el motor sólo arrancara cuando este el mando de control a cero; de esta manera evitaremos que el motor arranque de golpe cuando conectemos la alimentación si estuviese el mando de control en la posición máxima.

      Comenzaremos con la alimentación del circuito. Este circuito va a controlar la velocidad de un motorcillo con un portabrocas a 12V, muy útil para realizar los agujeros de una PCB de fabricación casera (Printed Circuit Board). Para obtener los 12V, usaremos una fuente ATX reciclada de un ordenador viejo, puesto que estas nos proporcionan bastantes amperios, suficiente para un motorcillo de estos. Pero resulta que el microcontrolador trabaja a 5V. Existen dos maneras de obtener estos 5V, una de ellas es utilizando la linea de 5V de la fuente ATX (cables rojos); la otra consiste en incorporar un regulador de voltaje en la propia placa. Yo me he decidido por la segunda puesto que quedará un circuito más "universal" y podremos usarlo con cualquier otra fuente que sólo nos proporcione los 12V. La parte encargada de obtener los 5V para el microcontrolador es la siguiente:

      El circuito integrado LM78L05 (DataSheet) nos proporcionará en su salida 5V y unos 100mA máximos, suficiente para alimentar el microcontrolador. A través de J1 (DC) se aplicarán los 12V de la fuente de alimentación. El condensador C3 actúa como filtro de salida.

      A continuación veremos la configuración básica del microcontrolador 12F683:


      Para programar el microcontrolador, tenemos que añadir un puerto ICSP de 5 pines (vease Programar PICs). También incluiremos un pulsador en push-down con su respectiva resistencia de pull-up en el pin MCLR, con esto añadiremos el RESET (que será el mecanismo de seguridad). Finalmente utilizaremos un cristal de cuarzo a 8MHz con sus dos respectivos condensadores de 33pF (C1 y C2) para el reloj del microcontrolador.

      Para controlar la velocidad del motor, utilizaremos un potenciometro. Con la entrada analógica AN0 del microcontrolador, leeremos la posición del potenciometro RV1. También he añadido un LED rojo que nos indicara una parada de emergencia.


      El potenciometro se conecta entre 0 y 5V, y la patilla central directamente a la entrada analógica del PIC. El LED está conectado de 5V a salida digital a través de una resistencia de 470Ω; por lo tanto, para encenderlo tendremos que poner la salida del microcontrolador a 0, no a 1.

      Finalmente, tendremos un circuito que nos permita controlar la alta potencia del motor, manteniendo aislados los dos circuitos de 5 y 12V:


      En el esquema no aparece el regulador de voltaje, pero el microcontrolador funciona a 5V y el motor a 12V. Mediante el opto-acoplador PC817A (DataSheet) separamos electricamente los circuitos de 5V y de 12V. El LED del opto-acoplador está conectado a través de una resistencia a la salida del CCP1 del microcontrolador (este es el que nos genera la señal de PWM). Por la salida, el opto-acoplador controla el estado de corte o conducción de dos transistores en push-pull (uno NPN y otro PNP) y la resistencia R3 mantiene en estado bajo las bases de los mismos mientras el opto-acoplador no conduce. La resistencia R2 limita la corriente que circula a través de las bases. El conjunto push-pull controla la puerta del MOSFET IRFZ44N (DataSheet), y éste controla el motor. Se puede añadir un pequeño radiador para disipar el posible calor. El diodo D3 evita que las corrientes autoinducidas que se generan en el interior del motor afecten al circuito.

      Al juntar todas las partes vistas anteriormente queda el circuito completo:


      Codigo en C para el microcontrolador:

//
//
// Control de velocidad para un motor
// a 12V con sistema de seguridad y
// control a través de un potenciometro.
// Un LED conectado a GP1 indicara que el
// sistema está bloqueado por seguridad
// y será necesario bajar el potenciometro
// al minimo para que el motor pueda girar.
//
//
//         PIC12F683
//       Uso del CCP1
//
// Copyright (c) 2016 Aaron G.
// All rights reserved.



#include <12f683.h>                                                            // Dispositivo
#device adc=10                                                                    // ADC a 10bits
#fuses hs,nowdt,put,mclr,noprotect,nocpd,nobrownout      // Configuración
#use delay(xtal=8000000)                                                   // Cristal a 8MHz
#use pwm(CCP1,FREQUENCY=10000)                           // PWM a 10KHz
#define limite_adc 10                                                          // Limite de seguridad
#define LEDs pin_a1



void main(void){                                                                // Configuracion inicial
      set_pwm1_duty(0);
      set_tris_a(0b00001001);
      setup_adc(adc_clock_internal);
      setup_adc_ports(san0);
      set_adc_channel(0);
      delay_ms(10);
      output_low(LEDs);
      while(read_adc()>=limite_adc) delay_ms(10);
      output_high(LEDs);
      while(1){                                                                     // Bucle infinito
            pwm_set_duty_percent(read_adc());
            delay_ms(10);
      }
}



      Cada vez que comienza el programa (al hacer un RESET por ejemplo) lee el estado del potenciometro, y si este está en una posición alta, se quedará bloqueado y el motor no arrancara. El LED rojo indicara éste estado de bloqueo el cuál se sobrepasa al bajar el potenciometro al mínimo.

      PCB disponible: Layout_Download




Autómata para riego de jardín







      Si tenemos un jardín, nunca viene mal disponer de un automatismo que lo riegue automáticamente a una hora que le especifiquemos. Por ello, voy a presentar en esta entrada un simple pero funcional circuito para poder automatizar dicha tarea.

      Para ello vamos a utilizar un microcontralador de la familia Microchip: el PIC12F683 (DataSheet). Se trata de un pequeño microcontrolador CMOS de 8 bits y 8 pines que será muy útil para este proyecto. Este microcontrolador llevará la cuenta del tiempo con ayuda de un cristal de cuarzo de 8 MHz, y conmutará una electro-válvula para abrir o cerrar el paso de agua a los aspersores. Para verlo de una manera más sencilla, dividimos el circuito en varias partes:



- La unidad central:

      Aquí se muestra como está conectado el cristal de cuarzo en el microcontrolador, así como el puerto ICSP para poder programarlo una vez esté montado (¿Cómo programar un PIC?):



- Entradas y salidas:

      Utilizaremos un relé de estado sólido para poder conmutar una electro-válvula a 230V AC desde el microcontrolador. Para ello necesitaremos un optoacoplador MOC3022 (DataSheet), un triac de potencia BT136 (DataSheet) y un par de resistencias. Un LED de 3mm en serie con el LED del optoacoplador, indicará el estado del relé.

      Como elemento de entrada, dispondremos de un pulsador para realizar el reset externo del microcontrolador. Una resistencia de Pull-Up mantiene en estado alto el pin durante el funcionamiento normal.



- Fuente de alimentación:

      Dado que el sistema lleva la cuenta del tiempo, si por alguna casualidad se quedase sin energía, se perdería la cuenta de la hora; y en lugar de ser un riego programado de manera precisa, podría convertirse en una ducha si nos pillase en ese momento en el jardín. Por ello, se dispone de un sistema de alimentación ininterrumpida.

      Utilizando un par de simples diodos rectificadores y un regulador lineal LM78L05 (DataSheet), se pueden utilizar dos lineas de alimentación. En una conectaremos una fuente conmutada que transforme los 230V AC a 12V DC; y en la segunda conectaremos una pila de 9V. De esta manera, mientras exista voltaje de la fuente, el diodo de la pila queda totalmente bloqueado (ya que está polarizado con una diferencia de potencial inversa) y no gasta nada de la pila. Pero si por alguna razón la fuente deja de suministrar voltaje, entraría en funcionamiento la pila manteniendo constante la cuenta del tiempo.


      Una vez unidas todas las partes vistas anteriormente, queda el siguiente circuito:




      PCB disponible en: Layout_Download

      Una vez realizado el circuito, será necesario cargar el programa en el microcontrolador:

//
//
// Temporizador para automatizar
// el riego de un jardín mediante
// una electrovalvula a 230V
// controlada mediante un triac
// y un optoacoplador con fototriac.
// El algoritmo de la base de tiempo
// es exacto, por lo tanto la precisión
// depende solo del cristal de cuarzo
// (estos tienen una precisión muy exacta).
//
//
//         PIC12F683
//       Uso del TIMER1
//
// Copyright (c) 2016 Aaron G.
// All rights reserved.


#include <12f683.h>                                    // Dispositivo
#fuses hs,nowdt,mclr,noprotect,nocpd,nobrownout
#define hora_inicio 7                            // Hora de inicio
#define minuto_inicio 0                            // Minuto de inicio
#define hora_final 7                            // Hora de paro
#define minuto_final 30                          // Minuto de paro
#use delay(xtal=8000000)                            // Frecuencia de trabajo
#define freq_inst 2000000                            // Frecuencia Timer1
#define rele pin_a1

int8 Hora=13,Minuto=5,Segundos=30; // Especificar hora actual
int32 Ticker;



// Algoritmo de la base de tiempo

#int_TIMER1

void TIMER1_isr(void){
  Ticker-=65536;
      if(Ticker<65536){
            Ticker+=freq_inst;
            Segundos++;
            if(Segundos==60){
  Minuto++;
Segundos=0;
if(Minuto==60){
    Hora++;
    Minuto=0;
    if(Hora==24) Hora=0;
                  }
            }
  }
}



// Programa principal

void main(void){
      setup_comparator(nc_nc_nc_nc);
      set_tris_a(0x08);
      Ticker=freq_inst;
      setup_timer_1(T1_INTERNAL|T1_DIV_BY_1);
      enable_interrupts(INT_TIMER1);
      enable_interrupts(GLOBAL);
      output_a(0);
      while(1){
            if((Hora==hora_inicio)&&(Minuto==minuto_inicio)) output_high(rele);
            if((Hora==hora_final)&&(Minuto==minuto_final)) output_low(rele);
      }
}


      El programa se basa en la interrupción del Timer1. El algoritmo de la base de tiempo es exacto, por lo tanto el único error que puede haber es el del cristal de cuarzo.

      Al inicio del programa se establecen las definiciones de la hora a la que queremos que se inicie el riego y la hora a la que queremos que finalice (todo en formato de 24h). Se establecen también las variables de la hora actual, es decir, hay que especificar la hora a la que comenzaremos a alimentar el circuito. Para ello es necesario poner unos minutos más de la hora actual para tener tiempo de compilar y programar el firmware; y cuando sea la hora que hemos especificado, bastará con pulsar el botón de reset para que el microcontrolador empiece a contar desde ese momento.