PIC16F887 I2C DS1307 RTC LCD Using XC8

Overview

PIC16F887 has a Master Synchronous Serial Port (MSSP) module that's useful for communicating with other serial interface peripheral or micro-controller devices. These peripheral devices may be Serial EEPROMs, shift registers, display drivers, A/D converters, etc. The MSSP module can operate in one of two modes:

• Serial Peripheral Interface (SPI)
• Inter-Integrated Circuit (I2C)
•  Full Master mode
•  Slave mode (with general address call).

The I2C interface supports the following modes in hardware:

• Master mode
• Multi-Master mode
• Slave mode.

In this example, I picking up the I2C mode of this communication module. Inter Integrated Circuit (I2C) is a two wire communication interface developed by Phillip. It's useful for communicating with other peripheral such as serial EEPROM, Real Time Clock (RTC), I/O expanding, sensor, or even other micro-controllers.

Running Program

 

Operation Modes

Master mode is common for interfacing with other on board peripheral. PIC16F887 uses two wires to transmit data serially, SDA(RC4) and SCL(RC3).

Master Mode Block Diagram

The Baud Rate Generator used for the SPI mode operation is now used to set the SCL clock frequency for either 100 kHz, 400 kHz, or 1 MHz I2C operation.The Baud Rate Generator reload value is contained in the lower 7 bits of the SSPADD register. 

In master mode we will need to use these MSSP registers,

MSSP Control Register 1 (SSPCON)
MSSP Control Register 2 (SSPCON2)
MSSP STATUS register (SSPSTAT)
Serial Receive/Transmit Buffer (SSPBUF)
MSSP Address register (SSPADD)

There are also two peripheral interrupt registers PIR1 and PIE1. 

A typical transmit sequence would go as follows:

a- The user generates a Start condition by setting the Start Enable (SEN) bit (SSPCON2 register).
b- SSPIF is set. The MSSP module will wait the required start time before any other operation
takes place.
c- The user loads the SSPBUF with the address to transmit.
d- Address is shifted out the SDA pin until all eight bits are transmitted.
e- The MSSP module shifts in the ACK bit from the slave device and writes its value into the
ACKSTAT bit (SSPCON2 register).
f- The MSSP module generates an interrupt at the end of the ninth clock cycle by setting the SSPIF bit.
g- The user loads the SSPBUF with eight bits of data.
h- Data is shifted out the SDA pin until all eight bits are transmitted.
i- The MSSP module shifts in the ACK bit from the slave device and writes its value into the
ACKSTAT bit (SSPCON2 register).
j- The MSSP module generates an interrupt at the end of the ninth clock cycle by setting the SSPIF bit.
k- The user generates a Stop condition by setting the Stop Enable bit PEN (SSPCON2 register).
l- Interrupt is generated once the Stop condition is complete. 

DS1307 RTC

The DS1307 serial real-time clock (RTC) is a lowpower, full binary-coded decimal (BCD) clock/calendar plus 56 bytes of NV SRAM. Address and data are transferred serially through an I2C, bidirectional bus. The clock/calendar provides seconds, minutes, hours, day, date, month, and year information. The end of the month date is automatically adjusted for months
with fewer than 31 days, including corrections for leap year. The clock operates in either the 24-hour or 12- hour format with AM/PM indicator. The DS1307 has a built-in power-sense circuit that detects power failures and automatically switches to the backup supply.
Timekeeping operation continues while the part operates from the backup supply.

DS1307 I2C RTC 8-PIN DIP

 

Typical Operating Circuit

PIN CONFIGURATIONS

Timekeeper Registers

Data Read—Slave Transmitter Mode

Data Read—Slave Transmitter Mode

We 0xD0 for address write, and 0xD1 for address read. 

MPLABX IDE and XC8 Programming

Using C compiler is very common for most of small 8-bit micro-controller now. XC8 has free version of C compiler for 8-bit PIC micro-controller.

