//******************************************************************************************
//   Project      :
//   Program Name :
//   Programer    :
//   Create date  :  Version 1.0    H23.05.20
//   Replace date :
//   History      :
//   Laungage     :  MPLAB C18 
//******************************************************************************************
//   Description
//     1)OSC  40MHz (10MHz Crystal * PLL4)
//
//******************************************************************************************
#include	<p18f452.h>
#include	<stdio.h>
#include	<string.h>
#include	<stdlib.h>
#include	<math.h>
#include	<ctype.h>
#include	<io.h>
#include	<adc.h>
//
//Define configration
//

#pragma config OSC=HSPLL     //Oscillator Selection : HS-PLL Enabled
#pragma config OSCS=OFF      //Osc. Switch Enable:
#pragma config PWRT=OFF      //Power-up Timer:
#pragma config BOR=OFF       //Brown-out Reset:
#pragma config BORV=25       //Brown-out Voltage:     2.5V
#pragma config WDT=OFF       //Watchdog Timer:
#pragma config WDTPS=1       //Watchdog Postscaler:   1:1
#pragma config CCP2MUX=OFF   //CCP2 MUX:              Disable(RB3)
//#pragma config CCP2MUX = ON  //CCP2 MUX:            Enable(RC1)
#pragma config STVR=OFF      //Stack Overflow Reset:
#pragma config LVP=OFF       //Low Voltage ICSP:
#pragma config DEBUG=OFF     //Background Debugger Enable:
#pragma config CP0=OFF       //Code Protection Block 0:
#pragma config CP1=OFF       //Code Protection Block 1:
#pragma config CP2=OFF       //Code Protection Block 2:
#pragma config CP3=OFF       //Code Protection Block 3:
#pragma config CPB=OFF       //Boot Block Code Protection:
#pragma config CPD=OFF       //Data EEPROM Code Protection:
#pragma config WRT0=OFF      //Write Protection Block 0:
#pragma config WRT1=OFF      //Write Protection Block 1:
#pragma config WRT2=OFF      //Write Protection Block 2:
#pragma config WRT3=OFF      //Write Protection Block 3:
#pragma config WRTB=OFF      //Boot Block Write Protection:
#pragma config WRTC=OFF      //Configuration Register Write Protection: 
#pragma config WRTD=OFF      //Data EEPROM Write Protection:
#pragma config EBTR0=OFF     //Table Read Protection Block 0: 
#pragma config EBTR1=OFF     //Table Read Protection Block 1:
#pragma config EBTR2=OFF     //Table Read Protection Block 2:  
#pragma config EBTR3=OFF     //Table Read Protection Block 3:
#pragma config EBTRB=OFF     //Boot Block Table Read Protection: 

//
//Define function
//
#define   PI_NORMAL  0
#define   PI_FAILURE 1

//
//
//Define function
//
void BCF(unsigned int);
void BSF(unsigned int);

void Timer(void);
void Wait_1mS(unsigned int);
void Select_clm(unsigned int);
unsigned char Set_FNT(unsigned int);
unsigned char Set_FNT_no(unsigned char);
void Wait_dsp(unsigned char *,unsigned int);
void Wait_dsp_num(unsigned char *,unsigned int);
void Demo01(void);
void Demo02(void);
void LED_OFF(void);
volatile unsigned int       G_counter=0; 

#define PI_7SEG_MAX 14

void main(void)
{
    unsigned char tmp_char;
    unsigned char flg = 0;
    unsigned char lp;

// *************************************
//   1.Initialize Segment
// *************************************

// (1)TRIS
    TRISA=0b11110000;
    TRISB=0b10000000;
    TRISC=0b11000000;    
    TRISD=0b10000000;
    TRISE=0b00000011;      //Caution !!! (Bit[7-4]) 

// (2)LAT
    LATA=0b00000000;
    LATB=0b00000000;
    LATC=0b00000000;
    LATD=0b00000000;
    LATE=0b00000000;

// (3)PORT
    PORTA=0b00001111;
    PORTB=0b01111111;
    PORTC=0b00000000;
    PORTD=0b01111111;
    PORTE=0b00000000;


// (4)Select A/D Converter
    ADCON1=0b00000111;    //ALL Degital Port

// *************************************
//   2.Program Main
// *************************************
// (1)Demo Program
    while(1){
        Demo01();
        Demo02();
    }
}

//******************************************************************************************
//   Function Name : Demo01
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
void Demo01(void)
{
    unsigned char c_dat[PI_7SEG_MAX];
    unsigned int lp;

    for(lp=0;lp<PI_7SEG_MAX;lp++){
            c_dat[lp]=lp;
    }
    Wait_dsp_num(c_dat,50);
}

