martes, 5 de noviembre de 2013

Sensor de temperatura con LM35 y arduino

En esta ocasión usted podrá encontrar el montaje correspondiente a un sensor de temperatura implementado con un sensor lineal LM35, para esta aplicación se usa la conversión análoga digital de 10 bits, y se hace un arreglo de resolución por la pérdida que se presenta al realizar la conversión.
Primero se debe entender que el LM35 aumenta 10 mV por cada grado que sense, significa que en el caso que en la salida del sensor se obtengan 355 mV esto equivale a 35,5°C.

          XT * 1°C 
T(°C) =  --------- 
            10mV    

Donde XT es la temperatura que es medida en la salida del sensor. Una vez realizada la conversión se verifica la cantidad que toma la variable en el arduino por medio del ADC, el valor se obtiene de la siguiente fórmula:

         Vref( + ) - Vref( - ) 
Resol =  --------------------- 
                   n           
                  2            
Para este caso en específico el Vref+=5V, Vref-=0, n=10, aplicando los valores se obtiene una resolución de 4,8 mV por bit.

          T(mV) * 1bit 
Valor =   ------------ 
              4,8mV    

Aquí la temperatura en mV se toma como 355 mV para dar continuación al ejemplo, aplicando la fórmula se obtiene un valor de 73.95, este valor dista de lo que se quiere mostrar, así que se debe encontrar una ecuación que satisfaga la conversión, se plantea la siguiente:

     Tout 
x =  ---- 
      Tin 

Donde "x" es la cantidad por la que se debe dividir la salida para el arreglo de resolución, también se debe considerar que se trabaja con números enteros,razón de peso para realizar aproximaciones, con las aproximaciones la variable de temperatura de salida se puede hallar con:

         Tmedida      
Tout = ( -------) - 1 
            2         


Puede descargar los esquemas y el programa en el link:


El resultado del código y el montaje debe ser el siguiente:

  
Código:

#include <LiquidCrystal.h>

int sensor=A0;// EL sensor de temperatura debe conectarse a A0
int temp; //variable para guardar temperatura

LiquidCrystal Pantalla(0,1,2,3,4,5);//(RS,E,D4,D5,D6,D7)

void setup()
{
  Pantalla.begin(16,2);// 16 caracteres 2 líneas
  Pantalla.setCursor(0,0);
  
}
void loop()
{
    Pantalla.clear();
    Pantalla.print("  Temperatura   ");
    Pantalla.setCursor(5,1);
    temp=analogRead(A0);// Lectura del conversor análogo digital
    temp=(temp/2)-1;//arreglo de variable por resolución
    Pantalla.print(temp);
    delay(100);
    
}


Publicado por en No hay comentarios:

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);
}
Publicado por en No hay comentarios:

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
}
Publicado por en 11 comentarios:

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)
}

}
Publicado por en 2 comentarios:
Suscribirse a: Entradas (Atom)