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

 

Prender una ampolleta con un rele y un Pir y algunas otras pocas cosas

Bueno por lo general no necesitamos un arduino conectado a unos sensores para hacer lo que queremos, algunas (muchas) veces no necesitamos tanta tecnología, solo necesitamos prender una ampolleta cuando detecte movimiento, bueno con los componentes adecuados podemos realizar este entretenido proyecto.

 

Primero aclaremos la idea, “Quiero prender una ampolleta cuando pase algo o alguien”, bueno primero necesitamos la Ampolleta, luego el Rele, un sensor de movimiento PIR, algunos componentes para que el Rele y el PIR hablen, 2 resistencias 1K y 2,2K y un transistor 2N2222, ahaha se me olvidaba la fuente de poder de 5 volt. Para el caso en particular el rele se activa con una señal baja osea sin señal de otra forma mientas no le llegue señal estar activo osea mantendrá la luz prendida y nosotros queremos lo contrario por lo tanto necesitamos invertir la señal para eso usamos el transistor 2N2222.

 

Aquí el esquema de la conexión:

inversor_esquema1

 

 

Aquí un esquema de nuestra protoboard con los componentes conectados.

pirrele_bb2

 

De esta forma ya tenemos un circuito bastante simple que enciende la luz al detectar un movimiento.

 

Fuente : aquí

Componentes:

PIR
RELE
2N2222

Resistencias

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!!!!

SomosMaker en el Mercurio.cl

Este Domingo 18 de Septiembre, Alexis Ibarra @chipote  del diario EL Mercurio  publico un reportaje sobre Arduinos y Raspberry pi donde nos hicieron una entrevista sobre todo este mundillo, les dejo el link para que la vean aquí

Solo por aclarar este reportaje fue 100% gratuito y nacio desde el Mercurio hacia nosotros, desde ya muchisimas gracias estas cosas son las mejores inyecciones de energia que podemos recibir, muchas gracias!!!!

captura-de-pantalla-2016-09-18-a-las-23-25-36

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

 

 

Como conectar nuestra Raspberry pi a nuestra red con samba

Por lo general prefiero trabajar con mis archivos via carpetas “broseables” por la red directo, para esto por lo general uso samba, aunque sea un poco nobs para algunos pero creo que es mas comodo.

 

Aquí dejo como configuro la Raspebian con Smb

1 instalamos samba

sudo apt-get install samba samba-common-bin

2 configuramos

sudo vi /etc/samba/smb.conf

Buscamos la linea

wins support = no

cambiamos por

wins support = yes

Luego agregamos

[piDesktop]
comment= PiDestop
path=/home/pi/Desktop/pi
browseable=Yes
writeable=Yes
only guest=no
create mask=0777
directory mask=0777
public=Yes

 

Listo Reiniciamos el server samba

/etc/init.d/smb restart

Done!!!!