/*
** ###################################################################
**     Filename  : DS1307_test.c
**     Compiler  : CodeWarrior compiler
**     DataSheet : DS1307 64x8, Serial, IIC Real-Time Clock
**                 REV: 071405
**     Processor : MC68HC908JL16CSPE
**     Date/Time : 2.27.2008
**     Abstract  :
**         This is the complete program file for SPRING 2008 for 
**         EE459L - Embedded Systems Design Laboratory Senior Design
**         Project.
**    
**
**     Omair Khan
**     University of Southern California
**     www.omair-khan.com
**
**
**      Revisions:
**        none
**
** ###################################################################
*/

#include <hidef.h> /* for EnableInterrupts macro */
#include "derivative.h" /* include peripheral declarations */
#include "ds1307.h" /* include DS1307 definitions */

/*
  The following puts the dummy interrupt service routine at
  location MY_ISR_ROM which is defined in the PRM file as
  the start of the FLASH ROM
*/

#pragma CODE_SEG MY_ISR_ROM

#pragma TRAP_PROC
void dummyISR(void)
{
}

/*
  This pragma sets the code storage back to default area of ROM as defined in
  the PRM file.
*/

#pragma CODE_SEG DEFAULT

void init_uP(void);
void del1m(int d);
void wait_100ms(void);
void blink_LED(int x);

void init_LCD(void);
void writeLCDcmd(unsigned char data,int a);
void writeNUM(int a);

void IIC_trans_start(unsigned char devAddress,unsigned char regAddrLSB);
void IIC_trans_ack(unsigned char nextNextData);
void IIC_rec_start(unsigned char devAddress);
void IIC_rec_wait(void);
void IIC_rec_disableAck(void);
void IIC_stop(void);

void DS1307_reg_init(void);
void set_dummy_alarm(void);
void DS1307_update_time(void);
void DS1307_save_alarm(void);
void DS1307_read_time(void);
void display_curr_time(void);
void alarm(void);

#pragma DATA_SEG __SHORT_SEG MY_ZEROPAGE

unsigned int delay0;
unsigned int delay1;

unsigned char flag=0;

/*
**********************************
*                                *
*     Main                       *
*                                *
**********************************
*/

void main(void) {

int rc=0;


init_uP();
init_LCD();

DS1307_reg_init();
DS1307_update_time();

set_dummy_alarm();
DS1307_save_alarm();


while (1) {

DS1307_read_time();
display_curr_time();

alarm();
      
}
  /* please make sure that you never leave this function */
}


/*
*********************************************************************************
*                                                                               *
*     Functions                                                                 *
*                                                                               *
*********************************************************************************
*/

void init_uP(){
  
CONFIG1_COPD = 1;        // disable COP reset
CONFIG2_IICSEL=1;       //Set MMIIC SDA on PTA2 & SCL on PTA3

DDRA_DDRA5=1;
PTA_PTA5=0;            // reset lcd
 
DDRB = 0xFF;          //set port B for output (LCD DATABUS)
 
DDRA_DDRA0=1;        //LED (NIGHTLIGHT)

DDRA_DDRA1=1;        //LCD /WR
PTA_PTA1=1;

DDRA_DDRA4=1;        //LCD A0
PTA_PTA4=1;
 
DDRD_DDRD1=1;       //LCD /CS
PTD_PTD1=1; 


MIMCR_MMBR2=0;      //Set Baudrate to (internal clk / 32)
MIMCR_MMBR1=1;      //10MHZ/4 = 2500000 hz
MIMCR_MMBR0=0;      //2500000/32 = 78125 hz

MMCR_MMEN=1;        //Enable MMIIC

  
}

/*
**********************************
*                                *
*     LCD                        *
*                                *
**********************************
*/

