Archive for enero 2014



Hola querido lect@r, en este proyecto veremos como configurar un pequeño modulo de tiempo real con arduino (El Modulo RTC Tiny es común y económico). Este modulo se compone entre otros elementos de un reloj DS1307, una memoria EEPROM 24C32AN y un soporte para pila de litio CR2032. 

Gracias a la pila de litio y a la memoria EEPROM el módulo almacena los datos y sigue en funcionamiento aunque desconectemos Arduino y por lo tanto cuando lo volvamos a encender seguiremos teniendo la hora correcta.

Pero primero debemos configurarlo a la hora actual antes siguiendo las instrucciones del código 1, sin olvidarnos de instalar las librerías necesarias antes de nada. Linck de la información original aquí.

Y luego volviendo a subir el código 1 cuando hayamos seguido las instrucciones para dejarla a la hora correcta ya configurada en nuestro pequeño modulo. 

Podemos comprobar si todo esta ok con el código 2 y su librería RTClib. Ya que este segundo código brinda la opción de mostrar la hora del modulo o la de ordenador si seguimos sus instrucciones.


Espero que les sirva y ayude, saludos de GUILLENXT.


CODIGO 1

#include <Wire.h>                       // Por alguna extraña razón, Wire.h debe incluirse aquí
#include <DS1307new.h>

// ********************************************* 
// DEFINIENDO
// *********************************************

// *********************************************
// VARIABLES
// *********************************************
uint16_t startAddr = 0x0000;            // Dirección inicial para almacenar en la NV-RAM
uint16_t lastAddr;                     // Nueva dirección para el almacenamiento en la NV-RAM
uint16_t TimeIsSet = 0xaa55;            // Ayuda que el tiempo no debe establecer de nuevo

// *********************************************
// SETUP
// *********************************************
void setup()
{
  pinMode(2, INPUT);                    // Prueba del pasador SQW, D2 = ENTRADA
  digitalWrite(2, HIGH);                // Prueba del pasador SQW, D2 = ALTO

  Serial.begin(9600);

/*
   Note por favor: HEMOS HECHO UN CAMBIO DIRECCIÓN PARA LA NV-RAM!
                   NV-RAM DIRECCIÓN 0x08 TIENE QUE CURSAR CON DIRECCIÓN 0x00 = 0
                   Para evitar sobrescribir LOS REGISTROS DEL RELOJ EN CASO DE
                   Errores en el código. LO QUE LA DIRECCIÓN ES LA ÚLTIMA 0x38 = 56!
*/
  RTC.setRAM(0, (uint8_t *)&startAddr, sizeof(uint16_t));// Store startAddr in NV-RAM address 0x08 

/*
    Elimine el comentario de las siguientes 2 líneas si desea ajustar el reloj
    Comentario hacia fuera si el reloj está ajustado.
    NO ME PREGUNTE POR QUÉ: DEBE SUBIR EL CÓDIGO dos veces para dejarlo trabajar
    DESPUÉS DE AJUSTE DEL RELOJ UNA VEZ.
*/

//TimeIsSet = 0xffff;
//RTC.setRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t));  

/*
  Control del reloj.
   Reloj sólo se establecerá si la Dirección NV-RAM no contiene 0xaa.
   DS1307 deben tener una copia de seguridad de la batería.
*/
  RTC.getRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t));
  if (TimeIsSet != 0xaa55)
  {
    RTC.stopClock();
    // FECHA A CAMBIAR //        
    RTC.fillByYMD(2013,12,13);
    RTC.fillByHMS(18,03,0);
    
    RTC.setTime();
    TimeIsSet = 0xaa55;
    RTC.setRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t));
    RTC.startClock();
  }
  else
  {
    RTC.getTime();
  }

/*
   Registro de Control de pin SQW que se puede utilizar como una interrupción.
*/
  RTC.ctrl = 0x00;                      // 0x00 = desactivar pin SQW, 0x10 = 1 Hz,
                                        // 0x11 = 4096Hz, 0x12 = 8192Hz, 0x13 = 32768Hz
  RTC.setCTRL();

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

