Reloj Tiempo real I2C DS1307 Rtc

El Reloj de tiempo real DS1307 es un integrado de MAxim/Dallas, este dispositivo permite almacenar la hora y fecha de igual forma como lo hace un reloj de pulcera, para su uso disponemos de distintas librerias pero la mas usada es TimeLib.h, la cual nos permite consulta y modificar la hora y fecha almacenada en el chip.

Aun asi y sabiendo que tenemos disponibles librerias que nos hacen el trabajo mas facil pasaremos por el trauma(jejeje) de trabajar sin la librearia.

Ejemplo: (Primero las conexiones)

 

Necesitaremos soldar los pines a la placa antes.

Codigo de seteo de hora y fecha, precaución cada vez que ejecutemos se configurara la misma hora ingresada en el codigo.

 

/**
* Ejemplo para arduino de escritura de fecha y hora al DS1307 en el
* modulo TinyRTC. Este ejemplo pone a tiempo el reloj con los datos
* provistos en la funcion setup.
*/
#include <Wire.h>

// Declaracion de las variables para almacenar informacion de tiempo
uint8_t second, minute, hour, wday, day, month, year;

/**
* Inicio del sketch: Este codigo se ejecuta al conectar el arduino
*/
void setup() {
// NOTA: Estas instrucciones se requieren para alimentar directamente el
// chip RTC desde los pines A3 Y A2 (colocar directamente el modulo sobre
// la tarjeta arduino, sin la necesidad de cablear en Arduino UNO).
// Si no se quiere hacer esto, se pueden eliminar o comentar sin problemas
pinMode(A3, OUTPUT);
digitalWrite(A3, HIGH);
pinMode(A2, OUTPUT);
digitalWrite(A2, LOW);

// Configurar la comunicacion a 9600 baudios
Serial.begin(9600);

// Preparar la librería Wire (I2C)
Wire.begin();

// Imprimir encabezado a la terminal
Serial.println(“—————————————————-“);
Serial.println(” EJEMPLO ESCRITURA DE DS1307 EN TINYRTC CON ARDUINO “);
Serial.println(“—————————————————-“);

// Inicializar las variables con el tiempo a cargar en el modulo RTC
second = 0;
minute = 58;
hour = 23;
wday = 4;
day = 15;
month = 2;
year = 17;
}

/**
* Ciclo principàl del sketch: Escribir informacion de fecha y hora una sola vez
*/
void loop() {
// Escribir hora y fecha al RTC
write_ds1307();

// Imprimimos la fecha y hora
Serial.println(“Poner a tiempo el DS1307 en Tiny RTC:”);
print_time();

// Ciclo infinito, no hacemos nada mas
for (;;);
}

/**
* Esta funcion establece la cominicación con el DS1307 y lee los registros
* de fecha y hora. Entrega la informacion horaria en las variables globales
* declaradas al principio del sketch.
*/
bool write_ds1307()
{
// Iniciar el intercambio de información con el DS1307 (0x68)
Wire.beginTransmission(0x68);
// Escribir la dirección del registro segundero
Wire.write(0x00);
// Escribir valores en los registros, nos aseguramos que el bit clock halt
// Del registro del segundero este desactivado
Wire.write(bin2bcd(second & 0x7F));
Wire.write(bin2bcd(minute));
Wire.write(bin2bcd(hour));
Wire.write(bin2bcd(wday));
Wire.write(bin2bcd(day));
Wire.write(bin2bcd(month));
Wire.write(bin2bcd(year));
// Terminamos la escritura y verificamos si el DS1307 respondio
// Si la escritura se llevo a cabo el metodo endTransmission retorna 0
if (Wire.endTransmission() != 0)
return false;
}

/**
* Convierte un numero binario a BCD
*/
uint8_t bin2bcd(uint8_t bin)
{
return (bin / 10 * 16) + (bin % 10);
}