//******************************************************************************************
//   Function Name : Demo02
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
void Demo02(void)
{
    unsigned char c_dat[] = "FEDCBA9876543210";
    unsigned int lp;

    Wait_dsp(c_dat,50);
}


//******************************************************************************************
//   Function Name : Demo03
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
void Demo03(void)
{
    unsigned char c_dat[] = "0123456789ABCDEF";
    unsigned int lp;

    Wait_dsp(c_dat,20);
}

//******************************************************************************************
//   Function Name : Wait_dsp
//   Title         : 
//   Input         : 
//   Output        : 
//   Description   : Wait : 0.1[S] * no
//******************************************************************************************
void Wait_dsp(unsigned char c_dat[],unsigned int no)
{
    unsigned int lp,lp_1;

    for(lp_1=0;lp_1<50;lp_1++){
        for(lp=0;lp<6;lp++){
            Select_clm(lp+1);
            PORTB = Set_FNT(c_dat[lp]);
            PORTD = Set_FNT(c_dat[lp+6]);
            Wait_1mS(1);
            LED_OFF();
        }
//
        Select_clm(7);
        PORTB = Set_FNT(c_dat[13]);
        PORTD = Set_FNT(c_dat[12]);
        Wait_1mS(1);
        LED_OFF();
    }
}

//******************************************************************************************
//   Function Name : Wait_dsp_num
//   Title         : 
//   Input         : 
//   Output        : 
//   Description   : Wait : 0.1[S] * no
//******************************************************************************************
void Wait_dsp_num(unsigned char c_dat[],unsigned int no)
{
    unsigned int lp,lp_1;

    for(lp_1=0;lp_1<50;lp_1++){
        for(lp=0;lp<6;lp++){
            Select_clm(lp+1);
            PORTB = Set_FNT(Set_FNT_no(c_dat[lp]));
            PORTD = Set_FNT(Set_FNT_no(c_dat[lp+6]));
            Wait_1mS(1);
            LED_OFF();
        }
//
        Select_clm(7);
        PORTB = Set_FNT(Set_FNT_no(c_dat[13]));
        PORTD = Set_FNT(Set_FNT_no(c_dat[12]));
        Wait_1mS(1);
        LED_OFF();
    }
}

//******************************************************************************************
//   Function Name : Set_FNT_no
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
unsigned char Set_FNT_no(unsigned char in_no)
{
    unsigned char out_c;

    if(in_no < 10){
        out_c = in_no + 0x30;
    }else{
        switch( in_no ){
            case 10 : 
                 out_c = 'A';
                 break;
            case 11 : 
                 out_c = 'B';
                 break;
            case 12 : 
                 out_c = 'C';
                 break;
            case 13 : 
                 out_c = 'D';
                 break;
            case 14 : 
                 out_c = 'E';
                 break;
            case 15 : 
                 out_c = 'F';
                 break;
            defalt :
                 out_c = 'n';
                 break;
        }
    }
    return(out_c);
}

//******************************************************************************************
//   Function Name : Set_FNT
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
unsigned char Set_FNT(unsigned int in_char)
{
    unsigned char fnt;

    switch( in_char ){
        case '0' : 
                 fnt = 0b01000000;
                 break;
        case '1' : 
                 fnt = 0b01111001;
                 break;
        case '2' : 
                 fnt = 0b00100100;
                 break;
        case '3' : 
                 fnt = 0b00110000;
                 break;
        case '4' : 
                 fnt = 0b00011001;
                 break;
        case '5' : 
                 fnt = 0b00010010;
                 break;
        case '6' : 
                 fnt = 0b00000010;
                 break;
        case '7' : 
                 fnt = 0b01111000;
                 break;
        case '8' : 
                 fnt = 0b00000000;
                 break;
        case '9' : 
                 fnt = 0b00010000;
                 break;
        case 'A' : 
                 fnt = 0b00001000;
                 break;
        case 'B' : 
                 fnt = 0b00000011;
                 break;
        case 'C' : 
                 fnt = 0b00100111;
                 break;
        case 'D' : 
                 fnt = 0b00100001;
                 break;
        case 'E' : 
                 fnt = 0b00000110;
                 break;
        case 'F' :
                 fnt = 0b00001110;
                 break;
        case '-' :
                 fnt = 0b00111111;
                 break;
        case '_' :
                 fnt = 0b01110111;
                 break;
        case 'n' :
                 fnt = 0b01111111;
                 break;
        case 'R' :
                 fnt = 0b00101111;
                 break;
        defalt : 
                 fnt = 0b01111111;
                 break;
    }
    return(fnt);
}

