#include <18f252.h>
//#DEVICE ICD=TRUE
#DEVICE *=8
//#DEVICE HIGH_INTS=TRUE
#FUSES RC, NOWDT, NOPROTECT, NOBROWNOUT, PUT, NOLVP, NOWRT
#CASE
#define OSC_CLOCK 2450000
#USE Delay(Clock=OSC_CLOCK)

#USE FAST_IO(A)
#USE FAST_IO(B)
#USE FAST_IO(C)

#rom 0x2100={'W','r','i','t','t','e','n',' ','b','y',' ','S','v','e','t','o','s','l','a','v',' ','P','i','r','e','v'}

// Брой дни във всеки месец
const char Months[12] = {31,28,31,30,31,30,30,31,30,31,30,31};

// Имена на месеците - bcd code
enum MonthsName   { Jan = 1, Feb, Mar, Apr, May, Jun,
               Jul, Aug, Sep, Oct=0x10, Nov, Dec  };

// Подредба на дисплейните символи в CharTable
enum Characters {
   char0 = 0, char1, char2, char3,
   char4, char5, char6, char7,
   char8, char9, charA, charB,
   charC, charD, charE, charF,
   charT, charH, charP, charL,
   UpLine, Minus, BotLine, Space,
   charU, charN, charO, charR,
   HiDegree, LowPulse, HiPulse, LoDegree = charO,
   charY = 31
};

typedef struct {
   char   fflashDigits;      // bit0 - Flashing Digit 0 are enabled
                        // bit1 - Flashing Digit 1 are enabled
                        // bit2 - Flashing Digit 2 are enabled
                        // bit3 - Flashing Digit 3 are enabled
                        // bit4 -
                        // bit5 -
                        // bit6 -
                        // bit7 -
   char   cflashDigits;
   char   lcd[4];            // 4 байта видеопамет, lcd[3]=MSB, lcd[0]=LSB
   int      semicolon:1;      // флаг показване/скриване на двуеточието
   int      dp2:1;            // флаг показване/скриване на десетична точка 2
   int      dp3:1;            // флаг показване/скриване на десетична точка 3
   int      dp4:1;            // флаг показване/скриване на десетична точка 4
   int      fflashDegree:1;      // флаг за мигане на показвания аналогов канал
} Display;

//
// used from RTC clock: year,month,day,hour,minute,second .
//
typedef struct {
   char   year,         // година
         month,         // месец
         day,         // ден
         hour,         // час
         minute,         // минута
         second;         // секунда
   int      fPwrDown:1;      // Индикатор за отпаднало захранване
   int      fSecond:1;      // Индикатор за смяна на секундата
   int      fMinute:1;      // Индикатор за смяна на минутата
   int      fHour:1;      // Индикатор за смяна на часа
} RTC;



RTC      rtc;
Display   display;
int8   flags,
      adcflags,
      kflags,
      Mode,
      Menu;

#bit time7ms8125=flags.1   // 7.8125 ms

#bit an_chn0=adcflags.0
#bit an_chn1=adcflags.1
#bit an0_complete=adcflags.2
#bit an1_complete=adcflags.3
#bit an_hex_mode=adcflags.4

#bit _BackPlane=PORTB.4

void UpdateDisplay(void)   {

   if( ! _BackPlane ) {
      /*
         ........
      */
     } else {
      /*
         ........
      */
   }
   _BackPlane = ! _BackPlane;
}


//   Interrupt every 7.8125ms ( for 64Hz LCD refresh rate )
void InitRTC(void)   {
   TRISC |= 0b00000011;   // Make RC1/T1OSI & RC0/T1OSO to be inputs
   TMR1H = 0xFF;
   TMR1L = 0x00;
   T1CON = 0b00001110;   // 1:1 prescaler, do not synchronize, external clock from crystal
                  // two 8-bit registers
   TMR1IP = 1;         // High interrupt priority
   TMR1IF = 0;         // Clear interrupt flag
   TMR1IE = 1;         // Enable interrupt from TMR1 module
   TMR1ON = 1;         // Start TMR1 to work
}

#define IncBCD(reg)         \
#asm                   \
   movf   reg,W         \
   addlw   1            \
   daw                  \
   movwf   reg            \
#endasm

#define BCD_RTC