// *********************************************
// LOOP
// *********************************************
void loop()
{
  RTC.getTime();
  if (RTC.hour < 10)                    // hora correcta si es necesario
  {
    Serial.print("0");
    Serial.print(RTC.hour, DEC);
  } 
  else
  {
    Serial.print(RTC.hour, DEC);
  }
  Serial.print(":");
  if (RTC.minute < 10)                  // minutos corregidos si es necesario
  {
    Serial.print("0");
    Serial.print(RTC.minute, DEC);
  }
  else
  {
    Serial.print(RTC.minute, DEC);
  }
  Serial.print(":");
  if (RTC.second < 10)                  // segundos corregidos si es necesario
  {
    Serial.print("0");
    Serial.print(RTC.second, DEC);
  }
  else
  {
    Serial.print(RTC.second, DEC);
  }
  Serial.print(" ");
  if (RTC.day < 10)                    // fecha correcta, si es necesario
  {
    Serial.print("0");
    Serial.print(RTC.day, DEC);
  }
  else
  {
    Serial.print(RTC.day, DEC);
  }
  Serial.print("-");
  if (RTC.month < 10)                   // mes correcto si es necesario
  {
    Serial.print("0");
    Serial.print(RTC.month, DEC);
  }
  else
  {
    Serial.print(RTC.month, DEC);
  }
  Serial.print("-");
  Serial.print(RTC.year, DEC);          // Año necesita no ser cambiado
  Serial.print(" ");
  switch (RTC.dow)                      // Impresión agradable del día de la semana
  {
    case 1:
      Serial.print("LUNES");
      break;
    case 2:
      Serial.print("MARTES");
      break;
    case 3:
      Serial.print("MIERCOLES");
      break;
    case 4:
      Serial.print("JUEVES");
      break;
    case 5:
      Serial.print("VIERNES");
      break;
    case 6:
      Serial.print("SABADO");
      break;
    case 7:
      Serial.print("DOMINGO");
      break;
  }
  uint8_t MESZ = RTC.isMEZSummerTime();
   
  RTC.getRAM(0, (uint8_t *)&lastAddr, sizeof(uint16_t));
  Serial.print("\n");
  lastAddr = lastAddr + 1; // queremos usarlo como contador de direcciones, por ejemplo,
  RTC.setRAM(0, (uint8_t *)&lastAddr, sizeof(uint16_t));
  RTC.getRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t));
  if (TimeIsSet == 0xaa55)              // comprobar si el reloj se ajusta o no
  {
  
  }
  else
  {
  
  }    
  delay(1000);                          // espera un segundo
}



CODIGO 2

#include <Wire.h>
#include "RTClib.h"
RTC_DS1307 RTC;

void setup () {
  //Inicializamos el puerto serie, wire y el modulo RTC
    Serial.begin(9600);
    Wire.begin();
    RTC.begin();
    //Si quitamos el comentario de la linea siguiente, se ajusta la hora y la fecha con la del ordenador
    //RTC.adjust(DateTime(__DATE__, __TIME__));
}

void loop () {
    DateTime now = RTC.now();
    //Imprimimos el dia
    Serial.print(now.day(), DEC);
    Serial.print('/');
    //Imprimimos el mes
    Serial.print(now.month(), DEC);
    Serial.print('/');
    //Imprimimos el año
    Serial.print(now.year(), DEC);
    Serial.print(' ');
    //Imprimimos la hora
    Serial.print(now.hour(), DEC);
    Serial.print(':');
    //Imprimimos los minutos
    Serial.print(now.minute(), DEC);
    Serial.print(':');
    //Imprimimos los segundos
    Serial.print(now.second(), DEC);
    Serial.println();
    //Comprobamos la hora y la enviamos por el puerto serie cada 3s
    delay(3000);
}

FOTOS Y VIDEOS:






ARCHIVOS PARA DESCARGA:

Dando click en la imagen a continuación, después de eso deben esperar 5 segundos y SALTAR LA PUBLICIDAD, están en ADFLY;





Hola lector@s hoy les traigo un interesante proyecto de una lampara con arduino y un sensor de sonido que se enciende y se apaga con aplausos o palmadas, para recrearlo necesitaremos los siguientes implementos:


  • Arduino Uno, Durmilanove, Nano o Leonardo.
  • Modulo de Relé (Canales al Gusto ya que solo usaremos una salida)
  • Sensor de Sonido
  • Cables de Prototipaje
  • Protoboard
El cableado es muy simple, tanto que en el momento de realizarlo en el taller solo visualizamos el encendido de la lampara con un Led.


Pero de usar un modulo relé parecido a este, recuerden que el mismo pulso que activa el led también activara nuestro modulo:


La conexión sería esta, salvo que en la imagen se usa la salida digital 2, pero la cambiamos, ok?;

Ahora toca subir el código a nuestro Arduino;

int sensorPin = A0;   // entrada para nuestro sensor de sonido
int relayPin = 10;    // pin relé
int sensorValue = 0;  // variable para almacenar el valor del sensor
int knockUp;