In this example, I use a PIC16F887, a 20x4 character LCD, a DS1307 RTC, an alarm buzzer, four input buttons, etc. The program display current time, date, and alarm information. It also allow us to adjust these parameters manually using push buttons.

/*
 * File:   main.c
 * Author: Admin
 *
 * Created on January 2, 2024, 2:37 PM
 */
 
#include <xc.h>
#include "config.h"
#include "i2c.h"
#include "lcd.h"
#include <stdio.h>
 
//__EEPROM_DATA(0,28,15,0,0,0,0,0);
 
const char ds1307_write = 0xD0;
const char ds1307_read  = 0xD1;
 
char msg[16],_rtc[7],_alarm[3],_match=0;
 
uint8_t bcd2dec(uint8_t data){
    return (data>>4)*10+(data&0x0F);
}
uint8_t dec2bcd(uint8_t data){
    return ((data/10)<<4)+(data%10);
}
 
void day_of_week(char _day){
    lcdXY(1,3); lcdString("Date : ");
    switch(_day){
        case 1: lcdString("Monday");    break;
        case 2: lcdString("Tuesday");   break;
        case 3: lcdString("Wednesday"); break;
        case 4: lcdString("Thursday");  break;
        case 5: lcdString("Friday");    break;
        case 6: lcdString("Saturday");  break;
        case 7: lcdString("Sunday");    break;
    }
}
 
