proj2

#include <ioavr.h>
#include <inavr.h>
#include <stdio.h>
#include <pgmspace.h>
#include "rtc_simple.h"
#include "hd44780.h"
#include "queue.h"
#include "keyb_drv.h"
#define CLOCK_INC   0x03


//LED
#include <iom128.h>

//Program configuration
//#define ISR_PROCESSING
#define PTR_ACCESS

#define LED_SEG PORTC
#define LED_SEG_DIR DDRC
#define LED_DG PORTB
#define LED_DG_DIR DDRB

#define DV_480Hz 15
#define DV_DEMO  40
#define DV_NEXT  13

#define DEC_OFF 0x3F
#define DISP_MAX 6
#define LED_BLANK 15

//LED
typedef union TRQ {
    //Access to entire byte
    unsigned char c;
    struct {
        unsigned char f_tck : 1;
        //other flags can be defined
        unsigned char not_used : 7;
    };
} TRQ;


//LCD
typedef union TSysRq {
    unsigned char msg;
    struct {
        unsigned char rq_data   : 4;
        unsigned char rq_id     : 4;
    };
} TSysRq;



static const char __flash LCDUserChar[] = {
    0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F,
    0x1F, 0x00, 0x10, 0x10, 0x10, 0x10, 0x00, 0x1F,
    0x1F, 0x00, 0x18, 0x18, 0x18, 0x18, 0x00, 0x1F,
    0x1F, 0x00, 0x1C, 0x1C, 0x1C, 0x1C, 0x00, 0x1F,
    0x1F, 0x00, 0x1E, 0x1E, 0x1E, 0x1E, 0x00, 0x1F,
    0x1F, 0x00, 0x1F, 0x1F, 0x1F, 0x1F, 0x00, 0x1F,
    0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03,
    0x18, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x18 };

__flash unsigned char BCD_2_LED[] = {
    0xDE, 0x82, 0xEC, 0xE6,
    0xB2, 0x76, 0x7E, 0xC2,
    0xFE, 0xF6, 0x1C, 0xBA,
    0xF8, 0xFA, 0x20, 0x00 };


__flash unsigned char DEC_1_OF_6[] =
    {0xFE, 0xFD, 0xFB, 0xF7, 0xEF, 0xDF};


static const char __flash sSun[] = " ";
static char const __flash sMon[] = " ";
static char const __flash sTue[] = " ";
static char const __flash sWed[] = " ";
static char const __flash sThu[] = " ";
static char const __flash sFri[] = " ";
static char const __flash sSat[] = " ";
static const char __flash sCl[] = "%2d:%02d:%02d %s";

__flash const char __flash* sWDay[] = {
    sSun, sMon, sTue, sWed, sThu, sFri, sSat
 };

//LCD
TClock rtc;
TClock myTime;
TQueue event_queue;
unsigned char ev_q_buf[16];

char tmp_buf[4];
TSysRq rq2;
char timer[3]={0, 1, 30};

 const char endingMes[] =
    "END END END END";

 //LED

 unsigned char disp[6] = {0,0,0,0,0,0};
 unsigned char cur_disp;
unsigned char dv_demo = DV_DEMO;
unsigned char dv_next = DV_NEXT;
__no_init unsigned char idx;
#define UPDATE_DISP_RQ 0x01
  volatile TRQ rq;


 //LCD

//This function is used by printf function to transfer data to STDIO device
int putchar(int ch){
    LCDPutChar(ch);
    return ch;
}

void onClockInc(){

static unsigned char i;
  ++i;
  disp[0]=  BCD_2_LED[i%10];
 // disp[1] = BCD_2_LED[rtc.min];
 // disp[2] = BCD_2_LED[rtc.hr];

    LCDGoTo(LINE_0 + 1);
    printf_P(
        sCl,
        rtc.hr,
        rtc.min,
        rtc.sec,
        memcpy_P(tmp_buf, sWDay[rtc.wday], sizeof(sSun)));


}

void onClockInc2(){


  LCDGoTo(LINE_0 + 21);
    printf_P(
        sCl,
        myTime.hr,
        myTime.min,
        myTime.sec,
        memcpy_P(tmp_buf, sWDay[rtc.wday], sizeof(sSun)));
}







  void InitDevices()
{
    LED_DG = 0xFE;
    LED_DG_DIR = 0xFF;
    LED_SEG_DIR = 0xFF;
    //Prescaler fclk / 1024 = 7200Hz
    //Prescaler for T0 is different than for T1,T2,T3
    OCR0 = DV_480Hz - 1;
    TCCR0 = (1 << WGM01) | (1 << CS02) | (1 << CS01) | (1 << CS00);
    TIMSK = (1 << OCIE0);
    __enable_interrupt();
}

  void DispDemo2(){
static unsigned char i;
  ++i;
  disp[0]=  BCD_2_LED[i%10];
  disp[1] = BCD_2_LED[i%100 - (i%10) ];
  disp[2] = BCD_2_LED[i%1000 ];

   /*
              disp[0]=  BCD_2_LED[0];
              disp[1] = BCD_2_LED[1];
              disp[2] = BCD_2_LED[2];
    disp[0]=  BCD_2_LED[rtc.sec];
  disp[1] = BCD_2_LED[rtc.min];
  disp[2] = BCD_2_LED[rtc.hr];
    */
      }