void setup() {
  // declarar la relayPin como salida:
  pinMode(relayPin, OUTPUT);  
  knockUp = 0;
  digitalWrite(relayPin, LOW); 
  Serial.begin(9600);
}

void loop() {
  // leer el valor del sensor:
  sensorValue = analogRead(sensorPin);    

 long startTime = millis();
 while(millis() - startTime < 1500){
      sensorValue = analogRead(sensorPin); 
       if (sensorValue > 800)
       {
        knockUp = knockUp + 1;
        digitalWrite(relayPin, LOW);
        delay(200);
        digitalWrite(relayPin, HIGH);
        Serial.println(knockUp, DEC); 
       } 
     }
  if (knockUp == 2){
   digitalWrite(relayPin, LOW); 
   delay(20000);
   digitalWrite(relayPin, HIGH); 
  }
  knockUp = 0;
}

Y nos ponemos a jugar con nuestra lampara activada por sonido gracias a arduino, podrán ver mas con el monitor serial, ok. Dicho proyecto lo base del famoso brasier o sujetador que se caía con un par de palmadas, llamado Clap-Off Bra, pero traducido y adaptando para todos ustedes.

Pero antes de subir el código anterior me gusta calibrar el sensor para que llegue al umbral deseado y se active su salida, para ello tenemos un pequeño potenciómetro que deberemos ajustar a nuestro ruido ambiente y lo fuerte de sus aplausos o golpes como se ve en el video;


El código de calibración para la salida analógica que es la que utilizaremos, junto al diagrama de conexiones lo pueden descargar dando click en la siguiente imagen (tan solo deben esperar 5 segundos y saltar la publicidad, el linck esta en adfly);



PD Añado el código de calibración de la salida digital de nuestro sensor de sonido, que nos ira muy bien para futuros proyectos e invito que si les gusta y lo hacen en casa no se olviden de agradecer y hasta colgar un video de como les quedo a ustedes.

Salu2 de GUILLENXT




Hola querido lectores, feliz 2014. Como inicio de este nuevo año y con mis mejores deseos a todos los amantes de la computación física y la robótica educativa les comparto mi colección de libros de Raspberry Pi recogidos a lo largo de mi trayectoria como estudiante y ahora como profesional.



Siempre pueden verla de forma online gratuitamente dando click en la imagen del final del post, esta les llevara a MEGA donde se encuentran ubicados. Tan solo deben esperar 5 segundos y saltar la publicidad de Adfly, ok.


La colección que recoge 36 libros en formato PDF, e aquí la lista especifica:


  • Adventures in Raspberry Pi
  • Beginning Sensor Networks with Arduino and Raspberry Pi
  • Getting Started With Raspberry Pi
  • Hacking Raspberry Pi 2013
  • Learn Raspberry Pi with Linux
  • Linux User and Developer 2012
  • Linux User and Developer 2013
  • Learn Raspberry Pi Programming with Python
  • Learn Raspberry Pi with Linux
  • Linux User and Developer 2012
  • Linux User and Developer 2013
  • Mastering the Raspberry Pi
  • Practical Raspberry Pi
  • Programming Arduino Next Steps Going Further with Sketches
  • Programming the Raspberry Pi by Dr Eben Upton
  • Programming the Raspberry Pi Getting Started with Python
  • Quick Start Guide v2
  • Raspberry Pi  A Quick Start Guide
  • Raspberry Pi Cookbook for Python Programmers
  • Raspberry Pi Education Manual
  • Raspberry Pi For Dummies
  • Raspberry Pi for Secret Agents
  • Raspberry Pi Hacks
  • Raspberry Pi Hardware Projects 1
  • Raspberry Pi Home Automation with Arduino
  • Raspberry Pi Networking Cookbook
  • Raspberry Pi Poster
  • Raspberry Pi Projects for Kids
  • Raspberry Pi Start Guide
  • Raspberry Pi User Guide 2012
  • Raspberry Pi User Guide
  • Raspberry Pi Robotic Projects
  • Raspberry Pi Server Essentials
  • Raspberry Pi Projects for the Evil Genius
  • Raspberry Pi Cookbook
  • Smart Home Automation with Linux and Raspberry Pi



Espero que les guste y sirva tanto o mas que a mi, por eso mismo es compartida ;)
Se aceptan donativos por paypal, mirar lado derecho inferior de la web, plis...
También puedes dejar tu comentario aqui abajo....


Bienvenid@s a mi Blog

- Copyright © GUILLENXT -Robotic Notes- Powered by Blogger - Re-Designed by Guillermo J. Gil Aitken -