miércoles, 30 de octubre de 2013

Velocidad y giro de un motoreductor con arduino

En esta ocasión se trata el tema de los servomotores, a continuación usted encuentra la conexión y la distribución que se sugiere para hacer un buen uso del motor y además de evitar daños al arduino,


Para el manejo de la inversión de giro del motor se hace uso del driver de corriente L293D, soporta una corriente de 1A, así que se debe tener en consideración el consumo del motor a conectar.

Los pines 2 y 3 del arduino se encargan de el manejo de la velocidad y sentido de giro del motor, la velocidad del motor es modulada por medio de un PWM, y dependiendo el sentido del giro, usted puede verificar la intensidad por medio de un led, los pulsadores conectados a los pines 4 y 5 se encargan del valor a configurar en el PWM, este valor se encuentra en el rango de 0-255.


/*Ejemplo para manejo de servomotor con arduino

2-> Salida a motor 1
3-> Salida a motor 2
4-> Sube PWM
5-> Baja PWM

*/
int valorPWM=0;// Valor de intensidad del pwm, define la velocidad del motor
int est,est2;// Variables para guardar el estado del pulsador.

void izq(int velocidad);//rutina motor hacia la izquierda
void der(int velocidad);//rutina motor hacia la derecha

void setup()
{
  pinMode(2,OUTPUT); //Pin 2 Como salida
  pinMode(3,OUTPUT); //Pin 3 Como salida
  pinMode(4,INPUT_PULLUP); //Pin 4 Como entrada -> activa con cero
  pinMode(5,INPUT_PULLUP); //Pin 5 Como entrada -> activa con cero
  digitalWrite(2,LOW);//Apaga el motor
  digitalWrite(3,LOW);//Apaga el motor
}
void loop()
{
  est=digitalRead(4);//Guarda el estado del pin 4, depende del pulsador
  est2=digitalRead(5);//Guarda el estado del pin 4, depende del pulsador
  if(est==0)//Aumento Pwm
  {
    delay(100);//retardo Antirebote
    valorPWM +=1;
    if(valorPWM>255)
    {
      valorPWM=255;
    }
  }
  if(est2==0)//Disminuye Pwm
  {
    delay(100);//retardo Antirebote
    valorPWM -=1;
    if(valorPWM<0)
    {
      valorPWM=0;
    }
  }
  //izq(valorPWM);//inicia el giro a izquierda
  der(valorPWM);//inicia el giro a derecha
}
void izq(int velocidad)
{
  digitalWrite(2,LOW);
  analogWrite(3,velocidad);
}
void der(int velocidad)
{
  digitalWrite(3,LOW);
  analogWrite(2,velocidad);
}

Configurando Adecuadamente el módulo Tiny RTC

En esta ocasión se comparte la manera adecuada para la programación del módulo Tiny RTC, gracias a un compañero quien me facilito el módulo pude explorarlo y hacerle funcionar, en primera instancia lo que les recomiendo es que no se confíen de algunas librerías que están publicadas para el manejo de este módulo, remítanse a la documentación del fabricante que se encuentra en este link:

http://www.dfrobot.com/wiki/index.php/Real_Time_Clock_Module_(DS1307)_(SKU:DFR0151)

La conexión que se debe realizar con arduino es la siguiente:


Es importante que se realice la conexión del pin 2 al arduino, este pin permite realizar la configuración de la hora y los días de manera adecuada. Los pasos a seguir para programar el módulo son:


  1. Se debe instalar la librería que les comparto al arduino.
  2. Una vez instalada la librería (que es simplemente copiar la carpeta del rar en la carpeta arduino->libraries), abrir el archivo .ino que se comparte.
  3. Allí simplemente se le quita el comentario en las líneas indicadas, se cambia la fecha y la hora, se programa el arduino conectado al módulo.
  4. Hecho el paso anterior, poner las líneas de nuevo en comentario y volver a programar.
  5. Terminado, por fin el módulo funciona.
  6. Las líneas que se deben modificar están de color rojo.

#include <Wire.h>                       // For some strange reasons, Wire.h must be included here
#include <DS1307new.h>

// *********************************************
// DEFINE
// *********************************************

// *********************************************
// VARIABLES
// *********************************************
uint16_t startAddr = 0x0000;            // Start address to store in the NV-RAM
uint16_t lastAddr;                      // new address for storing in NV-RAM
uint16_t TimeIsSet = 0xaa55;            // Helper that time must not set again

// *********************************************
// SETUP
// *********************************************
void setup()
{
  pinMode(2, INPUT);                    // Test of the SQW pin, D2 = INPUT
  digitalWrite(2, HIGH);                // Test of the SQW pin, D2 = Pullup on

  Serial.begin(9600);

/*
   PLEASE NOTICE: WE HAVE MADE AN ADDRESS SHIFT FOR THE NV-RAM!!!
                  NV-RAM ADDRESS 0x08 HAS TO ADDRESSED WITH ADDRESS 0x00=0
                  TO AVOID OVERWRITING THE CLOCK REGISTERS IN CASE OF
                  ERRORS IN YOUR CODE. SO THE LAST ADDRESS IS 0x38=56!
*/
  RTC.setRAM(0, (uint8_t *)&startAddr, sizeof(uint16_t));// Store startAddr in NV-RAM address 0x08 

/*
   Uncomment the next 2 lines if you want to SET the clock
   Comment them out if the clock is set.
   DON'T ASK ME WHY: YOU MUST UPLOAD THE CODE TWICE TO LET HIM WORK
   AFTER SETTING THE CLOCK ONCE.
*/
// TimeIsSet = 0xffff;
//  RTC.setRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t));  

/*
  Control the clock.
  Clock will only be set if NV-RAM Address does not contain 0xaa.
  DS1307 should have a battery backup.
*/
  RTC.getRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t));
  if (TimeIsSet != 0xaa55)
  {
    RTC.stopClock();
        
    RTC.fillByYMD(2013,10,30);
    RTC.fillByHMS(14,52,0);
    
    RTC.setTime();
    TimeIsSet = 0xaa55;
    RTC.setRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t));
    RTC.startClock();
  }
  else
  {
    RTC.getTime();
  }