/**
* Imprime la fecha y hora al monitor serial de arduino
*/
void print_time()
{
Serial.print(“Fecha: “);
Serial.print(day);
Serial.print(‘/’);
Serial.print(month);
Serial.print(‘/’);
Serial.print(year);

Serial.print(”  Hora: “);
Serial.print(hour);
Serial.print(‘:’);
Serial.print(minute);
Serial.print(‘:’);
Serial.print(second);

Serial.println();
}

 

Ahora podemos consultar la hora  con el siguiente codigo :

 

/**
*
* Ejemplo para arduino de lectura de fecha y hora al DS1307 en el
* modulo TinyRTC. Este ejemplo envia al monitor serial la fecha y la hora
* almacenada en el RTC cada segundo.
*/
#include <Wire.h>

// Declaracion de las variables para almacenar informacion de tiempo
uint8_t second, minute, hour, wday, day, month, year, ctrl;

/**
* Inicio del sketck: Este codigo se ejecuta al conectar el arduino
*/
void setup() {
// NOTA: Estas instrucciones se requieren para alimentar directamente el
// chip RTC desde los pines A3 Y A2 (colocar directamente el modulo sobre
// la tarjeta arduino, sin la necesidad de cablear en Arduino UNO).
// Si no se quiere hacer esto, se pueden eliminar o comentar sin problemas
pinMode(A3, OUTPUT);
digitalWrite(A3, HIGH);
pinMode(A2, OUTPUT);
digitalWrite(A2, LOW);

// Configurar la comunicacion a 9600 baudios
Serial.begin(9600);

// Preparar la librería Wire (I2C)
Wire.begin();

// Imprimir encabezado a la terminal
Serial.println(“—————————————————-“);
Serial.println(“EJEMPLO LECTURA DE RTC DS1307 EN TINYRTC CON ARDUINO”);
Serial.println(“—————————————————-“);
}

/**
* Ciclo principàl del sketch: Leer y mostrar la hora y fecha cada segundo
*/
void loop() {
// Esperar 1 segundo
delay(1000);

// Leer los registros del RTC
if (read_ds1307()) {
// Mostrar la fecha y hora
print_time();
} else {
// No se puede leer desde le DS1307 (NACK en I2C)
Serial.println(“No se detecta el DS1307, revisar conexiones”);
}
}

/**
* Esta funcion establece la cominicación con el DS1307 y lee los registros
* de fecha y hora. Entrega la informacion horaria en las variables globales
* declaradas al principio del sketch.
*/
bool read_ds1307()
{
// Iniciar el intercambio de información con el DS1307 (0xD0)
Wire.beginTransmission(0x68);

// Escribir la dirección del segundero
Wire.write(0x00);

// Terminamos la escritura y verificamos si el DS1307 respondio
// Si la escritura se llevo a cabo el metodo endTransmission retorna 0
if(Wire.endTransmission() != 0)
return false;

// Si el DS1307 esta presente, comenzar la lectura de 8 bytes
Wire.requestFrom(0x68, 8);

// Recibimos el byte del registro 0x00 y lo convertimos a binario
second = bcd2bin(Wire.read());
minute = bcd2bin(Wire.read()); // Continuamos recibiendo cada uno de los registros
hour = bcd2bin(Wire.read());
wday = bcd2bin(Wire.read());
day = bcd2bin(Wire.read());
month = bcd2bin(Wire.read());
year = bcd2bin(Wire.read());

// Recibir los datos del registro de control en la dirección 0x07
ctrl = Wire.read();
}

/**
* Esta función convierte un número BCD a binario. Al dividir el número guardado
* en el parametro BCD entre 16 y multiplicar por 10 se convierten las decenas
* y al obtener el módulo 16 obtenemos las unidades. Ambas cantidades se suman
* para obtener el valor binario.
*/
uint8_t bcd2bin(uint8_t bcd)
{
// Convertir decenas y luego unidades a un numero binario
return (bcd / 16 * 10) + (bcd % 16);
}

/**
* Imprime la fecha y hora al monitor serial de arduino
*/
void print_time()
{
Serial.print(“Fecha: “);
Serial.print(day);
Serial.print(‘/’);
Serial.print(month);
Serial.print(‘/’);
Serial.print(year);

Serial.print(”  Hora: “);
Serial.print(hour);
Serial.print(‘:’);
Serial.print(minute);
Serial.print(‘:’);
Serial.print(second);

Serial.println();
}

 

