//******************************************************************************************
//   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   PI_7SEG_MAX  14
#define   PI_NODATA    99
//
//
//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 Wait_dsp_intr(void);
void Init_USART(void);
void SendUART_s(char *);
void Trans_USART(unsigned char );
void Rec_USART(unsigned char * );
void isr (void);
void Int_buf(void);
void LED_OFF(void);
void Demo01(void);
void Demo02(void);


volatile unsigned char G_c_dat[PI_7SEG_MAX]; 
volatile unsigned char G_tmp_c_dat[PI_7SEG_MAX]; 
volatile unsigned char G_index = PI_NODATA; 

void main(void)
{
    unsigned char tmp_char;
    unsigned char flg = 0;
    unsigned char lp;
    unsigned char strmsg[]="   CIP254F81--";
    unsigned char uarmsg[]="  Start PIC18F452 OK> ";

// *************************************
//   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

// (5)Initialize USART
    Init_USART();

// *************************************
//   2.Program Main
// *************************************
// (1)Start Message ( UART ) 
    SendUART_s(uarmsg);

// (2)Start Message ( 7-Segment LED) 
    Wait_dsp(strmsg,200);

// (3)Demo Program
    Int_buf();
    while(1){
        Wait_dsp_intr();
    }
}

//******************************************************************************************
//   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 : Int_buf
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
void Int_buf(void)
{
    unsigned int lp;
    for(lp=0;lp<PI_7SEG_MAX;lp++){
        G_c_dat[lp]='-';
    }
}