void init_LCD() {
  

int ra=0;


PTA_PTA5=1;         // deactivate reset



writeLCDcmd(0x58,1);   //turn off display

writeLCDcmd(0x40,1);   //initialize LCD

writeLCDcmd(0x30,0);   //Int CG, 32chr CGRAM, 8lines/char, single pane, No invert, lcd, normal shift clock
writeLCDcmd(0x87,0);   //8 pixel wide characters, 2 frame AC drive
writeLCDcmd(0x07,0);   //vertical char size=8 pixels
writeLCDcmd(0x1F,0);   //32 display bytes per line
writeLCDcmd(0x23,0);   //tot. addr range per line (4 extra for horz blk)
writeLCDcmd(0x7F,0);   //128 display lines
writeLCDcmd(0x20,0);   //low byte of virtual screen width
writeLCDcmd(0x00,0);   //high byte of virtual screen width


writeLCDcmd(0x44,1);   //send scroll cmd
writeLCDcmd(0x00,0);   //set layer 1 home addr to 0x0000
writeLCDcmd(0x00,0);
writeLCDcmd(0x7F,0);  //128 lines for layer 1


writeLCDcmd(0x00,0);   //set layer 2 (graphic) home address to 0x1000
writeLCDcmd(0x10,0);   
writeLCDcmd(0x7F,0);  //128 lines for layer 2


                    //layers 3 and 4 not used
                                     
                    
writeLCDcmd(0x5A,1);   //set hor scroll cmd
writeLCDcmd(0x00,0);   //no hor scroll adjustment

writeLCDcmd(0x5B,1);   //set overlay selections cmd
writeLCDcmd(0x00,0);   //OR layers, text block 1, 2 layer (layer 2 can only be graphic)

writeLCDcmd(0x4C,1);   //auto cursor increment +1 cmd

writeLCDcmd(0x46,1);   //cursor write cmd
writeLCDcmd(0x00,0);   //0x00 addr
writeLCDcmd(0x00,0);



writeLCDcmd(0x42,1);   //send mwrite cmd


                    //for a total of 512 ascii spaces (0x20)
                    
for(ra=1;ra<512;++ra)
  writeLCDcmd(0x20,0);                    


//send 7168 zeros of data to clr out CGRAM area
//(28 x 256 = 7168)
//from 0400h to 0FFFh and the graphics area from
//1000h to 1FFFh


for(ra=0; ra<3584; ++ra) 
  writeLCDcmd(0x00,0);

  
for(ra=0; ra<4096; ++ra) 
  writeLCDcmd(0x00,0);
 
 
 
writeLCDcmd(0x5D,1);   //set cursor format
writeLCDcmd(0x04,0);   //five pixels wide
writeLCDcmd(0x86,0);   //vertical cursor size=7 pixels block cursor


writeLCDcmd(0x59,1);   //display ON
writeLCDcmd(0b00010100,0);   //(0b00010100) no layer 3, show layer 2, show layer 1, no cursor



writeLCDcmd(0x5C,1);   //set CGRAM addr cmd
writeLCDcmd(0x00,0);   //CGRAM addr = 0x0400
writeLCDcmd(0x04,0);


//----- DISPLAY IS CLEARED AND ON ------  
  
}

void writeLCDcmd(unsigned char data,int a) {

PTB = data;      //put data on databus
 
if(a==1)
  PTA_PTA4 = 1;    //write to (0 = data, 1 = command) register
if(a==0)
  PTA_PTA4 = 0;

PTD_PTD1 = 0;    //enable /CS
PTA_PTA1 = 0;    //enable /WR

PTA_PTA1 = 1;    //disable /WR
PTD_PTD1 = 1;    //disable /CS



}

void writeNUM(int a) {
  
  
writeLCDcmd((0x30)+a,0); 
   
  
}


/*
  del1m - Delay about 1msec times the "d" argument.
*/
void del1m(int d)
{

         /*   ; The following code delays 1 millisecond by looping.
            ; Total time is 4 + 2 * (3 + 256 * (4 + 3) + 4 + 3) = 3608 cycles
            ; A 12MHz external clock gives an internal CPU clock of 3MHz
            ; (333ns/cycle).  Delay is then 1.2 milliseconds.  Close enough.
          */

    while (d--) {
        asm{
                    mov     #$2,delay1  ; 4 cycles
            m1:     clr     delay0      ; 3 cycles
            m0:     dec     delay0      ; 4 cycles
                    bne     m0          ; 3 cycles
                    dec     delay1      ; 4 cycles
                    bne     m1          ; 3 cycles
        }
    }
}