uint8_t setting=0;
void __interrupt() MY_ISR(void){
    if(RBIF){
        if(RB0==0){           
            setting++;
        }
        if(RB1==0){
            if(setting==1){
                _rtc[2]=bcd2dec(_rtc[2]);
                _rtc[2]++; 
                if(_rtc[2]>0x23) _rtc[2]=0;
                _rtc[2]=dec2bcd(_rtc[2]);
                i2c_start();
                i2c_write(ds1307_write);
                i2c_write(2);
                i2c_write(_rtc[2]);
                i2c_stop();
            }
            if(setting==2){
                _alarm[2]=bcd2dec(_alarm[2]);
                _alarm[2]++;
                if(_alarm[2]>23) _alarm[2]=0;
                EEPROM_WRITE(2,_alarm[2]);
                while(RW);
                _alarm[2]=dec2bcd(_alarm[2]);
            }
            if(setting==3){
                _rtc[6]=bcd2dec(_rtc[6]);
                _rtc[6]++;
                if(_rtc[6]>99) _rtc[6]=0;
                _rtc[6]=dec2bcd(_rtc[6]);
                i2c_start();
                i2c_write(ds1307_write);
                i2c_write(6);
                i2c_write(_rtc[6]);
                i2c_stop();
            }
            if(setting==4){
                _rtc[3]++;
                if(_rtc[3]>0x07) _rtc[3]=0;
                i2c_start();
                i2c_write(ds1307_write);
                i2c_write(3);
                i2c_write(_rtc[3]);
                i2c_stop();
            }
        }
        if(RB2==0){
            if(setting==1){
                _rtc[1]=bcd2dec(_rtc[1]);
                _rtc[1]++; 
                if(_rtc[1]>0x59) _rtc[1]=0;
                _rtc[1]=dec2bcd(_rtc[1]);
                i2c_start();
                i2c_write(ds1307_write);
                i2c_write(1);
                i2c_write(_rtc[1]);
                i2c_stop();
            }
            if(setting==2){
                _alarm[1]=bcd2dec(_alarm[1]);
                _alarm[1]++;
                if(_alarm[1]>59) _alarm[1]=0;
                EEPROM_WRITE(1,_alarm[1]);
                while(RW);
                _alarm[1]=dec2bcd(_alarm[1]);
            }
            if(setting==3){
                _rtc[5]=bcd2dec(_rtc[5]);
                _rtc[5]++;
                if(_rtc[5]>0x12) _rtc[5]=1;
                _rtc[5]=dec2bcd(_rtc[5]);
                i2c_start();
                i2c_write(ds1307_write);
                i2c_write(5);
                i2c_write(_rtc[5]);
                i2c_stop();
            }           
        }
        if(RB3==0){
            if(setting==1){
                _rtc[0]=bcd2dec(_rtc[0]);
                _rtc[0]++; 
                if(_rtc[0]>0x59) _rtc[0]=0;
                _rtc[0]=dec2bcd(_rtc[0]);
                i2c_start();
                i2c_write(ds1307_write);
                i2c_write(0);
                i2c_write(_rtc[0]);
                i2c_stop();
            }
            if(setting==2){
                _alarm[0]=bcd2dec(_alarm[0]);
                _alarm[0]++;
                if(_alarm[0]>59) _alarm[0]=0;
                EEPROM_WRITE(0,_alarm[0]);
                while(RW);
                _alarm[0]=dec2bcd(_alarm[0]);
            }
            if(setting==3){
                _rtc[4]=bcd2dec(_rtc[4]);
                _rtc[4]++;
                if(_rtc[4]>0x31) _rtc[4]=1;
                _rtc[4]=dec2bcd(_rtc[4]);
                i2c_start();
                i2c_write(ds1307_write);
                i2c_write(4);
                i2c_write(_rtc[4]);
                i2c_stop();
            }          
        }
        RBIF=0;
        __delay_ms(200);
    }
    if(setting>4) {
            setting=0;
            lcdCommand(0x01);
            __delay_ms(5);
        }
}
void main(void) {
    OSCCONbits.IRCF=7;
 
    _alarm[2]=dec2bcd(EEPROM_READ(2));
    _alarm[1]=dec2bcd(EEPROM_READ(1));
    _alarm[0]=dec2bcd(EEPROM_READ(0));
    lcdInit();
    TRISD7=0;
    i2c_init(100000);
    PORTB=0;
    TRISB=0x0F;
    OPTION_REGbits.nRBPU=0;
    WPUB=0x0F;
    IOCB=0x0F;
    INTCONbits.RBIE=1;
    INTCONbits.RBIF=0;
    INTCONbits.GIE=1;  
    lcdCommand(0x0C);
    __delay_ms(5);
 
    while(1){
        for(char i=0;i<7;i++){
            i2c_start();
            i2c_write(ds1307_write);
            i2c_write(i);
            i2c_stop();
            __delay_us(100);
 
            i2c_start();
            i2c_write(ds1307_read);
            _rtc[i]=i2c_read(0);
            i2c_stop();
            __delay_us(100);
        }
        sprintf(msg,"Time : %2d:%2d:%2d",
                bcd2dec(_rtc[2]),bcd2dec(_rtc[1]),bcd2dec(_rtc[0]));
        lcdXY(1,1); lcdString(msg);
        sprintf(msg,"Alarm: %2d-%2d-%2d",
                bcd2dec(_alarm[2]),bcd2dec(_alarm[1]),bcd2dec(_alarm[0]));
        lcdXY(1,2); lcdString(msg);
        sprintf(msg,"20%2d/%2d/%2d  %dth",
                bcd2dec(_rtc[6]),bcd2dec(_rtc[5]),bcd2dec(_rtc[4]),bcd2dec(_rtc[3]));
        lcdXY(1,4); lcdString(msg);
        day_of_week(_rtc[3]);
        for(char i=0;i<3;i++){
            if((_alarm[i]-_rtc[i])==0) _match++;
        }
        if(_match==3){
            RD7=1;
            __delay_ms(5000);
 
        }else RD7=0;
        _match=0;
 
        switch(setting){
            case 1: lcdXY(16,1); lcdData('<'); break;
            case 2: lcdXY(16,2); lcdData('<'); break;
            case 3: lcdXY(16,3); lcdData('<'); break;
            case 4: lcdXY(16,4); lcdData('<'); break;
        }
        __delay_ms(500);
    }
    return;
}
 

I use my own test board to run this program. A PICKit2 programmer still support this chip.

Proteus Simulation