Ocupando la libreria TimeLib.h

Link descargas necesarias.

Time.h

DS1307RTC

 

/*
* TimeRTC.pde
* example code illustrating Time library with Real Time Clock.
*
*/

#include <TimeLib.h>
#include <Wire.h>
#include <DS1307RTC.h>  // a basic DS1307 library that returns time as a time_t

void setup()  {
Serial.begin(9600);
while (!Serial) ; // wait until Arduino Serial Monitor opens
setSyncProvider(RTC.get);   // the function to get the time from the RTC
if(timeStatus()!= timeSet)
Serial.println(“Unable to sync with the RTC”);
else
Serial.println(“RTC has set the system time”);
}

void loop()
{
if (timeStatus() == timeSet) {
digitalClockDisplay();
} else {
Serial.println(“The time has not been set.  Please run the Time”);
Serial.println(“TimeRTCSet example, or DS1307RTC SetTime example.”);
Serial.println();
delay(4000);
}
delay(1000);
}

void digitalClockDisplay(){
// digital clock display of the time
Serial.print(hour());
printDigits(minute());
printDigits(second());
Serial.print(” “);
Serial.print(day());
Serial.print(” “);
Serial.print(month());
Serial.print(” “);
Serial.print(year());
Serial.println();
}

void printDigits(int digits){
// utility function for digital clock display: prints preceding colon and leading 0
Serial.print(“:”);
if(digits < 10)
Serial.print(‘0’);
Serial.print(digits);
}

 

Nema17 + Controlador A4988 + RFID RC522 + Arduino Nano

Hola amigos, en este nuevo tutorial queremos compartir con ustedes nuestro ejemplo de como poner en funcionamiento un motor paso a paso bipolar de referencia Nema 17 conectado a un cotrolador A4988 mediante un lector RFID RC522 tan solo con una tarjeta BIP o cualquier tarjeta bancaria u otra tarjeta o llavero que emita una frecuencia de 13.56 Mhz; todo esto dirigido por un Arduino Nano.

El RC522 está diseñado para escribir o leer datos de aplicaciones de bajoc consumo de energia y todo esto a un bajo costo, ideal para dispositivos portatiles y tiene por caracteristicas lo siguiente:

  1. Corriente de operación: 13-26mA a 3.3V
  2. Corriente de standby: 10-13mA a 3.3V
  3. Corriente de sleep-mode: <80µA
  4. Corriente máxima: 30mA
  5. Frecuencia de operación: 13.56Mhz
  6. Distancia de lectura: 0 a 60mm
  7. Protocolo de comunicación: SPI
  8. Velocidad de datos máxima: 10Mbit/s

Para nuestro esquema hemos utilizado las siguientes librerias:

 

En el Diagrama podemos ver como conectamos el controlador A4988 al arduino
Detalle del controlador A4988 y sus conexiones.

pololuA4988

 

Este codigo basicamente trata de que al acercar la tarjeta BIP o la que estemos usando al RC522 un Led se encenderá haciendo girar el motor Nema 17 y no se apagará hasta que el motor regrese a su estado inicial manteniendo un completo descanso, lo cual le otorga un buen cuidado al motor y a su vez al controlador, la idea surge empezando por acercar la tarjeta al RC522, posteriormente encendiendo un Led y por ultimo el presente codigo´, esperamos sea de mucha utilidad.

Librerias:

SPI-master

rfid-master

Codigo:

#include <SPI.h>
#include <MFRC522.h>
int steps = 8;
int direccion = 7;
int reset = 5;
int pasos = 4000;

#define VELOCIDAD 1700

#define RST_PIN 9 // Configurable, see typical pin layout above
#define SS_PIN 10 // Configurable, see typical pin layout above

MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance

