DS1302 RTC Module

**** Working Code but subject to change as more features are added, basic functions working ****

**** Update Sept 2019 ****

For this example of using the DS1302 RTC Module we will be interfacing with it via the Z80 PIO, the code should be able to be adapted to other interface options.

Quick run down of the DS1302 Real Time Clock chip, for this example we have the Chip in a pre-made module with a 3-volt lithium Battery, the chip allows for also the use of Rechargeable Batteries or Super Capacitor though a trickle charge feature which can be found on Datasheet.

The chip has the following time keeping Functions: 12/24 hour mode, AM/PM, Hours, Minutes, seconds, day of the week, date, Month, year, time is stored in BCD format, Write protect Bit, and Oscillator enable bit, 31 bytes of 8 bit RAM storage

The chip is accessed by a Three wire interface, CLOCK, RESET (CE), DATA, since the DATA is both input and output, the connection to it must be bi-directional. The Z80 PIO mode 3 allows you to select which bits are inputs and outputs, this allows the DATA pin to be switch between a output to input during data read's.

Note from DS1302 Datasheet if power has been removed or not initialized for the first time the Write protect bit and Clock Oscillator enable bit are in a indeterminate state. At start up of program just to be sure you should write those bit's to zero to enable Clock.

The Clock timing diagram and Register address and definitions below will be used for creating our read and write routines.

Sample write routine:

Note I use custom defines for the Z80 and custom port Bit write/read routine that works similar to Arduino pin function. The function z80_pio_write_bit(port, bit 7-0, 1 or 0) and z80_pio_read_bit(port, bit 7-0) adds some overhead in code but helps in following the code.

ds1303_rtc_z80pio.c

/* DS1303 RTC Z80 PIO interface version */
#include "ds1303_rtc_z80pio.h"#include "z80_pio.h" #include <z80.h>#include <stdlib.h>#include <stdio.h>
/* PIO bit 0 = CLK, BIT 1 = DATA, BIT 2 = RESET/CE */
void rtc_read_time( char *ptr ){
int t, tc, tf;char data[25], sec_10,sec_1, min_10, min_1, hour_10, hour_1, am_pm, m12_24, day, date_1, date_10, month_1, month_10, year_1, year_10; char timeformat[3][3] = { {'M','T','\0'},{'A','M','\0'}, {'P','M','\0'} }; char *t_data;am_pm = 0;m12_24 = 0;

day = rtc_read(READ_DAY);month_10 = rtc_read(READ_MONTH);month_1 = month_10 & 0x0f;month_10 = month_10>>4;month_10 = month_1 + month_10 * 10;
date_10 = rtc_read(READ_DATE);date_1 = date_10 & 0x0f;date_10 = date_10>>4;
year_10 = rtc_read(READ_YEAR);year_1 = year_10 & 0x0f;year_10 = year_10>>4;

sec_10 = rtc_read(READ_SECONDS);sec_1 = sec_10 & 0x0f;sec_10 = sec_10>>4;//sec_10 = sec_1 + sec_10 * 10;
min_10 = rtc_read(READ_MINUTES);min_1 = min_10 & 0x0f;min_10 = min_10>>4;//min_10 = min_1 + min_10 * 10;
hour_10 = rtc_read(READ_HOUR);
m12_24 = hour_10 & 0x80;
if (m12_24 == 0x80) { m12_24 = 1; am_pm = hour_10 & 0x20; if ( am_pm == 0x20) { am_pm = 1; }else{ am_pm = 0; } }else{ m12_24 = 0; }
tf = am_pm + m12_24;
hour_1 = hour_10 & 0x0f;
hour_10 = (hour_10>>4) & 0x01;//hour_10 = hour_1 + hour_10 * 10;
t_data = ptr;
t_data[0] = ds_day[day][0];t_data[1] = ds_day[day][1];t_data[2] = ds_day[day][2];t_data[3] = ' ';t_data[4] = ds_month[month_10][0];t_data[5] = ds_month[month_10][1];t_data[6] = ds_month[month_10][2];t_data[7] = ' ';t_data[8] = date_10 + 48;t_data[9] = date_1 + 48;t_data[10] = ' ';t_data[11] = '2';t_data[12] = '0';t_data[13] = year_10 + 48;t_data[14] = year_1 + 48;t_data[15] = ' ';t_data[16] = hour_10 + 48;t_data[17] = hour_1 + 48;t_data[18] = ':';t_data[19] = min_10 + 48;t_data[20] = min_1 + 48;t_data[21] = ':';t_data[22] = sec_10 + 48;t_data[23] = sec_1 + 48;t_data[24] = ' ';t_data[25] = timeformat[tf][0];t_data[26] = timeformat[tf][1];t_data[27] = '\0';t_data[28] = 0;
//for(t=0;t<22;t++)//{ //*ptr++ = t_data[t];//}
}