void wait_100ms(void)
{
    asm {
            LDA #97    ; 2 clocks
            STA delay1 ; 4 clocks
    w_del1:
            CLRA                         ; 1 clocks * 97 iterations
            STA delay0 ; 4 clocks * 97 iterations
    w_del0:
            LDA delay0 ; 4 clocks * 256 * 97 iterations
            DECA                         ; 1 clocks * 256 * 97 iterations
            STA delay0 ; 4 clocks * 256 * 97 iterations
            BNE w_del0 ; 3 clocks * 256 * 97 iterations
            LDA delay1 ; 4 clocks * 97 iterations
            DECA                         ; 1 clocks * 97 iterations
            STA delay1 ; 4 clocks * 97 iterations
            BNE w_del1 ; 3 clocks * 97 iterations
    }
    /* Total time is
    2+4 + 97 * (1+4 + 256 * (4+1+4+3) + 4+1+4+3) = 299,639 cycles
    A 12MHz external clock gives an internal CPU clock of
    3MHz (333ns/cycle). Delay is then .0997 seconds.
    Close enough. */

}

void blink_LED(int x){

int ra=0,rc=0;
  
//BLINK LED ON AND OFF x TIMES

for(ra=0; ra<x; ra++) {
  
  PTA_PTA0=0; //turn off LED
  for(rc=0;rc<20000;rc++);
  PTA_PTA0=1; //turn on LED
  for(rc=0;rc<20000;rc++);
  PTA_PTA0=0; //turn off LED

}

  
}

/*
**********************************
*                                *
*     IIC                        *
*                                *
**********************************
*/

void IIC_trans_start(unsigned char devAddress,unsigned char regAddrLSB) {


while(MIMCR_MMBB==1);       //Wait until bus is free
//while(MMSR_MMTXBE==0);      //Wait for transmit buffer empty
                              
                              /** This should technically be there but
                              *** you are supposed to set a dummy data in a read
                              *** cycle which is never sent to the output bus so
                              *** MMTXBE is never set after a read cycle.
                              ***
                              *** Need to find a way to fix this and uncomment
                              *** above line.                              
                              **/


MMADR=devAddress;           //Set device addr
MMDTR=regAddrLSB;              //Send addr of target register
  
MIMCR_MMRW=0;               //Set MMIIC to write
MIMCR_MMAST=1;              //Put MMIIC in Master Mode

}

void IIC_trans_ack(unsigned char nextNextData) {

int i=0;
int lim=20000;
  
while(MMSR_MMTXBE==0);      //Wait until transmit buffer is empty

MMDTR=nextNextData; //Setup 2nd to next data to send
                     /** This data is not sent if stop 
                     *** signal is generated right after 
                     *** this function
                     */                  

while(MMSR_MMRXAK==1 && i < lim)     //Wait for dev to ACK
{
  
  i++;
 

}

if(MMSR_MMRXAK==1) {
 
   flag=1;
  
  } else {
    
      flag=0; 
  }

}


void IIC_rec_start(unsigned char devAddress){

unsigned char x;

while(MIMCR_MMBB==1);       //Wait until bus is free


x = MMDRR;                  //Clear MMRXBF

MMADR=devAddress;           //Set dev addr

MMCR_MMTXAK=0;              //uP will ACK recieved data
MIMCR_MMRW=1;               //Set MMIC to read
MMCR_REPSEN=1;              //Enable repeated start
MIMCR_MMAST=1;              //Put MMIIC in Master Mode

while(MMSR_MMTXBE==0);      //Wait for Transmit Buffer empty
MMDTR=0x00;                 //Set dummy data
while(MMSR_MMRXAK==1);      //Wait for dev ACK
 
}

void IIC_rec_wait(){

while(MMSR_MMRXBF==0);      //Wait until buffer is full
  
}

void IIC_rec_disableAck(){

/** Place this function only before the last data to be read **/

MMCR_MMTXAK=1;              //Disable ACK for last byte read              
  
}

void IIC_stop(){

MIMCR_MMAST=0;      //Disable master mode
MMCR_REPSEN=0;      //Disble repeated start

}

/*
**********************************
*                                *
*     DS1307                     *
*                                *
**********************************
*/