void setup() {
Serial.begin(9600); // Initialize serial communications with the PC
SPI.begin(); // Init SPI bus
mfrc522.PCD_Init(); // Init MFRC522 card
Serial.println(F(“Ingrese Tarjeta para Escribir Dato Personal”));
pinMode(4, OUTPUT);
pinMode(steps, OUTPUT);
pinMode(direccion, OUTPUT);
pinMode(reset, OUTPUT);
}

void loop() {
//Activar una direccion y fijar la velocidad con stepDelay

// Giramos 200 pulsos para hacer una vuelta completa
digitalWrite(4, LOW);
// Prepare key – all keys are set to FFFFFFFFFFFFh at chip delivery from the factory.
MFRC522::MIFARE_Key key;

for (byte i = 0; i < 6; i++) key.keyByte[i] = 0xFF;

if (  mfrc522.PICC_IsNewCardPresent()) {

digitalWrite(4, HIGH);
Serial.println(F(“Lectura Confirmada”));

digitalWrite(reset, LOW); //Mientras reset este en LOW el motor permanecerá apagado y no sufrirá. El chip apagará todos los puertos y no leerá comandos.
delay(100);
digitalWrite(reset, HIGH); //Cuando reset se encuentre en HIGH el motor arrancará y leerá los comandos enviados.
digitalWrite(direccion, HIGH);

for (int i = 0; i<pasos; i++) //Equivale al numero de vueltas (200 es 360º grados) o micropasos
{
digitalWrite(steps, HIGH); // This LOW to HIGH change is what creates the
digitalWrite(steps, LOW); // al A4988 de avanzar una vez por cada pulso de energia.
delayMicroseconds(VELOCIDAD); // Regula la velocidad, cuanto mas bajo mas velocidad.

}

digitalWrite(reset, LOW); //Mientras reset este en LOW el motor permanecerá apagado y no sufrirá. El chip apagará todos los puertos y no leerá comandos.
delay(500);
digitalWrite(reset, HIGH); //Cuando reset se encuentre en HIGH el motor arrancará y leerá los comandos enviados.
digitalWrite(direccion, LOW);

for (int i = 0; i<pasos; i++) //Equivale al numero de vueltas (200 es 360º grados) o micropasos
{

digitalWrite(steps, LOW); // LOW to HIGH hace que el motor avance ya que da la orden
digitalWrite(steps, HIGH); // al A4988 de avanzar una vez por cada pulso de energia.
delayMicroseconds(VELOCIDAD); // Regula la velocidad, cuanto mas bajo mas velocidad.
}

digitalWrite(reset, LOW);

//delay(500);

return;
}
// Look for new cards

digitalWrite(4, LOW);
}

Controlador Arduino Nano, Uno y Mega… Driver CH340g

Estimados muchos de las placas Arduino existentes en el mercado incluyendo muchas de las nuestras son de preocedencia China, por lo general para abartar costos estas placas utilizan componentes distintos de las placas Arduino originales el mas utilizado es el controlador CH340g el cual se diseño para reemplazar a tracional FT232RL o el ATMEGA16u2 , desafortunadamente este controlador CH340g no esta soportador nativamnte por Windows o OSX, por lo tanto y en muchas ocaciones se hace necesario instalar controladores para estas placas, estos controladores corresponden al modulo de comunicacion Usb de la placa y el computador.

Pasos para la instalación :

1- Descarga del controlador versión de acuerdo al Sistema operativo que usted tenga.

ch340_linux (Controlador Linux)

ch340_mac (Controlador OSX)

ch340_windows (Controlador Windows)

2- Descomprimir Controlador

captura-de-pantalla-2016-10-03-a-las-22-56-24

3- Ejcutar controlador SETUP.EXE

captura-de-pantalla-2016-10-03-a-las-22-58-42

3- Luego de clickear en INSTALL instalara de forma completa los controladores y saldra una pantalla como esta.

captura-de-pantalla-2016-10-03-a-las-23-01-51

4- Ya podemos conectar nuestro Arduino y trabajar.

captura-de-pantalla-2016-10-03-a-las-23-03-17