//******************************************************************************************
//   Function Name : LED_OFF
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
void LED_OFF(void)
{
    PORTB = 0b011111111;
    PORTD = 0b011111111;
}

//******************************************************************************************
//   Function Name : Select_clm
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
void Select_clm(unsigned int no)
{
    PORTC = PORTC & 0b11000000;
    PORTE = PORTE & 0b11111011;
    switch( no ){
        case 1 : 
                 PORTC = PORTC | 0b00000001;
                 break;
        case 2 : 
                 PORTC = PORTC | 0b00000010;
                 break;
        case 3 : 
                 PORTC = PORTC | 0b00000100;
                 break;
        case 4 : 
                 PORTC = PORTC | 0b00001000;
                 break;
        case 5 : 
                 PORTC = PORTC | 0b00010000;
                 break;
        case 6 : 
                 PORTC = PORTC | 0b00100000;
                 break;
        case 7 : 
                 PORTE = PORTE | 0b00000100;
                 break;
        defalt : 
                 break;
    }
}

//******************************************************************************************
//   Function Name : Wait_1mS
//   Title         : wait function
//   Input         : 
//   Output        : 
//******************************************************************************************
void Wait_1mS(unsigned int no)
{
    unsigned int lp;
    for(lp=0;lp<no;lp++){
        Timer();
    }
}


//******************************************************************************************
//  Function Name : Timer
//  Title         : wait function (1mS)
//  Input         :
//  Output        :
//******************************************************************************************
void Timer(void)
{
// *******************************************************
// 1.Define T1CON(TIMER1 CONTROL REGISTER) Register
//*   T1CON(7)  RD16: 16-bit Read/Write Mode Enable bit
//                      1 = Enables register read/write of TImer1 in one 16-bit operation
//                      0 = Enables register read/write of Timer1 in two 8-bit operations
//*   T1CON(6)  Unimplemented: Read as '0'
//*   T1CON(5-4)T1CKPS<1:0>: Timer1 Input Clock Prescale Select bits
//                      11 = 1:8 Prescale value
//                      10 = 1:4 Prescale value
//                      01 = 1:2 Prescale value
//                      00 = 1:1 Prescale value
//*   T1CON(3)  T1OSCEN: Timer1 Oscillator Enable bit
//                      1 = Timer1 oscillator is enabled
//                      0 = Timer1 oscillator is shut off
//                        The oscillator inverter and feedback resistor are turned off to eliminate power drain.
//*   T1CON(2)  T1SYNC: Timer1 External Clock Input Synchronization Select bit
//                      When TMR1CS = 1:
//                         1 = Do not synchronize external clock input
//                         0 = Synchronize external clock input
//                      When TMR1CS = 0:
//                         This bit is ignored. Timer1 uses the internal clock when TMR1CS = 0.
//*   T1CON(1)  TMR1CS: Timer1 Clock Source Select bit
//                      1 = External clock from the T13CKI pin (on the rising edge)
//                      0 = Internal clock (FOSC/4)
//*   T1CON(0)  bit 0 TMR1ON: Timer1 On bit
//                      1 = Enables Timer1
//                      0 = Stops Timer1
// *******************************************************

    T1CON = 0b10000001;  //   16-bit Read/Write Mode, 1:8 Prescale value

// *******************************************************
// 2.Define TMR1 Register
//    Caution(16-bit Read/Write Mode) !!!!:
//    (a)Writing to TMR1H does not directly affect Timer1.
//       Instead, the high byte of Timer1 is updated with the contents of TMR1H when a write occurs to TMR1L.
//       This allows all 16 bits of Timer1 to be updated at once.
//    (b)A read from TMR1L will load the contents of the high byte of Timer1 into the Timer1 high byte buffer. 
//       This provides the user with the ability to accurately read all 16 bits of Timer1 without the need to 
//       determine whether a read of the high byte, followed by a read of the low byte, has become invalid due 
//       to a rollover or carry between reads.
// *******************************************************
//   TMR1 data ( OSC:10MHz, 4X PLLON, 1:1 Prescale value, 0.001[S];1000Hz )
//     1mS(1000Hz): 10MHz * 4(PLLON) / 4(PIC) / 1(Prescale) / 1000(1000Hz)==> 0d10,000(Count) ==> 0x2710(Count)
//     TMR1 = 0xFFFF - 0x2710 ==> 0xD8EF
//     
    TMR1H = 0xD8;
    TMR1L = 0xEF;

// *******************************************************
// 3.Timer
// *******************************************************
    PIR1bits.TMR1IF = 0;
    while(1){
        if(PIR1bits.TMR1IF != 0 )break;
    }
}