static void InitDevicesLCD()
{
  //LCD
    LCDInit();
    LCDLoadUserCharP(LCDUserChar, 0, sizeof(LCDUserChar));
    LCDClear();

    //LCD TIMER
    //T0 start
    ////TCNT0 = 0;
    ////OCR0 = 71;

    rtcInit(&myTime, timer[0], timer[1], timer[2]);

    TCCR0 = (1 << WGM01) | (1 << CS02) | (1 << CS01) | (1 << CS00);
    //dvt = 50;
    //Timers interrupt mask
    TIMSK = (1 << OCIE0);
    __enable_interrupt();

}


//LCD

#pragma vector = TIMER0_COMP_vect
__interrupt void ISR_OCR0()
{
static unsigned char pre_dv = 100;
    kbService(&event_queue);
    if(--pre_dv) return;
    pre_dv = 100;
        if(!rtcZero(myTime)){
    rtcInc(&rtc);
        rtcDec(&myTime);
        }
        if(rtcZero(myTime)){
         //finish();
         }

    LED_DG |= DEC_OFF;
    LED_SEG = disp[cur_disp];
    LED_DG = DEC_1_OF_6[cur_disp];


    qAdd(&event_queue, MSG(CLOCK_INC, 0));
}


//LED
//#pragma vector = TIMER0_COMP_vect
__interrupt void T0_COMP_ISR()
{
 static unsigned char cur_disp=0;
    LED_DG |= DEC_OFF;
    LED_SEG = disp[cur_disp];
    LED_DG = DEC_1_OF_6[cur_disp];
    if((++cur_disp) == DISP_MAX) cur_disp = 0;
    if(--dv_demo) return;
    dv_demo = DV_DEMO;
    #ifdef ISR_PROCESSING
    DispDemo();
    #else
    rq.f_tck = 1;
    #endif

        /*
        static unsigned char pre_dv = 100;
    kbService(&event_queue);
    if(--pre_dv) return;
    pre_dv = 100;
        if(!rtcZero(myTime)){
    rtcInc(&rtc);
        rtcDec(&myTime);
        }


    qAdd(&event_queue, MSG(CLOCK_INC, 0));
        */
}

/*
//LCD & LED
#pragma vector = TIMER0_COMP_vect
__interrupt void ISR_OCR0()
{
static unsigned char pre_dv = 100;
    kbService(&event_queue);
    if(--pre_dv) return;
    pre_dv = 100;
        if(!rtcZero(myTime)){
    rtcInc(&rtc);
        rtcDec(&myTime);
        }
      //  if(rtcZero(myTime))
      //   finish();


    qAdd(&event_queue, MSG(CLOCK_INC, 0));

        //
    static unsigned char cur_disp=0;
    LED_DG |= DEC_OFF;
    LED_SEG = disp[cur_disp];
    LED_DG = DEC_1_OF_6[cur_disp];
    if((++cur_disp) == DISP_MAX) cur_disp = 0;
    if(--dv_demo) return;
    dv_demo = DV_DEMO;


    #ifdef ISR_PROCESSING
    DispDemo2();
    #else
    rq.f_tck = 1;
    #endif


}

*/
/*
void main()
{
    idx = 0;
    cur_disp = 0;
    //dv_next = DV_NEXT;
    //dv_demo = DV_DEMO;
    InitDevices();
    while(1)
    {
        #ifndef ISR_PROCESSING
        if(rq.f_tck)
        {
            rq.f_tck = 0;
            DispDemo2();
                 }
        #endif
    }
}

*/


void main()
{
        idx = 0;
        cur_disp = 0;

    InitDevices();
    qInit(&event_queue, ev_q_buf, sizeof(ev_q_buf));
    qAdd(&event_queue, MSG(CLOCK_INC, 0));
    for(;;)
    {
        while(!qGet(&event_queue, &rq2.msg));
        switch(rq2.rq_id) {
        case CLOCK_INC:
            onClockInc();
                        onClockInc2();
            break;
        }
    }
}