void DS1307_reg_init(){
  
CURR_SEC=0x00;
CURR_MIN=0x00;
CURR_HR=0x00;
CURR_DAY=0x00;
CURR_DATE=0x00;
CURR_MONTH=0x00;
CURR_YEAR=0x00;
DS1307_CTRL=0x10;       //Disable SQRW

DS1307CH=0;             //Enable clock oscillator

CURR_SEC_SECH=0x5;      //Set seconds MSB=0
CURR_SEC_SECL=0x0;      //Set seconds LSB=0

CURR_MIN_MINH=0x5;      //Set min MSB=5
CURR_MIN_MINL=0x9;      //Set min LSB=9

HRMODE=0x1;             //Set HR mode=1 for 12hr
CURR_HR_HR12H=0x1;      //Set HR MSB=1
CURR_HR_HRL=0x1;        //Set HR LSB=1

CURR_AMPM=0x1;          //Set AMPM=1 for PM

CURR_DAY=0x04;           //Set Day=1 for Monday

CURR_DATE_DATEH=0x2;    //Set Date MSB=2
CURR_DATE_DATEL=0x8;    //Set Date LSB=9

CURR_MONTH_MONTHH=0x0;  //Set MONTH MSB=0
CURR_MONTH_MONTHL=0x2;  //Set MONTH LSB=2

CURR_YEAR_YEARH=0x0;    //Set YEAR MSB=0
CURR_YEAR_YEARL=0x8;    //Set YEAR LSB=8

DS1307_CTRL_RS=0x01;    //Set sqrwave to 4.096kHz
DS1307_CTRL_OUT=0x0;    //Set sqrwave out put to low when inactive
DS1307_CTRL_SQWE=0x0;   //Disable SQRW
  
}

void set_dummy_alarm(){
  
//12:00 AM SAT

ALRM0_AMPM=0x0;         //AM

ALRM0_MIN_MINH=0x0;
ALRM0_MIN_MINL=0x0;

ALRM0_HR_HRH=0x1;
ALRM0_HR_HRL=0x2;

ALRM0_DAY_DAY=0x5;     //FRI
  
}

void DS1307_update_time(){
  
IIC_trans_start(DS1307_IIC_ADDR,DS1307_SEC_ADDR);     //Start IIC transfer, Set DS1307 transmitting addr, Sec register addr
IIC_trans_ack(CURR_SEC);                              //Accept ACK & Set SECS
IIC_trans_ack(CURR_MIN);                              //Accept ACK & Set MINS
IIC_trans_ack(CURR_HR);                               //Accept ACK & Set HR
IIC_trans_ack(CURR_DAY);                              //Accept ACK & Set DAY
IIC_trans_ack(CURR_DATE);                             //Accept ACK & Set DATE
IIC_trans_ack(CURR_MONTH);                            //Accept ACK & Set MONTH
IIC_trans_ack(CURR_YEAR);                             //Accept ACK & Set YEAR
IIC_trans_ack(DS1307_CTRL);                           //Accept ACK & Set CTRL
IIC_trans_ack(0x00);																	//Accept ACK & Set dummy data
IIC_stop();                                           //Send stop signal
  
}

void DS1307_save_alarm(){
  
IIC_trans_start(DS1307_IIC_ADDR,DS1307_RAM_ADDR);     //Start IIC transfer, Set DS1307 transmitting addr, RAM addr
IIC_trans_ack(ALRM0_DAY);                             //Accept ACK & Save DAY
IIC_trans_ack(ALRM0_HR);                              //Accept ACK & Save HR
IIC_trans_ack(ALRM0_MIN);                             //Accept ACK & Save MIN
IIC_trans_ack(0x00);																	//Accept ACK & Set dummy data
IIC_stop();                                           //Send stop signal
  
}

void DS1307_read_time(){
  

IIC_trans_start(DS1307_IIC_ADDR,DS1307_SEC_ADDR);     //Start IIC transfer, Set DS1307 transmitting addr, Sec register addr
IIC_trans_ack(0x00);
IIC_stop();                                           //Send stop signal

IIC_rec_start(DS1307_IIC_ADDR);                       //Start IIC recieve, Set DS1307 recieving addr
IIC_rec_wait();                                       //Wait for data to come
CURR_SEC=MMDRR;                                       //Store recieved data in current sec
IIC_rec_wait();                                       //Wait for data to come
CURR_MIN=MMDRR;                                       //store recieved data in current min
IIC_rec_wait();                                       //Wait for data to come
CURR_HR=MMDRR;                                        //store recieved data in current hr
IIC_rec_wait();                                       //Wait for data to come
CURR_DAY=MMDRR;                                       //store recieved data in current day
IIC_rec_wait();                                       //Wait for data to come
CURR_DATE=MMDRR;                                      //store recieved data in current date
IIC_rec_wait();                                       //Wait for data to come
CURR_MONTH=MMDRR;                                     //store recieved data in current month
IIC_rec_disableAck();                                 //Disable ACK
IIC_rec_wait();                                       //Wait for data to come
CURR_YEAR=MMDRR;                                      //store recieved data in current year
IIC_stop();                                           //Send stop signal
  
}