#INT_TIMER1
void Tmr1Handler(void)   {
static int8 counter = 128, r;

   TMR1H = 0xFF;      // interrupt every 7.8125s ( for 64Hz LCD refresh rate )
   TMR1IF = 0;

   UpdateDisplay();

   time7ms8125 = 1;

   if( --counter )
      return;
   counter = 128;

    rtc.fSecond = 1;

#ifdef BIN_RTC   // Binary version of RTC
   rtc.fSecond = 1;
   if( ++rtc.second > 59 )   {
      rtc.second = 0;
      if( ++rtc.minute > 59 )   {
         rtc.minute = 0;
         if( ++rtc.hour > 23 )   {
            rtc.hour = 0;
            r = Months[ rtc.month ];
            if( rtc.month == Feb )   {
               if( rtc.year % 4 == 0 )
                  r++;
            }
            if( ++rtc.day > r )   {
               rtc.day = 1;
               if( ++rtc.month > Dec )   {
                  rtc.month = Jan;    // Happy new year :)
                  if( ++rtc.year > 0x99 )
                     rtc.year = 0x00;
               }
            }
         }
      }
   }
#else
#ifdef BCD_RTC   // BCD version of RTC
   IncBCD( rtc.second );
   rtc.fSecond = 1;
   if( rtc.second > 0x59 )   {
      rtc.second = 0;
      IncBCD( rtc.minute );
      if( rtc.minute > 0x59 )   {
         rtc.minute = 0;
         IncBCD( rtc.hour );
         if( rtc.hour > 0x23 )   {
            rtc.hour = 0;
            r = Months[ rtc.month ];
            if( rtc.month == Feb )   {
               if( rtc.year % 4 == 0 )
                  r++;
            }
            IncBCD( rtc.day );
            if( rtc.day > r )   {
               rtc.day = 1;
               IncBCD( rtc.month );
               if( rtc.month > Dec )   {
                  rtc.month = Jan;
                  IncBCD( rtc.year ); // Happy new year :)
                  if( rtc.year > 0x99 )
                     rtc.year = 0;
               }
            }
         }
      }
   }
#endif
#endif
}

void ScanKey(void) {
/*
   .....

   .....
*/
}

void InitHardware(void) {
   INTCON = 0;
   PORTA = 0; PORTB = 0; PORTC = 0;
   TRISA = 0b00011111; TRISB = 0b11100000; TRISC = 0b11011011;

   memset( &display, 0, sizeof(display) );

   if( ! POR &&  NOT_PD ) {
      POR = 1;
      rtc.hour = 0x12; rtc.minute = 0x00; rtc.second = 0x57;
      rtc.day = 0x16; rtc.month = 0x09; rtc.year = 0x05;
      display.lcd[0] = display.lcd[1] = display.lcd[2] = display.lcd[3] = Space;
   }
   INTCON2 = 0;   // Enable PORTB pull-up resistors
   T0CON = 0;      // Stop TMR0
   _BackPlane = 0;
   InitRTC();
   flags = 0; kflags = 0;
   rtc.fPwrDown = 0; rtc.fSecond = 0; Menu = 0; Mode = 0;
/*
   IPEN = 1;   // Set interrupt priority scheme
   GIEH = 1;   // Enable all unmasked interrupts with high priority
   GIEL = 1;   // Enable all unmasked interrupts with low priority
*/
   INTCON |= 0b11000000;            // Enable all unmasked interrupts
}



main()   {

   InitHardware();

   while ( 1 )      {

      sleep();

      if( time7ms8125 ) {   // 7.8125 ms

         time7ms8125 = 0;

         ScanKey();

         switch( Mode )   {
            case 0: // Mode = Normal mode
               if( rtc.fSecond )   {
                  rtc.fSecond = 0;
                  /*
                  .......
                  */
               }
               break;

            case 1: // Mode = Set Clock
               switch( Menu )   {
                  case 0:
                     /*
                     .....
                     */
                     break;
                  case 1:
                     /*
                     .....
                     */
                     break;
                  case 2:
                     /*
                     .....
                     */
                     break;
                  case 3:
                     /*
                     .....
                     */
                     break;
               }
               break;

            case 2: // Mode = Show temperature from AN0
               if( an0_complete )   {
                  an0_complete = 0;
                  /*
                  .....
                  */
               }
               break;

            case 3:   // Mode = Show temperature from AN1
               if( an1_complete )    {
                  an1_complete = 0;
                  /*
                  .....
                  */
               }
               break;

            case 4:   // Show AN0 - AN1
               if( an0_complete && an1_complete )
                  an0_complete = 0; an1_complete = 0;
                  /*
                  .....
                  */
               break;
         }
      }
   }
}