5- En este caso el PC asigno el COM14 para nuestra placa Arduino, en nuestro IDE de ARDUINO en Herramientas debemos seleccionar el modelo de placa Arduino y el correspondiente Puerto.

Pasos para la instalación :

 

1- Descarga del controlador versión de acuerdo al Sistema operativo que usted tenga.

ch340_linux (Controlador Linux)

ch340_mac (Controlador OSX)

ch340_windows (Controlador Windows)

2- Descomprimir Controlador

captura-de-pantalla-2016-10-03-a-las-22-56-24

3- Ejecutar controlador SETUP.EXE

captura-de-pantalla-2016-10-03-a-las-22-58-42

3- Luego de clickear en INSTALL instalara de forma completa los controladores y saldrá una pantalla como esta.

captura-de-pantalla-2016-10-03-a-las-23-01-51

4- Ya podemos conectar nuestro Arduino y trabajar.

captura-de-pantalla-2016-10-03-a-las-23-03-17

 

5- En este caso el PC asigno el COM14 para nuestra placa Arduino, en nuestro IDE de ARDUINO en Herramientas debemos seleccionar el modelo de placa Arduino y el correspondiente Puerto.

 

Feliz Hack!!!!

Arduino y CD74HC4067 prendiendo Led

Uno de los módulos creo que mas útiles que tenemos disponibles son los multiplexores (CD74HC4067), una descripción muy light de este dispositivo seria como una zapatilla de pines… Para que se entienda de forma mas fácil es un dispositivo donde usando 5 pines del Arduino podemos manejar 16 señales o sensores.. si 16, y esto se agradece en el minuto que queremos tener acceso a muchos datos o armar un robot o manejar muchas luces y todo lo que se nos pudiera ocurrir, lo mejor es capaz de leer señales digitales o analógicas… Super!!!

Por el minuto nos limitaremos a prender 16 led, luego trataremos de manejar varios sensores, incluso hacer uso de varios multiplexores a la vez.

Aquí el diagrama:

multiplexor_arduino_led

 

Para simplificar la vida usaremos una libreria Mux.h la podemos descargar del siguiente link :

https://github.com/mikedotalmond/Arduino-Mux-CD74HC4067

Arduino-Mux-CD74HC4067-master (Aquí también por si desaparece)

Aquí el Modulo en nuestra Tienda

Aquí el código :

#include <Mux.h>

Mux mux(2,3,4,5,4); // initialise on construct...
int counter=0;

void setup(){
Serial.begin(9600);
mux.setup(8,9,10,11,4); // initialise Mux
}

void loop(){
mux.write(counter, HIGH); //Turn ON the selected LED
delay(500);
mux.write(counter, LOW); //Turn OFF the selected LED

if(counter==15){
Serial.println(counter); //Print results
}
else{
Serial.print(counter);
Serial.print(", ");
}

counter = ++counter & 15; //Add +1 to counter until 15
}

 

 

Nota: Para el circuito del video no use resistencias, en favor del tiempo.

 

Conectar Motor Nema 17, Controlador DV4988 y Arduino Nano

Creo que todos los que estamos en este mundillo de Arduino y los circuitos hemos soñado con construir nuestro propio robot uno con brazos, piernas, cara, ojos etc.. (o como a cada uno se lo imagine), el tema que en todas ideas existe un punto en común, “LOS MOTORES” existen muchos modelos, motores DC, motores bipolares, unipolares, etc…
Para cada necesidad puedes elegir el motor que mas te acomode y claro todo queda a tu criterio.

Para este caso explicaremos como controlar un motor paso a paso bipolar Nema 17, este es un motor súper utilizado por su costo versus calidad en las tan famosas impresoras 3D o CNC.

En este pequeño tutorial explicaremos el manejo de este motor con un controlador A4988 y usaremos un Arduino Nano para controlar el conjunto total.

Diagrama en Fritzing
nema17 A4988 Arduino Nano.fzz

nema17 A4988 Arduino Nano_bb

En el Diagrama podemos ver como conectamos el controlador A4988 al arduino
Detalle del controlador A4988 y sus conexiones.

