News

  • General

Twitter

ChilliTronix

ChilliTronix @nsoamesmp @happilyHeather @wardenpark They could take over the campus... and run it properly.

about 1 year ago via Twitter Web Client

ChilliTronix

ChilliTronix @ukscone Sorry, all they needed was the password the employers had or they just needed a pin?

about 1 year ago via Twitter Web Client

ChilliTronix

ChilliTronix @ukscone Really? Wow. And these people are supposed to keep the USA safe?

about 1 year ago via Twitter Web Client

ChilliTronix

ChilliTronix @EFF @ukscone Which it could have done on day one, or it could have asked the NSA or GCHQ.

about 1 year ago via Twitter Web Client

ChilliTronix

ChilliTronix RT @EFF: BREAKING: FBI asks court to drop San Bernardino order against Apple, announcing it got into the phone without the company's help.

about 1 year ago via Twitter Web Client

@nsoamesmp @happilyHeather @wardenpark They could take over the campus... and run it properly.

about 1 year ago from Twitter Web Client

@ukscone Sorry, all they needed was the password the employers had or they just needed a pin?

about 1 year ago from Twitter Web Client

@ukscone Really? Wow. And these people are supposed to keep the USA safe?

about 1 year ago from Twitter Web Client

@EFF @ukscone Which it could have done on day one, or it could have asked the NSA or GCHQ.

about 1 year ago from Twitter Web Client

RT @EFF: BREAKING: FBI asks court to drop San Bernardino order against Apple, announcing it got into the phone without the company's help.

about 1 year ago from Twitter Web Client

Real Time Clock, DS1307 and 24C32 EEPROM

The Tiny RTC Real time clock module includes not only a real time clock (the DS1307) but an I2C EEPROM, the Atmel 24C32, and a LIR2032 battery. Every thing you need to operate a real time clock is included, and should you be so inclined you can also add a Dallas One Wire temperature sensor, and then read that as well. This device does not include one though. The EEPROM contains 32K bits, or 4K bytes.

 

Tiny RTC Real Time Clock with DS1307 and 24C32

Pin out is as written on the board, on the left hand side from the top of the picture:

  1. Dallas one wire (not used)
  2. SCL (I2C bus clock)
  3. SDA (I2C bus data)
  4. VCC (+5V)
  5. Ground.

This is all you actually need to use both the clock and the EEPROM. On the other side there s:

  1. SQ, Square wave output, if set, can be set to run at 1Hz, 4KHz, 8KHz or 32KHz.
  2. DS, as above, Dallas one wire bus not used.
  3. SCL (I2C bus clock)
  4. SDA (I2C bus data)
  5. VCC (+5V)
  6. Ground.
  7. Batt. This allows you to monitor the battery voltage, see notes below.