void display_curr_time(){
  
writeLCDcmd(0x46,1);            //set cursor address to top of text block (addr 0x0000)
writeLCDcmd(0x03,0);
writeLCDcmd(0x01,0);


writeLCDcmd(0x42,1);            //send mwrite cmd


writeNUM(CURR_HR_HR12H);
writeNUM(CURR_HR_HRL);
writeLCDcmd(0x3A,0);            // colon
writeNUM(CURR_MIN_MINH);
writeNUM(CURR_MIN_MINL);
writeLCDcmd(0x3A,0);						//colon
writeNUM(CURR_SEC_SECH);
writeNUM(CURR_SEC_SECL);

writeLCDcmd(0x20,0);						//space

if(CURR_AMPM==0){
  
  writeLCDcmd(0x41,0);
  writeLCDcmd(0x4D,0); 
  
} else if(CURR_AMPM==1){
  
  writeLCDcmd(0x50,0);
  writeLCDcmd(0x4D,0); 
  
}

writeLCDcmd(0x20,0);						//space

writeNUM(CURR_MONTH_MONTHH);
writeNUM(CURR_MONTH_MONTHL);
writeLCDcmd(0x2F,0);            //slash
writeNUM(CURR_DATE_DATEH);
writeNUM(CURR_DATE_DATEL);
writeLCDcmd(0x2F,0);            //slash
writeNUM(2);
writeNUM(0);
writeNUM(CURR_YEAR_YEARH);
writeNUM(CURR_YEAR_YEARL);

writeLCDcmd(0x20,0);						//space

if(CURR_DAY==1) {

writeLCDcmd(0x4D,0);					  //M
writeLCDcmd(0x4F,0);            //O
writeLCDcmd(0x4E,0);            //N
  
} else if(CURR_DAY==2) {

writeLCDcmd(0x54,0);					  //T
writeLCDcmd(0x55,0);            //U
writeLCDcmd(0x45,0);            //E
  
} else if(CURR_DAY==3) {

writeLCDcmd(0x57,0);					  //W
writeLCDcmd(0x45,0);            //E
writeLCDcmd(0x44,0);            //D
  
} else if(CURR_DAY==4) {

writeLCDcmd(0x54,0);					  //T
writeLCDcmd(0x48,0);            //H
writeLCDcmd(0x55,0);            //U
  
} else if(CURR_DAY==5) {

writeLCDcmd(0x46,0);					  //F
writeLCDcmd(0x52,0);            //R
writeLCDcmd(0x49,0);            //I
  
} else if(CURR_DAY==6) {

writeLCDcmd(0x53,0);					  //S
writeLCDcmd(0x41,0);            //A
writeLCDcmd(0x54,0);            //T
  
} else if(CURR_DAY==7) {

writeLCDcmd(0x53,0);					  //S
writeLCDcmd(0x55,0);            //U
writeLCDcmd(0x4E,0);            //N
  
} 
  
}


void alarm(){
  
  
if(CURR_DAY == ALRM0_DAY_DAY){
  
  if(CURR_AMPM == ALRM0_AMPM){
    
    if(CURR_HR_HRL == ALRM0_HR_HRL){
    
      if(CURR_HR_HR12H == ALRM0_HR_HRH){
    
        if(CURR_MIN_MINL == ALRM0_MIN_MINL){
      
          if(CURR_MIN_MINH == ALRM0_MIN_MINH){
        
            //if it reaches here then need to ring alarm
          
             if(CURR_SEC_SECL % 2 == 0) {
              
              DS1307_CTRL_SQWE=0x1;   //enable sqrwave
              PTA_PTA0=1;
             }
             else{
              
              DS1307_CTRL_SQWE=0x0;   //disable sqrwave           
              PTA_PTA0=0;
             }
          
            IIC_trans_start(DS1307_IIC_ADDR,DS1307_CTRL_ADDR);    //Start IIC transfer, Set DS1307 transmitting addr, Sec register addr
            IIC_trans_ack(DS1307_CTRL);                           //Accept ACK & Set CTRL
            IIC_trans_ack(0x00);																	//Accept ACK & Set dummy data
            IIC_stop();                                           //Send stop signal
                      
             
          }
        }
      }
    }
  }  
} //else
}