pololuA4988

Por otra parte podemos ver el detalle de los cables del motor los cuales están identificados por color.

Negro A+
Verde A-
Rojo B+
Azul B-

nema1

Estos colores pueden cambiar en otros motores incluso en otro mismo Nema 17. Por lo general esta información esta disponible por quien lo venda.

Un punto importante es que en la conexión de tierra y voltaje que alimenta al motor debe ir un condensador de al menos 10mf, nótese que el condensador tiene polaridad lo cual debe respetarse ya que si se conecta al revés literalmente el condensador explotara. La función del condensador en este caso es la de estabilizar el voltaje entregado al motor para evitar cambios en la línea de alimentación ya que como el motor tiene un consumo alto esto podría producir perdidas de señales digitales entregadas al motor de paso a paso, Para este caso el condensador tendría la tarea de mantener esta pequeña corriente almacenada disponible todo eltiempo.

El código lo que hace es girar en un sentido y otro en forma de loop declarando pin 12 como controlador de Step, pin 13 como dirección y velocidad la cual se declara en 1700, mientras mas alta se declare la variable la velocidad del motor será mas lenta y mientras mas baja la velocidad del motor será mas rápida(claramente).
Motor2.ino

#define VELOCIDAD 1700
 
int steps = 8;
int direccion = 7;
int reset = 5;
int pasos = 3500;
 
// the setup routine runs once when you press reset:
void setup() {
// initialize the digital pin as an output.
pinMode(steps, OUTPUT);
pinMode(direccion, OUTPUT);
pinMode(reset, OUTPUT);
}
 
// the loop routine runs over and over again forever:
void loop() {
digitalWrite(reset, LOW); //Mientras reset este en LOW el motor permanecerá apagado y no sufrirá. El chip apagará todos los puertos y no leerá comandos.
delay(100);
digitalWrite(reset, HIGH); //Cuando reset se encuentre en HIGH el motor arrancará y leerá los comandos enviados.
digitalWrite(direccion, HIGH);
 
for (int i = 0; i<pasos; i++) //Equivale al numero de vueltas (200 es 360º grados) o micropasos
{
digitalWrite(steps, HIGH); // This LOW to HIGH change is what creates the
digitalWrite(steps, LOW); // al A4988 de avanzar una vez por cada pulso de energia.
delayMicroseconds(VELOCIDAD); // Regula la velocidad, cuanto mas bajo mas velocidad.
 
}
 
digitalWrite(reset, LOW); //Mientras reset este en LOW el motor permanecerá apagado y no sufrirá. El chip apagará todos los puertos y no leerá comandos.
delay(100);
digitalWrite(reset, HIGH); //Cuando reset se encuentre en HIGH el motor arrancará y leerá los comandos enviados.
digitalWrite(direccion, LOW);
 
for (int i = 0; i<pasos; i++) //Equivale al numero de vueltas (200 es 360º grados) o micropasos
{
 
digitalWrite(steps, LOW); // LOW to HIGH hace que el motor avance ya que da la orden
digitalWrite(steps, HIGH); // al A4988 de avanzar una vez por cada pulso de energia.
delayMicroseconds(VELOCIDAD); // Regula la velocidad, cuanto mas bajo mas velocidad.
}
}

Como usar el sensor Photoresistor con arduino

Codigo

int lightPin = 0;  //Definimos el pin para el ldr
int ledPin=11;     //Definimos pin para el Led

void setup()
{
    Serial.begin(9600);  //Comenzamos la comunicación serial
    pinMode( ledPin, OUTPUT );
}

void loop()
{
    Serial.println(analogRead(lightPin)); //Escribimos el valor del LDR en la pantalla  Serial de Arduino
    analogWrite(ledPin, analogRead(lightPin)/4);  //Mandamos el valor al pin del led. Dependiendo del valor del resistor 
                                                //se debe dividir el valor. por ejemplo, 
                                                //con una resistencia de 10k dividimos el valor por 2, para una de 100k dividimos por 4.
   delay(10); //prendemos el led con un corto tiempo.
}