void rtc_write(char address, char data ){char i, j;// make sure out PIO is set correctz80_outp( Z80_PIO_A_CTL, Z80_PIO_M3); // set mode 3 Port Bit set per maskz80_outp( Z80_PIO_A_CTL, 0xf8); // First Three bits set to output.
j = address;z80_pio_write_bit(Z80_PIO_A, 0, 0);z80_pio_write_bit(Z80_PIO_A, 2, 1);// Shift bit's out right, LSB-MSBfor(i=0; i < 8; i++) { z80_pio_write_bit(Z80_PIO_A, 0, 0); z80_pio_write_bit(Z80_PIO_A, 1, j & 0x01 ); z80_pio_write_bit(Z80_PIO_A, 0, 1); j = j>>1; }j = data;
// Shift bit's out right, LSB-MSBfor(i=0; i < 8; i++) { z80_pio_write_bit(Z80_PIO_A, 0, 0); z80_pio_write_bit(Z80_PIO_A, 1, j & 0x01 ); z80_pio_write_bit(Z80_PIO_A, 0, 1); j = j>>1; }
z80_pio_write_bit(Z80_PIO_A, 0, 0); z80_pio_write_bit(Z80_PIO_A, 2, 0);
}

char rtc_read(char k ){char i, j, t;// make sure out PIO is set correctz80_outp( Z80_PIO_A_CTL, Z80_PIO_M3); // set mode 3 Port Bit set per maskz80_outp( Z80_PIO_A_CTL, 0xf8); // First Three bits set to output.j = k;z80_pio_write_bit(Z80_PIO_A, 0, 0);z80_pio_write_bit(Z80_PIO_A, 2, 1);// Shift bit's out left, LSB-MSB// Write address to readfor(i=0; i < 8; i++) { z80_pio_write_bit(Z80_PIO_A, 0, 0); z80_pio_write_bit(Z80_PIO_A, 1, j & 0x01 ); z80_pio_write_bit(Z80_PIO_A, 0, 1); j = j>>1; }
z80_outp( Z80_PIO_A_CTL, Z80_PIO_M3); // set mode 3 Port Bit set per maskz80_outp( Z80_PIO_A_CTL, 0xfa); // First and Thrid bits set to output, now bit two is inputj=0;
for(i=0; i < 8; i++) { j = j>>1; z80_pio_write_bit(Z80_PIO_A, 0, 0); j= j | (0x80 * (0x01 & z80_pio_read_bit(Z80_PIO_A, 1))); z80_pio_write_bit(Z80_PIO_A, 0, 1); }z80_pio_write_bit(Z80_PIO_A, 0, 0); z80_pio_write_bit(Z80_PIO_A, 2, 0); return j;}

ds1303_rtc_z80pio.h

/* DS1303 RTC Z80 PIO interface version *//* header file */
#include "z80_pio.h" #include <z80.h>#include <stdlib.h>#include <stdio.h>
// Define DS1303 commands// Command specifies if a read or write operation// the registers store time in BCD format, conversion from binary must be done to write or read data// Note Datasheet states the Clock oscilator and Write protect are in a unknown state at intial powerup, unless battery backup is being used. You must set both to zero before the chip will operate.