These units work well with Arduinos, it is as simple as connecting 4 wires, +V, ground, and the two I2C bus wires which gives access to both the real time clock and EEPROM. The real time clock will not run unless initialised (It keeps it's data in RAM which can be cleared by removing the battery which also de initialises it).

To use the Real Time Clock with a Raspberry Pi see here or here. It is a case of connecting power and I2C and then loading some modules. Note that you are unlikely to use the EEPROM on the PI.

For Arduino we recommend the DS1307RTC library here, and the time library from the same website here. We did have an issue compiling on our setup due to compiler differences. The Time Library contains a file called DateStrings.cpp. If you get compile time errors please copy and paste the following into your DateStrings.cpp:

/* DateStrings.cpp
 * Definitions for date strings for use with the Time library
 *
 * No memory is consumed in the sketch if your code does not call any of the string methods
 * You can change the text of the strings, make sure the short strings are each exactly 3 characters 
 * the long strings can be any length up to the constant dt_MAX_STRING_LEN defined in Time.h
 * 
 */

#if defined(__AVR__)
#include <avr/pgmspace.h>
#else
// for compatiblity with Arduino Due and Teensy 3.0 and maybe others?
#define PROGMEM
#define PGM_P  const char *
#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
#define pgm_read_word(addr) (*(const unsigned char **)(addr))
#define strcpy_P(dest, src) strcpy((dest), (src))
#endif
#include <string.h> // for strcpy_P or strcpy
#include "Time.h"
 
// the short strings for each day or month must be exactly dt_SHORT_STR_LEN
#define dt_SHORT_STR_LEN  3 // the length of short strings

static char buffer[dt_MAX_STRING_LEN+1];  // must be big enough for longest string and the terminating null

const char monthStr1[] PROGMEM = "January";
const char monthStr2[] PROGMEM = "February";
const char monthStr3[] PROGMEM = "March";
const char monthStr4[] PROGMEM = "April";
const char monthStr5[] PROGMEM = "May";
const char monthStr6[] PROGMEM = "June";
const char monthStr7[] PROGMEM = "July";
const char monthStr8[] PROGMEM = "August";
const char monthStr9[] PROGMEM = "September";
const char monthStr10[] PROGMEM = "October";
const char monthStr11[] PROGMEM = "November";
const char monthStr12[] PROGMEM = "December";

PGM_P const monthNames_P[] PROGMEM = 
{
    "",monthStr1,monthStr2,monthStr3,monthStr4,monthStr5,monthStr6,
	monthStr7,monthStr8,monthStr9,monthStr10,monthStr11,monthStr12
};

const char monthShortNames_P[] PROGMEM = "ErrJanFebMarAprMayJunJulAugSepOctNovDec";

const char dayStr0[] PROGMEM = "Err";
const char dayStr1[] PROGMEM = "Sunday";
const char dayStr2[] PROGMEM = "Monday";
const char dayStr3[] PROGMEM = "Tuesday";
const char dayStr4[] PROGMEM = "Wednesday";
const char dayStr5[] PROGMEM = "Thursday";
const char dayStr6[] PROGMEM = "Friday";
const char dayStr7[] PROGMEM = "Saturday";

PGM_P const dayNames_P[] PROGMEM = { dayStr0,dayStr1,dayStr2,dayStr3,dayStr4,dayStr5,dayStr6,dayStr7};
const char dayShortNames_P[] PROGMEM = "ErrSunMonTueWedThrFriSat";

/* functions to return date strings */

char* monthStr(uint8_t month)
{
    strcpy_P(buffer, (PGM_P)pgm_read_word(&(monthNames_P[month])));
	return buffer;
}

char* monthShortStr(uint8_t month)
{
   for (int i=0; i < dt_SHORT_STR_LEN; i++)      
      buffer[i] = pgm_read_byte(&(monthShortNames_P[i+ (month*dt_SHORT_STR_LEN)]));  
   buffer[dt_SHORT_STR_LEN] = 0;
   return buffer;
}

char* dayStr(uint8_t day) 
{
   strcpy_P(buffer, (PGM_P)pgm_read_word(&(dayNames_P[day])));
   return buffer;
}

char* dayShortStr(uint8_t day) 
{
   uint8_t index = day*dt_SHORT_STR_LEN;
   for (int i=0; i < dt_SHORT_STR_LEN; i++)      
      buffer[i] = pgm_read_byte(&(dayShortNames_P[index + i]));  
   buffer[dt_SHORT_STR_LEN] = 0; 
   return buffer;
}

 

 

You need to initialise the clock, we used the example included in the D1307RTC library called set time which will set the time if not set to when that example sketch was compiled. (Which when we compiled it and uploaded it was around seconds behind the current time).

You don't need to do anything with the EEPROM, but if you want to run our test sketch below, you first need to put something in the EEPROM and we used the sketch below which we got from here, but had to edit to fix changes to calls to the Wire library.

/* 
  *  Use the I2C bus with EEPROM 24LC64 
  *  Sketch:    eeprom.pde
  *  
  *  Author: hkhijhe
  *  Date: 01/10/2010
  * 
  * Modified by ChilliTronix 13/08/2014 to change calls to the Wire.h library 
  * as Wire.send() is not Wire.write and Wire.receive() is now Wire.read()  
  */

  #include <Wire.h> //I2C library



  void i2c_eeprom_write_byte( int deviceaddress, unsigned int eeaddress, byte data ) {
    int rdata = data;
    Wire.beginTransmission(deviceaddress);
    Wire.write((int)(eeaddress >> 8)); // MSB
    Wire.write((int)(eeaddress & 0xFF)); // LSB
    Wire.write(rdata);
    Wire.endTransmission();
  }

  // WARNING: address is a page address, 6-bit end will wrap around
  // also, data can be maximum of about 30 bytes, because the Wire library has a buffer of 32 bytes
  void i2c_eeprom_write_page( int deviceaddress, unsigned int eeaddresspage, byte* data, byte length ) {
    Wire.beginTransmission(deviceaddress);
    Wire.write((int)(eeaddresspage >> 8)); // MSB
    Wire.write((int)(eeaddresspage & 0xFF)); // LSB
    byte c;
    for ( c = 0; c < length; c++)
      Wire.write(data[c]);
    Wire.endTransmission();
  }

  byte i2c_eeprom_read_byte( int deviceaddress, unsigned int eeaddress ) {
    byte rdata = 0xFF;
    Wire.beginTransmission(deviceaddress);
    Wire.write((int)(eeaddress >> 8)); // MSB
    Wire.write((int)(eeaddress & 0xFF)); // LSB
    Wire.endTransmission();
    Wire.requestFrom(deviceaddress,1);
    if (Wire.available()) rdata = Wire.read();
    return rdata;
  }

  // maybe let's not read more than 30 or 32 bytes at a time!
  void i2c_eeprom_read_buffer( int deviceaddress, unsigned int eeaddress, byte *buffer, int length ) {
    Wire.beginTransmission(deviceaddress);
    Wire.write((int)(eeaddress >> 8)); // MSB
    Wire.write((int)(eeaddress & 0xFF)); // LSB
    Wire.endTransmission();
    Wire.requestFrom(deviceaddress,length);
    int c = 0;
    for ( c = 0; c < length; c++ )
      if (Wire.available()) buffer[c] = Wire.read();
  }




  void setup() 
  {
    char somedata[] = "this is data from the eeprom"; // data to write
    Wire.begin(); // initialise the connection
    Serial.begin(9600);
    i2c_eeprom_write_page(0x50, 0, (byte *)somedata, sizeof(somedata)); // write to EEPROM 

    delay(10); //add a small delay

    Serial.println("Memory written");
  }

  void loop() 
  {
    int addr=0; //first address
    byte b = i2c_eeprom_read_byte(0x50, 0); // access the first address from the memory

    while (b!=0) 
    {
      Serial.print((char)b); //print content to serial port
      addr++; //increase address
      b = i2c_eeprom_read_byte(0x50, addr); //access an address from the memory
    }
    Serial.println(" ");
    delay(2000);

  }

 

 

And below a full sketch to show reading the time, EEPROM and checking the battery voltage. Please note that connecting the battery permenently wo an analog input on an Arduino will drain the battery as, from what we can tell, the input will look like a 10K resistor.

 

/* Written by ChilliTronix Ltd 10/08/2014
From the examples in the DTC1307RTC library and an example 
of I2C EEPROM usage here: http://playground.arduino.cc/code/I2CEEPROM
However there are some errors due to changes in the wire library so we
have chaged Wire.send to Wire.write.

Please note there are other worked examples of I2C EEPROM usage
See for example here: http://playground.arduino.cc/Main/LibraryForI2CEEPROM


*/

#include <Wire.h>
#include <Time.h>
#include <DS1307RTC.h>

int batteryTestPin = A3;
int batteryValue = 0;
float batteryVoltage = 0;

void setup() {
  Serial.begin(9600);
  while (!Serial) ; // wait for serial
  delay(200);
  Serial.println("DS1307RTC Read Test");
  Serial.println("-------------------");
}

void loop() {
  tmElements_t tm;

  if (RTC.read(tm)) {
    Serial.print("Ok, Time = ");
    print2digits(tm.Hour);
    Serial.write(':');
    print2digits(tm.Minute);
    Serial.write(':');
    print2digits(tm.Second);
    Serial.print(", Date (D/M/Y) = ");
    Serial.print(tm.Day);
    Serial.write('/');
    Serial.print(tm.Month);
    Serial.write('/');
    Serial.print(tmYearToCalendar(tm.Year));
    Serial.println();
  } else {
    if (RTC.chipPresent()) {
      Serial.println("The DS1307 is stopped.  Please run the SetTime");
      Serial.println("example to initialize the time and begin running.");
      Serial.println();
    } else {
      Serial.println("DS1307 read error!  Please check the circuitry.");
      Serial.println();
    }
    delay(9000);
  }
  delay(1000);
  
  
  // Read I2C EEPROM
    int addr=0; //first address
    byte b = i2c_eeprom_read_byte(0x50, 0); // access the first address from the memory

    while (b!=0) 
    {
      Serial.print((char)b); //print content to serial port
      addr++; //increase address
      b = i2c_eeprom_read_byte(0x50, addr); //access an address from the memory
    }
    Serial.println(" ");
    
    
    //Now lets check the battery voltage
    batteryValue = analogRead(batteryTestPin);
    batteryVoltage = batteryValue * (5.0/1023.0);
    Serial.print("Batter voltage is: ");
    Serial.println(batteryVoltage);

}

void print2digits(int number) {
  if (number >= 0 && number < 10) {
    Serial.write('0');
  }
  Serial.print(number);
}



// Library calls for I2C memory below

void i2c_eeprom_write_byte( int deviceaddress, unsigned int eeaddress, byte data ) {
    int rdata = data;
    Wire.beginTransmission(deviceaddress);
    Wire.write((int)(eeaddress >> 8)); // MSB
    Wire.write((int)(eeaddress & 0xFF)); // LSB
    Wire.write(rdata);
    Wire.endTransmission();
  }

  // WARNING: address is a page address, 6-bit end will wrap around
  // also, data can be maximum of about 30 bytes, because the Wire library has a buffer of 32 bytes
  void i2c_eeprom_write_page( int deviceaddress, unsigned int eeaddresspage, byte* data, byte length ) {
    Wire.beginTransmission(deviceaddress);
    Wire.write((int)(eeaddresspage >> 8)); // MSB
    Wire.write((int)(eeaddresspage & 0xFF)); // LSB
    byte c;
    for ( c = 0; c < length; c++)
      Wire.write(data[c]);
    Wire.endTransmission();
  }

  byte i2c_eeprom_read_byte( int deviceaddress, unsigned int eeaddress ) {
    byte rdata = 0xFF;
    Wire.beginTransmission(deviceaddress);
    Wire.write((int)(eeaddress >> 8)); // MSB
    Wire.write((int)(eeaddress & 0xFF)); // LSB
    Wire.endTransmission();
    Wire.requestFrom(deviceaddress,1);
    if (Wire.available()) rdata = Wire.read();
    return rdata;
  }

  // maybe let's not read more than 30 or 32 bytes at a time!
  void i2c_eeprom_read_buffer( int deviceaddress, unsigned int eeaddress, byte *buffer, int length ) {
    Wire.beginTransmission(deviceaddress);
    Wire.write((int)(eeaddress >> 8)); // MSB
    Wire.write((int)(eeaddress & 0xFF)); // LSB
    Wire.endTransmission();
    Wire.requestFrom(deviceaddress,length);
    int c = 0;
    for ( c = 0; c < length; c++ )
      if (Wire.available()) buffer[c] = Wire.read();
  }