/*
   Control Register for SQW pin which can be used as an interrupt.
*/
  RTC.ctrl = 0x00;                      // 0x00=disable SQW pin, 0x10=1Hz,
                                        // 0x11=4096Hz, 0x12=8192Hz, 0x13=32768Hz
  RTC.setCTRL();

  Serial.println("Tiempo Actual");
  
  uint8_t MESZ;
      
  Serial.println();
}

// *********************************************
// MAIN (LOOP)
// *********************************************
void loop()
{
  RTC.getTime();
  if (RTC.hour < 10)                    // correct hour if necessary
  {
    Serial.print("0");
    Serial.print(RTC.hour, DEC);
  } 
  else
  {
    Serial.print(RTC.hour, DEC);
  }
  Serial.print(":");
  if (RTC.minute < 10)                  // correct minute if necessary
  {
    Serial.print("0");
    Serial.print(RTC.minute, DEC);
  }
  else
  {
    Serial.print(RTC.minute, DEC);
  }
  Serial.print(":");
  if (RTC.second < 10)                  // correct second if necessary
  {
    Serial.print("0");
    Serial.print(RTC.second, DEC);
  }
  else
  {
    Serial.print(RTC.second, DEC);
  }
  Serial.print(" ");
  if (RTC.day < 10)                    // correct date if necessary
  {
    Serial.print("0");
    Serial.print(RTC.day, DEC);
  }
  else
  {
    Serial.print(RTC.day, DEC);
  }
  Serial.print("-");
  if (RTC.month < 10)                   // correct month if necessary
  {
    Serial.print("0");
    Serial.print(RTC.month, DEC);
  }
  else
  {
    Serial.print(RTC.month, DEC);
  }
  Serial.print("-");
  Serial.print(RTC.year, DEC);          // Year need not to be changed
  Serial.print(" ");
  switch (RTC.dow)                      // Friendly printout the weekday
  {
    case 1:
      Serial.print("MON");
      break;
    case 2:
      Serial.print("TUE");
      break;
    case 3:
      Serial.print("WED");
      break;
    case 4:
      Serial.print("THU");
      break;
    case 5:
      Serial.print("FRI");
      break;
    case 6:
      Serial.print("SAT");
      break;
    case 7:
      Serial.print("SUN");
      break;
  }
  uint8_t MESZ = RTC.isMEZSummerTime();
   
  RTC.getRAM(0, (uint8_t *)&lastAddr, sizeof(uint16_t));
  Serial.print("\n");
  lastAddr = lastAddr + 1;              // we want to use it as addresscounter for example
  RTC.setRAM(0, (uint8_t *)&lastAddr, sizeof(uint16_t));
  RTC.getRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t));
  if (TimeIsSet == 0xaa55)              // check if the clock was set or not
  {
  
  }
  else
  {
  
  }    
  delay(1000);                          // wait a second
}

martes, 29 de octubre de 2013

Librería para Arduino para el manejo de motores Unipolares, método Full Step y Half Step

Esta librería que se publica aquí no tiene la intención de reemplazar a la librería que por defecto te descarga con arduino llamada Stepper, teniendo en cuenta esa librería surge la necesidad de crear un librería especializada en motores unipolares de 5 y 6 hilos, por experiencia personal, a veces se vuelve complicado el manejo de la librería stepper, en el sentido de practicidad, aunque se midan las bobinas y se determine la secuencia, la librería stepper esta pensada más para motores bipolares que para los unipolares, puesto que su funcionamiento no es secuencial, sino que alterna los voltajes en los pines que se seleccionan o se configuran, así que se ha creado la librería para el manejo de estos motores como aparece normalmente el la literatura de consulta.

En el esquema anterior se puede observar la distribución para un motor unipolar de 6 hilos, donde dos de los hilos son unidos entre si para ser tomados como común, se conectan por medio del protoboard al pin del driver de corriente ULN2003, también se debe tener en cuenta que por los colores en el cableado ya se deben haber identificado las bobinas para cumplir con la secuencia.

A continuación se encuentran los archivos para descarga, listos para instalar la librería en la versión de arduino que usted posea en la actualidad, dentro de la librería se encuentra el respectivo ejemplo de uso.

https://www.dropbox.com/s/lgfh4ghitwevso9/Unipolar.rar

Código:



 #include "Unipolar.h"// Unipolar Stepper Motor

void setup()
{
  confUni(2,3,4,5);//pins to the motor
}
void loop()
{
  cwMov(12,10);//set (Steps,Speed) clock wise
  acwMov(13,10);//set (Steps,Speed) Anti clock wise
  halfMov(12,10);//set half step clock wise (Steps, Speed)
  ahalfMov(12,10);//set hal step anti clock wise(Steps,Speed)
}

}