#define READ_SECONDS 0x81 // Bit 7 is used for Clock oscilator enable, Bits 6-4 10's Place and Bit's 3-0 are one's place.
#define WRITE_SECONDS 0x80 // Bit 7 is used for Clock oscilator enable, Bits 6-4 10's Place and Bit's 3-0 are one's place.
#define READ_MINUTES 0x83 // Bits 6-4 10's Place and Bit's 3-0 are one's place.
#define WRITE_MINUTES 0x82 // Bits 6-4 10's Place and Bit's 3-0 are one's place.
#define READ_HOUR 0x85 // Bit 7 is 12/24 hour mode select, Bit 6 unused Bits 5-4 10's Place and Bit's 3-0 are one's place. Note bit 5 in 12 hour mode indicated AM low, PM high
#define WRITE_HOUR 0x84 // Bit 7 is 12/24 hour mode select, Bit 6 unused Bits 5-4 10's Place and Bit's 3-0 are one's place. Note bit 5 in 12 hour mode indicated AM low, PM high
#define READ_DATE 0x87 // Bit's 7 & 6 are unused, Bits 5 & 4 ten's Place, Bits 3-0 one's places (1-31)
#define WRITE_DATE 0x86 // Bit's 7 & 6 are unused, Bits 5 & 4 ten's Place, Bits 3-0 one's places (1-31)
#define READ_MONTH 0x89 // Bit's 7 & 6 are unused, Bits 5 & 4 ten's Place, Bits 3-0 one's places (1-12)
#define WRITE_MONTH 0x88 // Bit's 7 & 6 are unused, Bits 5 & 4 ten's Place, Bits 3-0 one's places (1-12)
#define READ_DAY 0x8b // Bit's 7 - 3 are unused, Bits 2-0 one's places (1-7)
#define WRITE_DAY 0x8a // Bit's 7 - 3 are unused, Bits 2-0 one's places (1-7)
#define READ_YEAR 0x8d // Bit's 7 - 3 are unused, Bits 2-0 one's places (0-99)
#define WRITE_YEAR 0x8c // Bit's 7 - 3 are unused, Bits 2-0 one's places (0-99)
#define READ_WP 0x8f // Bit 7 only 1 = Write protect
#define WRITE_WP 0x8e // Bit 7 only 1 = Write protect
#define READ_TCS 0x91 // Trickle Charge settings, see datasheet.
#define WRITE_TCS 0x90 // Trickle Charge settings
#define READ_CB 0xbf // Clock Burst read
#define WRITE_CB 0xbe // Clock Burst write
static const char *ds_day[] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
static const char *ds_month[] = {"January", "March", "April", "May", "June", "July", "Augest", "September", "November", "December" };

void rtc_read_time( char *ptr );void rtc_write(char address, char data );char rtc_read(char k );

Sample code using the above functions:

/* Z80 PIO RTC ds1302 clock module */

#include "ds1303_rtc_z80pio.h"#include "z80_pio.h"#include <z80.h>#include "Hyundai_256x128.h"#include <stdlib.h>#include <stdio.h>
void int2ascii(unsigned int cx, char *ptr );
int pio_int_a, pio_int_b;
void system_init(void);

int main(){int t, tc, tf;char data[30]; system_init();/*rtc_write(WRITE_WP, 0x00); // RTC write protect offrtc_write(WRITE_SECONDS, 0x00); // Seconds/Oscilator enablertc_write(WRITE_HOUR, 0xa4);rtc_write(WRITE_MINUTES, 0x36); rtc_write(WRITE_YEAR, 0x19);rtc_write(WRITE_DAY, 0x00);rtc_write(WRITE_DATE, 0x08); rtc_write(WRITE_MONTH, 0x07); */
LCD_set_cursor(0 , 0);LCD_print("RTC DS1302 test\0");t=1;while( t != 0){

rtc_read_time( data );LCD_set_cursor(0 , 4);LCD_print(data);

z80_delay_ms(500);}

return 0;}

void system_init(void){
// initialize PIO ports
z80_outp( Z80_PIO_A_CTL, Z80_PIO_M3); // set mode 3 Port Bit set per maskz80_outp( Z80_PIO_A_CTL, 0xf8); // First Three bits set to output.

z80_outp( Z80_PIO_B_CTL, Z80_PIO_M1); // set mode 1 byte input

// intialize displayLCD_write_cmd( 0x40 ); // System set commandLCD_write(0x30); // P1 use internal 8px char w/ no top line correctionLCD_write(0x87); // P2 8px width charLCD_write(0x07); // P3 8px height charLCD_write(0x1f); // P4 32 char per lineLCD_write(0x23); // P5 previous value + 4LCD_write(0x7f); // P6 128 pixel screen heightLCD_write(0x20); // P7 32 char per lineLCD_write(0x00); // P8

LCD_write_cmd(0x5d); // Set cursor typeLCD_write(0x04);LCD_write(0x86);LCD_write_cmd(0x4c); // Set direction of cursor movementLCD_write_cmd(0x5B); // Set display overlayLCD_write(0x08); //3

LCD_write_cmd(0x44); //Scroll - Set display start address and display regionsLCD_write(0x00);LCD_write(0x00);LCD_write(0x80);LCD_write(0xb0);LCD_write(0x04);LCD_write(0x80);LCD_write(0x00);LCD_write(0x00);LCD_write(0x80);LCD_write(0xb0);

LCD_write_cmd(0x5A); // Set horizontal scroll LCD_write(0x00);

LCD_write_cmd(0x59); // Display onLCD_write(0x16); // 06
LCD_clear();LCD_graphics_clear();LCD_set_cursor(0, 0);

}
void int2ascii(unsigned int cx, char *ptr ){ int i;ptr = ptr + 5;
*ptr-- = '\0';
for( i = 0; i < 5; i++){*ptr-- = '0' + cx % 10 ;cx = cx / 10;} }

Page updated

Google Sites

Report abuse