//******************************************************************************************
//   Function Name : Wait_dsp_intr
//   Title         : 
//   Input         : 
//   Output        : 
//   Description   : 
//******************************************************************************************
void Wait_dsp_intr(void)
{
    unsigned int lp;

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

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

    for(lp_1=0;lp_1<no;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   : 
//******************************************************************************************
void Wait_dsp_num(unsigned char c_dat[],unsigned int no)
{
    unsigned int lp,lp_1;

    for(lp_1=0;lp_1<no;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 'I' :
                 fnt = 0b01111011;
                 break;
        case 'P' :
                 fnt = 0b00001100;
                 break;
        case 'R' :
                 fnt = 0b00101111;
                 break;
        case '-' :
                 fnt = 0b00111111;
                 break;
        case '_' :
                 fnt = 0b01110111;
                 break;
        case ' ' :
                 fnt = 0b01111111;
                 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;
    }
}

//****************************************************************************
//   Function Name : Init_USART
//   Title         : 
//   Input         : 
//   Output        : 
//   Description   : 
//****************************************************************************
void Init_USART(void)
{
// *******************************************************
// 1.Define Interrupts
//      Timer1 interrupt, if enabled, is generated on overflow, which is latched in the TMR1IF 
//      interrupt flag bit of the PIR1 register. This interrupt can be enabled or disabled
//      by setting or clearing the TMR1IE Interrupt Enable bit of the PIE1 register.
// *******************************************************
//  (1)Define INTCON(INTERRUPT CONTROL)Register
//       INTCON(7) GIE/GIEH(Global Interrupt Enable bit)
//       INTCON(6) PEIE/GIEL(Peripheral Interrupt Enable bit)
//          1 = Enables, 0 = Disables
    INTCON = INTCON | 0b11000000;

//  (2)Define PIR1(PERIPHERAL INTERRUPT REQUEST)Register
//       PIR1(5) RCIF: USART Receive Interrupt Flag bit
//          1 = Enables, 0 = Disables
    PIR1 = PIR1 | 0b00100000;

//  (3)Define PIE1: PERIPHERAL INTERRUPT ENABLE REGISTER 1
//       PIE1(5) RCIE: USART Receive Interrupt Enable bit
//          1 = Enables, 0 = Disables
    PIE1 = PIE1 | 0b00100000;

//  (4)Define IPR1(PERIPHERAL INTERRUPT PRIORITY REGISTER 1)
//       IPR1(5) RCIP: USART Receive Interrupt Priority bit
//           1 = High priority, 0 = Low priority
//  IPR1 = IPR1 | 0b00100000;
    IPR1 = IPR1 | 0b00000000;

// *******************************************************
// 1.Define TXSTA(TRANSMIT STATUS AND CONTROL) Register   
//   TXSTA(7) CSRC: Clock Source Select bit
//        Asynchronous mode:Donft care
//   TXSTA(6) TX9: 9-bit Transmit Enable bit
//         1 = Selects 9-bit transmission
//         0 = Selects 8-bit transmission
//   TXSTA(5) TXEN: Transmit Enable bit(1)
//         1 = Transmit enabled
//         0 = Transmit disabled
//   TXSTA(4) SYNC: EUSART Mode Select bit
//         1 = Synchronous mode
//         0 = Asynchronous mode
//   TXSTA(3) Unimplemented: Read as '0'
//   TXSTA(2) BRGH: High Baud Rate Select bit
//     Asynchronous mode:
//         1 = High speed
//         0 = Low speed
//   TXSTA(1) TRMT: Transmit Shift Register Status bit
//         1 = TSR empty
//         0 = TSR full
//   TXSTA(0) TX9D: Ninth bit of Transmit Data
//        Can be address/data bit or a parity bit.
// *******************************************************
//  TXSTA = 0b00100100;
    TXSTA = 0b00100000;

// *******************************************************
// 2.Define RCSTA(RECEIVE STATUS AND CONTROL) Register   
//    RCSTA(7) SPEN: Serial Port Enable bit
//         1 = Serial port enabled (configures RX/DT and TX/CK pins as serial port pins)
//         0 = Serial port disabled (held in Reset)
//    RCSTA(6) RX9: 9-bit Receive Enable bit
//         1 = Selects 9-bit reception
//         0 = Selects 8-bit reception
//    RCSTA(5) SREN: Single Receive Enable bit
//      Asynchronous mode:
//           Donft care
//    RCSTA(4) CREN: Continuous Receive Enable bit
//      Asynchronous mode:
//         1 = Enables receiver
//         0 = Disables receiver
//    RCSTA(3) ADDEN: Address Detect Enable bit
//      Asynchronous mode 9-bit (RX9 = 1):
//         1 = Enables address detection, enable interrupt and load the receive buffer when RSR<8> is set
//         0 = Disables address detection, all bytes are received and ninth bit can be used as parity bit
//      Asynchronous mode 8-bit (RX9 = 0):
//        Donft care
//    RCSTA(2) FERR: Framing Error bit
//      1 = Framing error (can be updated by reading RCREG register and receive next valid byte)
//      0 = No framing error
//    RCSTA(1) OERR: Overrun Error bit
//      1 = Overrun error (can be cleared by clearing bit CREN)
//      0 = No overrun error
//    RCSTA(0) RX9D: Ninth bit of Received Data
//      This can be address/data bit or a parity bit and must be calculated by user firmware.
// *******************************************************
    RCSTA=0b10010000;

// *******************************************************
// 3.Define SPBRG(Baud Rate Generator Register) Register
// *******************************************************
//     9600BPS, OSC:40MHz(40MHz*PLL) ==> SPREG=64
    SPBRG=64;

}

//******************************************************************************************
//   Function Name : SendUART_s
//   Title         : 
//   Input         : 
//   Output        :
//   Description   : Write TXREG
//******************************************************************************************
void SendUART_s(char *put_string)
{
    while(*put_string!=0x00){
        Trans_USART(*put_string);
        put_string++;
    }

}

//****************************************************************************
//   Function Name : Trans_USART
//   Title         : 
//   Input         : 
//   Output        : 
//   Description   : 
//****************************************************************************
void Trans_USART(unsigned char IO_data )
{
char chk_flg;
//  
//  1.Check Send Flag
//
    while(1){
        chk_flg = TXSTA & 0x02; //0000,0010 TXSTA(TRMT)
        if(chk_flg != 0x00)break;
    }
//
//  2.Set data
//
    TXREG = IO_data;

}

//****************************************************************************
//   Function Name : Rec_USART
//   Title         : 
//   Input         : 
//   Output        : 
//   Description   : 
//****************************************************************************
void Rec_USART(unsigned char *IO_data )
{
char chk_flg;
//  
//  1.Check Recvive Flag
//
    while(1){
        chk_flg = PIR1 & 0x20; //0010,0000 PIR1(RCIF)
        if(chk_flg != 0x00)break;
    }
//  
//  2.Check error
//
    chk_flg = RCSTA & 0x06; //0000,0110 RCSTA(FERR,OERR)
    if(chk_flg != 0x00){
        *IO_data = 0x00;
        return;
    }
//  
//  3.Set Recive Data
//
    *IO_data = RCREG;
}

//****************************************************************************
//   Function Name : isr
//   Title         : interrupt (UART) 
//   Input         :
//   Output        :
//****************************************************************************
#pragma code Int_addr=0x8
void Int_function (void)
{
     _asm GOTO isr _endasm
}
#pragma code
#pragma interruptlow isr
void isr (void) {
    unsigned char io_char;
    unsigned char lp;

    Rec_USART(&io_char);
    Trans_USART(io_char);
    if(G_index==PI_NODATA){
        if(io_char=='>'){
            G_index=0;
        }
    }else if(G_index<PI_7SEG_MAX){
        G_tmp_c_dat[G_index] = io_char;
        G_index++;
    }else{
        G_index=PI_NODATA;
        for(lp=0;lp<PI_7SEG_MAX;lp++){
            G_c_dat[lp] = G_tmp_c_dat[lp];
        }
    }
}