//******************************************************************************************
//  dsPIC33FJ256GP710 Sample Program
//   Project      :
//   Program Name :
//   Programer    :
//   Create date  :  Version 1.0    H23.08.05
//   History      :
//   Laungage     :  MPLAB C30 
//******************************************************************************************
//   Description
//    1.OSC  80MHz  (10MHz[Crystal]/2*32/2)
//    2.I/O Port
//      (1)Grafic LCD Control Port
//        PORTD(0-7)     : SG12864A(DB0-DB7)
//        PORTD(8)       : SG12864A(D/I)
//        PORTD(9)       : SG12864A(R/W)
//        PORTD(10)      : SG12864A(E)
//        PORTD(11)      : SG12864A(CS1)
//        PORTD(12)      : SG12864A(CS2)
//        PORTD(13)      : SG12864A(RES)
//      (2)UART Port
//        PORTF(2)/U1RX  : Serial Comunication RX
//        PORTF(3)/U1TX  : Serial Comunication TX
//      (3)Genaral I/O Port
//        PORTB(0-15)    : 
//        PORTE(0-7)     : 
//        
//******************************************************************************************

#include "string.h"
#include "stdio.h"
#include "ctype.h"
#include "math.h"
#include "stdlib.h"
#include "time.h"

#include "p33FJ256GP710.h"


//_FOSCSEL(FNOSC_FRC & IESO_OFF);                    //Fast RC oscillator
//_FOSCSEL(FNOSC_FRCPLL & IESO_OFF);                 //Fast RC oscillator w/ divide and PLL
_FOSCSEL(FNOSC_PRIPLL & IESO_OFF);                   //Primary oscillator (XT, HS, EC) w/ PLL
//_FOSC(FCKSM_CSECMD & OSCIOFNC_ON & POSCMD_NONE );  //OSC2 Pin:Digital I/O, Primary disabled(Internal OSC)
_FOSC(FCKSM_CSECMD & OSCIOFNC_OFF & POSCMD_XT );     //OSC2 Pin:OSC2 is clock O/P, XT oscillator(3-10MHz)
_FWDT(FWDTEN_OFF);  

// Parameter
#define   PI_P_DI            8
#define   PI_P_RW            9
#define   PI_P_E            10
#define   PI_P_CS1          11 
#define   PI_P_CS2          12 
#define   PI_P_RES          13 
//
#define   PI_NORMAL          0
#define   PI_FAILER          1
#define   PI_LINE           10  
#define   PI_PAGE           11 
#define   PI_FUR            12
#define   PI_SEC            13
#define   PI_LCD_FUR        14
#define   PI_LCD_SEC        15
#define   PI_SOLID_LINE     20
#define   PI_DOTTED_LINE    21

// Define function
void Prog01(void);
void Prog02(void);
void Init_LCD(void);
void LCD_clear(void);
char GRF_LINE(unsigned char, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char);
char LINE(unsigned char, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char);
char PSET(unsigned char, unsigned char, unsigned char);
void LCD_read(unsigned char, unsigned char, unsigned char, unsigned char *, unsigned char);
char Put_LCD_char(unsigned char, unsigned char, unsigned char, unsigned char);
char Set_fnt(unsigned char *, unsigned char);
void LCD_dsp(unsigned char, unsigned char, unsigned char, unsigned char, unsigned char);
void LCD_MOVF_DB(unsigned char);
void LCD_ENSIG(void);
void LCD_ENSIG_R(void);
void LCD_BCF(unsigned char);
void LCD_BSF(unsigned char);
void LCD_WRTRS_DB(void);
void LCD_RDTRS_DB(void);
void LCD_RED_DB(unsigned char *);
void NopN(unsigned int);
void InitUART(void);
void Timer(unsigned int);
void SendUART(char);
void SendUARTStr(char *);
void RecUART(char *);
void InitADC(void);
void GetADC(int *);

int main(void)
{

// *******************
//  1.Initialize
// *******************
//  (0)Define OSC 80MHz(10MHz/2*32(M32)/2)
    CLKDIV = 0b0000000000000000;
    PLLFBD = 0x001E;   //M32(M32-2=>0d30=>0x1E)  Use FNOSC_PRIPLL(Crystal)
//  PLLFBD = 0x0029;   //M43(M43-2=>0d41=>0x29)  Use FNOSC_FRCPLL(Internal OSC)

//  (1)Set All Digital Port  
    AD1PCFGL = 0xffff;
    AD1PCFGH = 0xffff;

//  (2)Define PORT
//    1)PortB
    TRISB = 0xFFFF;
//  LATB  = 0x0000;
    PORTB = 0x0000; 

//    2)PortD
    TRISD = 0xC000;
//  LATD  = 0x0000;
    PORTD = 0x0000; 

// (3)Initialized LCD
    Init_LCD();
    LCD_clear();

// *****************************
//  2.Program Main
// *****************************
//  (1)Program
    while(1){
//   1-1)Demo Characters   
        LCD_clear();   // LCD Crear 
        Prog01();      // Demo Program 1
        Timer(20);     // Wait 2[S]

//   1-2)Demo Graf   
        LCD_clear();   // LCD Crear 
        Prog02();      // Demo Program 2
        Timer(20);     // Wait 2[S]
    }

}


//******************************************************************************************
//   Function Name : Prog01
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
void Prog01(void)
{
    Put_LCD_char('0', 0, 0,  PI_LINE);
    Put_LCD_char('1', 0, 1,  PI_PAGE);
    Put_LCD_char('2', 0, 2,  PI_PAGE);
    Put_LCD_char('3', 0, 3,  PI_PAGE);
    Put_LCD_char('4', 0, 4,  PI_PAGE);
    Put_LCD_char('5', 0, 5,  PI_PAGE);
    Put_LCD_char('6', 0, 6,  PI_PAGE);
    Put_LCD_char('7', 0, 7,  PI_PAGE);
    Put_LCD_char('8', 0, 8,  PI_PAGE);
    Put_LCD_char('9', 0, 9,  PI_PAGE);
    Put_LCD_char('ｱ', 0,10,  PI_PAGE);
    Put_LCD_char('ｲ', 0,11,  PI_PAGE);
    Put_LCD_char('ｳ', 0,12,  PI_PAGE);
    Put_LCD_char('ｴ', 0,13,  PI_PAGE);
    Put_LCD_char('ｵ', 0,14,  PI_PAGE);
    Put_LCD_char('ｶ', 0,15,  PI_PAGE);
    Put_LCD_char('ｷ', 0,16,  PI_PAGE);
    Put_LCD_char('ｸ', 0,17,  PI_PAGE);
    Put_LCD_char('ｹ', 0,18,  PI_PAGE);
    Put_LCD_char('ｺ', 0,19,  PI_PAGE);
    Put_LCD_char('ｻ', 0,20,  PI_PAGE);
    Put_LCD_char('ｼ', 1, 0,  PI_PAGE);
    Put_LCD_char('ｽ', 1, 1,  PI_PAGE);
    Put_LCD_char('ｾ', 1, 2,  PI_PAGE);
    Put_LCD_char('ｿ', 1, 3,  PI_PAGE);
    Put_LCD_char('ﾀ', 1, 4,  PI_PAGE);
    Put_LCD_char('ﾁ', 1, 5,  PI_PAGE);
    Put_LCD_char('ﾂ', 1, 6,  PI_PAGE);
    Put_LCD_char('ﾃ', 1, 7,  PI_PAGE);
    Put_LCD_char('ﾄ', 1, 8,  PI_PAGE);
    Put_LCD_char('ﾅ', 1, 9,  PI_PAGE);
    Put_LCD_char('ﾆ', 1,10,  PI_PAGE);
    Put_LCD_char('ﾇ', 1,11,  PI_PAGE);
    Put_LCD_char('ﾈ', 1,12,  PI_PAGE);
    Put_LCD_char('ﾉ', 1,13,  PI_PAGE);
    Put_LCD_char('ﾊ', 1,14,  PI_PAGE);
    Put_LCD_char('ﾋ', 1,15,  PI_PAGE);
    Put_LCD_char('ﾌ', 1,16,  PI_PAGE);
    Put_LCD_char('ﾍ', 1,17,  PI_PAGE);
    Put_LCD_char('ﾎ', 1,18,  PI_PAGE);
    Put_LCD_char('ﾏ', 1,19,  PI_PAGE);
    Put_LCD_char('ﾐ', 1,20,  PI_PAGE);
    Put_LCD_char('ﾑ', 2, 0,  PI_PAGE);
    Put_LCD_char('ﾒ', 2, 1,  PI_PAGE);
    Put_LCD_char('ﾓ', 2, 2,  PI_PAGE);
    Put_LCD_char('ﾔ', 2, 3,  PI_PAGE);
    Put_LCD_char('ﾕ', 2, 4,  PI_PAGE);
    Put_LCD_char('ﾖ', 2, 5,  PI_PAGE);
    Put_LCD_char('ﾗ', 2, 6,  PI_PAGE);
    Put_LCD_char('ﾘ', 2, 7,  PI_PAGE);
    Put_LCD_char('ﾙ', 2, 8,  PI_PAGE);
    Put_LCD_char('ﾚ', 2, 9,  PI_PAGE);
    Put_LCD_char('ﾛ', 2,10,  PI_PAGE);
    Put_LCD_char('ﾜ', 2,11,  PI_PAGE);
    Put_LCD_char('ﾝ', 2,12,  PI_PAGE);
    Put_LCD_char('ﾞ', 2,13,  PI_PAGE);
    Put_LCD_char('ﾟ', 2,14,  PI_PAGE);
//
    Put_LCD_char('A', 3, 0,  PI_PAGE);
    Put_LCD_char('B', 3, 1,  PI_PAGE);
    Put_LCD_char('C', 3, 2,  PI_PAGE);
    Put_LCD_char('D', 3, 3,  PI_PAGE);
    Put_LCD_char('E', 3, 4,  PI_PAGE);
    Put_LCD_char('F', 3, 5,  PI_PAGE);
    Put_LCD_char('G', 3, 6,  PI_PAGE);
    Put_LCD_char('H', 3, 7,  PI_PAGE);
    Put_LCD_char('I', 3, 8,  PI_PAGE);
    Put_LCD_char('J', 3, 9,  PI_PAGE);
    Put_LCD_char('K', 3,10,  PI_PAGE);
    Put_LCD_char('L', 3,11,  PI_PAGE);
    Put_LCD_char('M', 3,12,  PI_PAGE);
    Put_LCD_char('N', 3,13,  PI_PAGE);
    Put_LCD_char('O', 3,14,  PI_PAGE);
    Put_LCD_char('P', 3,15,  PI_PAGE);
    Put_LCD_char('Q', 3,16,  PI_PAGE);
    Put_LCD_char('R', 3,17,  PI_PAGE);
    Put_LCD_char('S', 3,18,  PI_PAGE);
    Put_LCD_char('T', 3,19,  PI_PAGE);
    Put_LCD_char('U', 3,20,  PI_PAGE);
    Put_LCD_char('V', 4, 0,  PI_PAGE);
    Put_LCD_char('W', 4, 1,  PI_PAGE);
    Put_LCD_char('X', 4, 2,  PI_PAGE);
    Put_LCD_char('Y', 4, 3,  PI_PAGE);
    Put_LCD_char('Z', 4, 4,  PI_PAGE);
    Put_LCD_char('u', 4, 5,  PI_PAGE);
    Put_LCD_char('d', 4, 6,  PI_PAGE);
    Put_LCD_char('r', 4, 7,  PI_PAGE);
    Put_LCD_char('l', 4, 8,  PI_PAGE);
    Put_LCD_char(' ', 4, 9,  PI_PAGE);
    Put_LCD_char('a', 4,10,  PI_PAGE);
    Put_LCD_char('e', 4,11,  PI_PAGE);
    Put_LCD_char('+', 4,12,  PI_PAGE);
    Put_LCD_char('-', 4,13,  PI_PAGE);
    Put_LCD_char('=', 4,14,  PI_PAGE);
    Put_LCD_char(')', 4,15,  PI_PAGE);
    Put_LCD_char('(', 4,16,  PI_PAGE);
    Put_LCD_char(']', 4,17,  PI_PAGE);
    Put_LCD_char('[', 4,18,  PI_PAGE);
    Put_LCD_char('>', 4,19,  PI_PAGE);
    Put_LCD_char('<', 4,20,  PI_PAGE);
    Put_LCD_char('"', 5, 0,  PI_PAGE);
    Put_LCD_char('!', 5, 1,  PI_PAGE);
    Put_LCD_char('*', 5, 2,  PI_PAGE);
    Put_LCD_char('/', 5, 3,  PI_PAGE);
}

//******************************************************************************************
//   Function Name : Prog02
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
void Prog02(void)
{
    unsigned char lp;
    unsigned char  y;
    float f_y, f_x ;


// *****************************************
//  1.Line 
// *****************************************
    GRF_LINE(5, 5,  5, 60, PI_SOLID_LINE,  PI_FUR);
    GRF_LINE(5, 5, 125, 5, PI_SOLID_LINE,  PI_FUR);

    for(lp=25;lp<50;lp=lp+20){
        GRF_LINE(5,lp, 125,lp, PI_DOTTED_LINE, PI_FUR);
    }
    for(lp=5;lp<127;lp=lp+20){
        GRF_LINE(lp,5, lp,50, PI_DOTTED_LINE, PI_FUR);
    }
    Put_LCD_char('X', 7, 20, PI_LCD_FUR);
    Put_LCD_char('Y', 0,  0, PI_LCD_FUR);

// *****************************************
//  2.Graf 
// *****************************************
// (1)Y = SIN(X)
    for(lp=0;lp<120;lp++){
        f_x = lp;
        f_x = f_x / (float)5 ;
        f_y = sin(f_x) * 20 + 20 ;
        y = (unsigned char)f_y;
        GRF_LINE((lp+5),(y+5),(lp+5),(y+5), PI_SOLID_LINE, PI_FUR);
    }

// *****************************************
//  3.Title 
// *****************************************

     Put_LCD_char('Y', 0, 11, PI_LCD_SEC);
     Put_LCD_char('=', 0, 12, PI_LCD_SEC);
     Put_LCD_char('S', 0, 13, PI_LCD_SEC);
     Put_LCD_char('I', 0, 14, PI_LCD_SEC);
     Put_LCD_char('N', 0, 15, PI_LCD_SEC);
     Put_LCD_char('(', 0, 16, PI_LCD_SEC);
     Put_LCD_char('X', 0, 17, PI_LCD_SEC);
     Put_LCD_char(')', 0, 18, PI_LCD_SEC);
//
     Put_LCD_char('G', 0, 4, PI_LCD_SEC);
     Put_LCD_char('R', 0, 5, PI_LCD_SEC);
     Put_LCD_char('A', 0, 6, PI_LCD_SEC);
     Put_LCD_char('F', 0, 7, PI_LCD_SEC);

}

//******************************************************************************************
//   Function Name : Init_LCD
//   Title         : Initialized LCD
//   Input         : 
//   Output        : 
//******************************************************************************************
void Init_LCD(void)
{
    unsigned short  tmp_s=0; 

// *************************
//  1.Default Value
// *************************
    tmp_s = (1<<PI_P_E) | (0<<PI_P_RW) | (0<<PI_P_DI) | (1<<PI_P_CS1) | (0<<PI_P_CS2);
    PORTD = tmp_s;

// *************************
//  2.LCD Reset (1.0[μS]<)
// *************************
    LCD_BCF(PI_P_RES);
    NopN(1);  //1.0[μS]<
//
    LCD_BSF(PI_P_RES);
    NopN(1);  //1.0[μS]<



}

//******************************************************************************************
//   Function Name : LCD_clear
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
void LCD_clear(void)
{
    unsigned char lp_page;
    unsigned char lp_clm;
 
    LCD_dsp(0, 0, 0, 0x00, PI_LINE);

    for(lp_page=0;lp_page<8;lp_page++){
        for(lp_clm=0;lp_clm<128;lp_clm++){
            LCD_dsp(0, lp_page, lp_clm, 0x00, PI_PAGE);
        }
    }
}

//******************************************************************************************
//   Function Name :  GRF_LINE
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
char GRF_LINE(unsigned char in_x0, unsigned char in_y0, unsigned char in_x1, unsigned char in_y1, 
          unsigned char line_mode, unsigned char in_mode)
{
    char status;

    in_y0 = 63 - in_y0 ; 
    in_y1 = 63 - in_y1 ; 
    status = LINE(in_x0, in_y0, in_x1, in_y1, line_mode, in_mode);

    return(status);
}


//******************************************************************************************
//   Function Name :  LINE
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
char LINE(unsigned char in_x0, unsigned char in_y0, unsigned char in_x1, unsigned char in_y1, 
          unsigned char line_mode, unsigned char in_mode)
{
    unsigned char tmp_c;
    float  f_x0,f_x1,f_y0,f_y1;    
    float  A,B;    
    int    y;
    unsigned char cx,cy;
    int  lp;
    unsigned char chk_flg = 0;
    unsigned char lp_add;

// **********************
// 0.Initialize 
// **********************
    if(line_mode == PI_DOTTED_LINE){
        lp_add = 2;
    }else{
        lp_add = 1;
    } 

// **********************
// 1.Check argument 
// **********************
    if(in_x0 > in_x1){
        tmp_c = in_x0;
        in_x0 = in_x1;
        in_x1 = tmp_c;

        tmp_c = in_y0;
        in_y0 = in_y1;
        in_y1 = tmp_c;
    }

    if((in_x0 == in_x1) && (in_y0 == in_y1)){
        if((in_x0 < 128)&&(in_y0 < 64)){
            if(in_mode == PI_FUR){
                PSET(in_x0, in_y0,PI_FUR);
            }
            PSET(in_x0, in_y0,PI_SEC);                
        }
        return(PI_NORMAL);
    }else if(in_x0 == in_x1){
        if(in_y0 > in_y1){
            tmp_c = in_y0;
            in_y0 = in_y1;
            in_y1 = tmp_c;
        }
        for(lp=in_y0;lp<in_y1;lp=lp+lp_add){
            if(in_mode == PI_FUR && chk_flg == 0){
                PSET(in_x0, lp, PI_FUR);
                chk_flg = 1;
            }
            PSET(in_x0, lp,PI_SEC);      
        }
        return(PI_NORMAL);
    }

    if(in_x0 > 127){
        in_x0 = 127 ;
    }   
    if(in_x1 > 127){
        in_x1 = 127 ;
    }   

// **********************
// 2.Calc A 
// **********************
    f_x0 = (float)in_x0;
    f_x1 = (float)in_x1;
    f_y0 = (float)in_y0;
    f_y1 = (float)in_y1;
    A = ((float)(f_y1 - f_y0)) / ((float)(f_x1 - f_x0));
    B = (float)f_y0 - (float)(A * (float)f_x0);    

// **********************
// 3.Program 
// **********************
    for(lp=in_x0;lp < ( in_x1 + 1 ) ; lp=lp+lp_add){        
        y = A * lp + B ; 
        if(y < 0 || 62 < y ){
        }else{
            cx=lp;
            cy=y;            
            if(in_mode == PI_FUR && chk_flg == 0){
                PSET(cx, cy,PI_FUR);
                chk_flg = 1;
            }
            PSET(cx, cy,PI_SEC);
        }
    }
    return(PI_NORMAL);
}

//******************************************************************************************
//   Function Name :  PSET
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
char PSET(unsigned char in_x, unsigned char in_y, unsigned char in_mode)
{
    unsigned char tmp_page;
    unsigned char tmp_data;
    unsigned char tmp_lcd_data;

    tmp_page = in_y / 8 ;
    tmp_data = ( 1 << ( in_y % 8 )); 
    if(tmp_page > 7) return(PI_FAILER);

    if(in_mode == PI_FUR){
        LCD_read(0, 0, 0, &tmp_lcd_data, PI_LINE);
    }

    LCD_read(0, tmp_page, in_x, &tmp_lcd_data, PI_PAGE);
    tmp_data = tmp_data | tmp_lcd_data ;

    LCD_dsp(0, tmp_page, in_x, tmp_data, PI_PAGE);

    return(PI_NORMAL);
}

//******************************************************************************************
//   Function Name :  Put_LCD_char
//   Title         : 
//   Input         : char, page, clm(char), cs, mode
//   Output        : 
//******************************************************************************************
char Put_LCD_char(unsigned char in_char, unsigned char in_page,  unsigned char in_pos, 
unsigned char in_mode )
{
    unsigned char fnt[5];
    unsigned int  lp;
    unsigned char clm;
    unsigned char tmp_line;
    char status;

//  1.Get Font
    status = Set_fnt(&fnt[0], in_char);
//  if(status != PI_NORMAL) return(PI_FAILER);

//  2.Check Error
//  (1)Check position
    if(in_pos > 20 ){
        return(PI_FAILER);
    }else if(in_page > 7){
        return(PI_FAILER);
    }

//  3.Put LCD
    if(in_mode == PI_LINE){
        tmp_line = in_page *8; 
        LCD_dsp(tmp_line, 0, 0, 0x00, PI_LINE);
    }

    clm = in_pos * 6 ;
    for(lp=0;lp<5;lp++){
        LCD_dsp(0, in_page, clm, fnt[lp], PI_PAGE);
        clm++;
    }

    return(PI_NORMAL);
}

//******************************************************************************************
//   Function Name : Set_fnt
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
char Set_fnt(unsigned char fnt[], unsigned char c)
{
// ****************
//   0-9
// ****************

    if(c=='0'){
        fnt[0] = 0b00000000;
        fnt[1] = 0b00111110;
        fnt[2] = 0b01000001;
        fnt[3] = 0b00111110;
        fnt[4] = 0b00000000;
        return(PI_NORMAL);
    }
    if(c=='1'){
        fnt[0] = 0b00000000;
        fnt[1] = 0b01000010;
        fnt[2] = 0b01111111;
        fnt[3] = 0b01000000;
        fnt[4] = 0b00000000;
        return(PI_NORMAL);
    }
    if(c=='2'){
        fnt[0] = 0b01000010;
        fnt[1] = 0b01000001;
        fnt[2] = 0b01100001;
        fnt[3] = 0b01010001;
        fnt[4] = 0b01001110;
        return(PI_NORMAL);
    }
    if(c=='3'){
        fnt[0] = 0b00100010;
        fnt[1] = 0b01001001;
        fnt[2] = 0b01001001;
        fnt[3] = 0b01001001;
        fnt[4] = 0b00110110;
        return(PI_NORMAL);
    }
    if(c=='4'){
        fnt[0] = 0b00111100;
        fnt[1] = 0b00100010;
        fnt[2] = 0b00100001;
        fnt[3] = 0b01111111;
        fnt[4] = 0b00100000;
        return(PI_NORMAL);
    }
    if(c=='5'){
        fnt[0] = 0b01001111;
        fnt[1] = 0b01001001;
        fnt[2] = 0b01001001;
        fnt[3] = 0b01001001;
        fnt[4] = 0b00110000;
        return(PI_NORMAL);
    }
    if(c=='6'){
        fnt[0] = 0b00111110;
        fnt[1] = 0b01001001;
        fnt[2] = 0b01001001;
        fnt[3] = 0b01001001;
        fnt[4] = 0b00110000;
        return(PI_NORMAL);
    }
    if(c=='7'){
        fnt[0] = 0b00000001;
        fnt[1] = 0b00000001;
        fnt[2] = 0b01110001;
        fnt[3] = 0b00001001;
        fnt[4] = 0b00000111;
        return(PI_NORMAL);
    }
    if(c=='8'){
        fnt[0] = 0b00110110;
        fnt[1] = 0b01001001;
        fnt[2] = 0b01001001;
        fnt[3] = 0b01001001;
        fnt[4] = 0b00110110;
        return(PI_NORMAL);
    }
    if(c=='9'){
        fnt[0] = 0b00100110;
        fnt[1] = 0b01001001;
        fnt[2] = 0b01001001;
        fnt[3] = 0b01001001;
        fnt[4] = 0b00111110;
        return(PI_NORMAL);
    }

// ****************
//   A-Z
// ****************
    if(c=='A'){
        fnt[0] = 0b01111100;
        fnt[1] = 0b00010010;
        fnt[2] = 0b00010001;
        fnt[3] = 0b00010010;
        fnt[4] = 0b01111100;
        return(PI_NORMAL);
    }
    if(c=='B'){
        fnt[0] = 0b01111111;
        fnt[1] = 0b01001001;
        fnt[2] = 0b01001001;
        fnt[3] = 0b01001001;
        fnt[4] = 0b00110110;
        return(PI_NORMAL);
    }
    if(c=='C'){
        fnt[0] = 0b00111110;
        fnt[1] = 0b01000001;
        fnt[2] = 0b01000001;
        fnt[3] = 0b01000001;
        fnt[4] = 0b00100010;
        return(PI_NORMAL);
    }
    if(c=='D'){
        fnt[0] = 0b01111111;
        fnt[1] = 0b01000001;
        fnt[2] = 0b01000001;
        fnt[3] = 0b01000001;
        fnt[4] = 0b00111110;
        return(PI_NORMAL);
    }
    if(c=='E'){
        fnt[0] = 0b01111111;
        fnt[1] = 0b01001001;
        fnt[2] = 0b01001001;
        fnt[3] = 0b01001001;
        fnt[4] = 0b01001001;
        return(PI_NORMAL);
    }
    if(c=='F'){
        fnt[0] = 0b01111111;
        fnt[1] = 0b00001001;
        fnt[2] = 0b00001001;
        fnt[3] = 0b00001001;
        fnt[4] = 0b00001001;
        return(PI_NORMAL);

    }
    if(c=='G'){
        fnt[0] = 0b00111110;
        fnt[1] = 0b01000001;
        fnt[2] = 0b01001001;
        fnt[3] = 0b01001001;
        fnt[4] = 0b01111010;
        return(PI_NORMAL);
    }
    if(c=='H'){
        fnt[0] = 0b01111111;
        fnt[1] = 0b00001000;
        fnt[2] = 0b00001000;
        fnt[3] = 0b00001000;
        fnt[4] = 0b01111111;
        return(PI_NORMAL);
    }
    if(c=='I'){
        fnt[0] = 0b00000000;
        fnt[1] = 0b01000001;
        fnt[2] = 0b01111111;
        fnt[3] = 0b01000001;
        fnt[4] = 0b00000000;
        return(PI_NORMAL);
    }
    if(c=='J'){
        fnt[0] = 0b00100000;
        fnt[1] = 0b01000000;
        fnt[2] = 0b01000000;
        fnt[3] = 0b01000000;
        fnt[4] = 0b00111111;
        return(PI_NORMAL);
    }
    if(c=='K'){
        fnt[0] = 0b01111111;
        fnt[1] = 0b00001000;
        fnt[2] = 0b00010100;
        fnt[3] = 0b00100010;
        fnt[4] = 0b01000001;
        return(PI_NORMAL);
    }
    if(c=='L'){
        fnt[0] = 0b01111111;
        fnt[1] = 0b01000000;
        fnt[2] = 0b01000000;
        fnt[3] = 0b01000000;
        fnt[4] = 0b01000000;
        return(PI_NORMAL);
    }
    if(c=='M'){
        fnt[0] = 0b01111111;
        fnt[1] = 0b00000010;
        fnt[2] = 0b00011100;
        fnt[3] = 0b00000010;
        fnt[4] = 0b01111111;
        return(PI_NORMAL);
    }
    if(c=='N'){
        fnt[0] = 0b01111111;
        fnt[1] = 0b00000010;
        fnt[2] = 0b00001000;
        fnt[3] = 0b00100000;
        fnt[4] = 0b01111111;
        return(PI_NORMAL);
    }
    if(c=='O'){
        fnt[0] = 0b00111110;
        fnt[1] = 0b01000001;
        fnt[2] = 0b01000001;
        fnt[3] = 0b01000001;
        fnt[4] = 0b00111110;
        return(PI_NORMAL);
    }
    if(c=='P'){
        fnt[0] = 0b01111111;
        fnt[1] = 0b00001001;
        fnt[2] = 0b00001001;
        fnt[3] = 0b00001001;
        fnt[4] = 0b00000110;
        return(PI_NORMAL);
    }
    if(c=='Q'){
        fnt[0] = 0b00111110;
        fnt[1] = 0b01000001;
        fnt[2] = 0b01010001;
        fnt[3] = 0b00111110;
        fnt[4] = 0b01000000;
        return(PI_NORMAL);
    }
    if(c=='R'){
        fnt[0] = 0b01111111;
        fnt[1] = 0b00001001;
        fnt[2] = 0b00011001;
        fnt[3] = 0b00101001;
        fnt[4] = 0b01000110;
        return(PI_NORMAL);
    }
    if(c=='S'){
        fnt[0] = 0b00100110;
        fnt[1] = 0b01001001;
        fnt[2] = 0b01001001;
        fnt[3] = 0b01001001;
        fnt[4] = 0b00110010;
        return(PI_NORMAL);
    }
    if(c=='T'){
        fnt[0] = 0b00000001;
        fnt[1] = 0b00000001;
        fnt[2] = 0b01111111;
        fnt[3] = 0b00000001;
        fnt[4] = 0b00000001;
        return(PI_NORMAL);
    }
    if(c=='U'){
        fnt[0] = 0b00111111;
        fnt[1] = 0b01000000;
        fnt[2] = 0b01000000;
        fnt[3] = 0b01000000;
        fnt[4] = 0b00111111;
        return(PI_NORMAL);
    }
   if(c=='V'){
        fnt[0] = 0b00011111;
        fnt[1] = 0b00100000;
        fnt[2] = 0b01000000;
        fnt[3] = 0b00100000;
        fnt[4] = 0b00011111;
        return(PI_NORMAL);
    }
    if(c=='W'){
        fnt[0] = 0b00111111;
        fnt[1] = 0b01000000;
        fnt[2] = 0b00111111;
        fnt[3] = 0b01000000;
        fnt[4] = 0b00111111;
        return(PI_NORMAL);
    }
    if(c=='X'){
        fnt[0] = 0b01000001;
        fnt[1] = 0b00100010;
        fnt[2] = 0b00011100;
        fnt[3] = 0b00100010;
        fnt[4] = 0b01000001;
        return(PI_NORMAL);
    }

    if(c=='Y'){
        fnt[0] = 0b00000001;
        fnt[1] = 0b00000100;
        fnt[2] = 0b01110000;
        fnt[3] = 0b00000100;
        fnt[4] = 0b00000001;
        return(PI_NORMAL);
    }
    if(c=='Z'){
        fnt[0] = 0b01100001;
        fnt[1] = 0b01010001;
        fnt[2] = 0b01001001;
        fnt[3] = 0b01000101;
        fnt[4] = 0b01000011;
        return(PI_NORMAL);
    }

// ****************
//   ｶﾅ文字
// ****************

   if(c==0xb1){  //'ｱ'
        fnt[0] = 0b00000001;
        fnt[1] = 0b01000001;
        fnt[2] = 0b00111101;
        fnt[3] = 0b00001001;
        fnt[4] = 0b00000111;
        return(PI_NORMAL);
    }

    if(c==0xb2){  //'ｲ'
        fnt[0] = 0b00100000;
        fnt[1] = 0b00010000;
        fnt[2] = 0b01111100;
        fnt[3] = 0b00000011;
        fnt[4] = 0b00000000;
        return(PI_NORMAL);
    }

    if(c==0xb3){  //'ｳ'
        fnt[0] = 0b00000110;
        fnt[1] = 0b00000010;
        fnt[2] = 0b01000011;
        fnt[3] = 0b00100010;
        fnt[4] = 0b00011110;
        return(PI_NORMAL);
    }

    if(c==0xb4){  //'ｴ'
        fnt[0] = 0b01000000;
        fnt[1] = 0b01000010;
        fnt[2] = 0b01111110;
        fnt[3] = 0b01000010;
        fnt[4] = 0b01000000;
        return(PI_NORMAL);
    }

    if(c==0xb5){  //'ｵ'
        fnt[0] = 0b00100010;
        fnt[1] = 0b00010010;
        fnt[2] = 0b00001010;
        fnt[3] = 0b01111111;
        fnt[4] = 0b00000010;
        return(PI_NORMAL);
    }

    if(c==0xb6){  //'ｶ'
        fnt[0] = 0b01000010;
        fnt[1] = 0b00111111;
        fnt[2] = 0b00000010;
        fnt[3] = 0b01000010;
        fnt[4] = 0b00111110;
        return(PI_NORMAL);
    }

    if(c==0xb7){  //'ｷ'
        fnt[0] = 0b00001010;
        fnt[1] = 0b00001010;
        fnt[2] = 0b01111111;
        fnt[3] = 0b00001010;
        fnt[4] = 0b00001010;
        return(PI_NORMAL);
    }

    if(c==0xb8){  //'ｸ'
        fnt[0] = 0b00000100;
        fnt[1] = 0b00000011;
        fnt[2] = 0b01000001;
        fnt[3] = 0b00100001;
        fnt[4] = 0b00011111;
        return(PI_NORMAL);
    }

    if(c==0xb9){  //'ｹ'
        fnt[0] = 0b00001000;
        fnt[1] = 0b00000111;
        fnt[2] = 0b01000010;
        fnt[3] = 0b00111110;
        fnt[4] = 0b00000010;
        return(PI_NORMAL);
    }

    if(c==0xba){  //'ｺ'
        fnt[0] = 0b01000010;
        fnt[1] = 0b01000010;
        fnt[2] = 0b01000010;
        fnt[3] = 0b01000010;
        fnt[4] = 0b01111110;
        return(PI_NORMAL);
    }

    if(c==0xbb){  //'ｻ'
        fnt[0] = 0b00000010;
        fnt[1] = 0b00001111;
        fnt[2] = 0b01000010;
        fnt[3] = 0b00111111;
        fnt[4] = 0b00000010;
        return(PI_NORMAL);
    }

    if(c==0xbc){  //'ｼ'
        fnt[0] = 0b00001010;
        fnt[1] = 0b00010100;
        fnt[2] = 0b00000000;
        fnt[3] = 0b01000000;
        fnt[4] = 0b00111110;
        return(PI_NORMAL);
    }

    if(c==0xbd){  //'ｽ'
        fnt[0] = 0b01000010;
        fnt[1] = 0b00100010;
        fnt[2] = 0b00011010;
        fnt[3] = 0b00100110;
        fnt[4] = 0b01000010;
        return(PI_NORMAL);
    }

    if(c==0xbe){  //'ｾ'
        fnt[0] = 0b00000100;
        fnt[1] = 0b01111111;
        fnt[2] = 0b01000100;
        fnt[3] = 0b01000100;
        fnt[4] = 0b01011100;
        return(PI_NORMAL);
    }

    if(c==0xbf){  //'ｿ'
        fnt[0] = 0b00000010;
        fnt[1] = 0b00000100;
        fnt[2] = 0b01000000;
        fnt[3] = 0b00100000;
        fnt[4] = 0b00011110;
        return(PI_NORMAL);
    }

    if(c==0xc0){  //'ﾀ'
        fnt[0] = 0b00001000;
        fnt[1] = 0b00000110;
        fnt[2] = 0b01001001;
        fnt[3] = 0b00100001;
        fnt[4] = 0b00011111;
        return(PI_NORMAL);
    }

    if(c==0xc1){  //'ﾁ'
        fnt[0] = 0b00001000;
        fnt[1] = 0b01001010;
        fnt[2] = 0b00111111;
        fnt[3] = 0b00001001;
        fnt[4] = 0b00001000;
        return(PI_NORMAL);
    }

    if(c==0xc2){  //'ﾂ'
        fnt[0] = 0b00000100;
        fnt[1] = 0b00001000;
        fnt[2] = 0b00000100;
        fnt[3] = 0b01001000;
        fnt[4] = 0b00111110;
        return(PI_NORMAL);
    }

    if(c==0xc3){  //'ﾃ'
        fnt[0] = 0b00000100;
        fnt[1] = 0b01000101;
        fnt[2] = 0b00111101;
        fnt[3] = 0b00000101;
        fnt[4] = 0b00000100;
        return(PI_NORMAL);
    }

    if(c==0xc4){  //'ﾄ'
        fnt[0] = 0b00000000;
        fnt[1] = 0b01111111;
        fnt[2] = 0b00001000;
        fnt[3] = 0b00010000;
        fnt[4] = 0b00000000;
        return(PI_NORMAL);
    }

    if(c==0xc5){  //'ﾅ'
        fnt[0] = 0b00000100;
        fnt[1] = 0b00000100;
        fnt[2] = 0b01000100;
        fnt[3] = 0b00111111;
        fnt[4] = 0b00000100;
        return(PI_NORMAL);
    }

    if(c==0xc6){  //'ﾆ'
        fnt[0] = 0b01000000;
        fnt[1] = 0b01000010;
        fnt[2] = 0b01000010;
        fnt[3] = 0b01000010;
        fnt[4] = 0b01000000;
        return(PI_NORMAL);
    }

    if(c==0xc7){  //'ﾇ'
        fnt[0] = 0b01000010;
        fnt[1] = 0b00101010;
        fnt[2] = 0b00010010;
        fnt[3] = 0b00101010;
        fnt[4] = 0b01000110;
        return(PI_NORMAL);
    }

    if(c==0xc8){  //'ﾈ'
        fnt[0] = 0b00100010;
        fnt[1] = 0b00010010;
        fnt[2] = 0b01111011;
        fnt[3] = 0b00010110;
        fnt[4] = 0b00100010;
        return(PI_NORMAL);
    }

    if(c==0xc9){  //'ﾉ'
        fnt[0] = 0b00000000;
        fnt[1] = 0b00000000;
        fnt[2] = 0b01000000;
        fnt[3] = 0b00111111;
        fnt[4] = 0b00000000;
        return(PI_NORMAL);
    }

    if(c==0xca){  //'ﾊ'
        fnt[0] = 0b01100000;
        fnt[1] = 0b00011110;
        fnt[2] = 0b00000000;
        fnt[3] = 0b00011110;
        fnt[4] = 0b01100000;
        return(PI_NORMAL);
    }

    if(c==0xcb){  //'ﾋ'
        fnt[0] = 0b00111110;
        fnt[1] = 0b01001000;
        fnt[2] = 0b01001000;
        fnt[3] = 0b01001000;
        fnt[4] = 0b01001000;
        return(PI_NORMAL);
    }

    if(c==0xcc){  //'ﾌ'
        fnt[0] = 0b00000010;
        fnt[1] = 0b00000010;
        fnt[2] = 0b01000010;
        fnt[3] = 0b01000010;
        fnt[4] = 0b00111110;
        return(PI_NORMAL);
    }

    if(c==0xcd){  //'ﾍ'
        fnt[0] = 0b00001000;
        fnt[1] = 0b00000100;
        fnt[2] = 0b00000100;
        fnt[3] = 0b00001000;
        fnt[4] = 0b00010000;
        return(PI_NORMAL);
    }

    if(c==0xce){  //'ﾎ'
        fnt[0] = 0b00110010;
        fnt[1] = 0b00000010;
        fnt[2] = 0b01111111;
        fnt[3] = 0b00000010;
        fnt[4] = 0b00110010;
        return(PI_NORMAL);
    }

    if(c==0xcf){  //'ﾏ'
        fnt[0] = 0b00000010;
        fnt[1] = 0b00001010;
        fnt[2] = 0b00010010;
        fnt[3] = 0b00101010;
        fnt[4] = 0b01000110;
        return(PI_NORMAL);
    }

    if(c==0xd0){  //'ﾐ'
        fnt[0] = 0b00000000;
        fnt[1] = 0b01001001;
        fnt[2] = 0b01001001;
        fnt[3] = 0b01001001;
        fnt[4] = 0b00000000;
        return(PI_NORMAL);
    }

    if(c==0xd1){  //'ﾑ'
        fnt[0] = 0b01110000;
        fnt[1] = 0b01001111;
        fnt[2] = 0b01000000;
        fnt[3] = 0b00110000;
        fnt[4] = 0b01000000;
        return(PI_NORMAL);
    }

    if(c==0xd2){  //'ﾒ'
        fnt[0] = 0b01000000;
        fnt[1] = 0b00101000;
        fnt[2] = 0b00011111;
        fnt[3] = 0b00100000;
        fnt[4] = 0b00000000;
        return(PI_NORMAL);
    }

    if(c==0xd3){  //'ﾓ'
        fnt[0] = 0b00001010;
        fnt[1] = 0b01111110;
        fnt[2] = 0b01001010;
        fnt[3] = 0b01001010;
        fnt[4] = 0b01001010;
        return(PI_NORMAL);
    }

    if(c==0xd4){  //'ﾔ'
        fnt[0] = 0b00000100;
        fnt[1] = 0b01111111;
        fnt[2] = 0b00000100;
        fnt[3] = 0b00010100;
        fnt[4] = 0b00001100;
        return(PI_NORMAL);
    }

    if(c==0xd5){  //'ﾕ'
        fnt[0] = 0b01000000;
        fnt[1] = 0b01000100;
        fnt[2] = 0b01000100;
        fnt[3] = 0b01111100;
        fnt[4] = 0b01000000;
        return(PI_NORMAL);
    }

    if(c==0xd6){  //'ﾖ'
        fnt[0] = 0b00000000;
        fnt[1] = 0b01010100;
        fnt[2] = 0b01010100;
        fnt[3] = 0b01111100;
        fnt[4] = 0b00000000;
        return(PI_NORMAL);
    }

    if(c==0xd7){  //'ﾗ'
        fnt[0] = 0b00000100;
        fnt[1] = 0b00000101;
        fnt[2] = 0b01000101;
        fnt[3] = 0b01000101;
        fnt[4] = 0b00111100;
        return(PI_NORMAL);
    }

    if(c==0xd8){  //'ﾘ'
        fnt[0] = 0b00000000;
        fnt[1] = 0b00001111;
        fnt[2] = 0b00000000;
        fnt[3] = 0b01000000;
        fnt[4] = 0b00111111;
        return(PI_NORMAL);
    }

    if(c==0xd9){  //'ﾙ'
        fnt[0] = 0b01111111;
        fnt[1] = 0b00000000;
        fnt[2] = 0b01111111;
        fnt[3] = 0b01000000;
        fnt[4] = 0b00100000;
        return(PI_NORMAL);
    }

    if(c==0xda){  //'ﾚ'
        fnt[0] = 0b00000000;
        fnt[1] = 0b01111111;
        fnt[2] = 0b01000000;
        fnt[3] = 0b01000000;
        fnt[4] = 0b00100000;
        return(PI_NORMAL);
    }

    if(c==0xdb){  //'ﾛ'
        fnt[0] = 0b00000000;
        fnt[1] = 0b01111110;
        fnt[2] = 0b01000010;
        fnt[3] = 0b01000010;
        fnt[4] = 0b01111110;
        return(PI_NORMAL);
    }

    if(c==0xdc){  //'ﾜ'
        fnt[0] = 0b00000000;
        fnt[1] = 0b00001110;
        fnt[2] = 0b00000010;
        fnt[3] = 0b01000010;
        fnt[4] = 0b00111110;
        return(PI_NORMAL);
    }

    if(c==0xdd){  //'ﾝ'
        fnt[0] = 0b00000010;
        fnt[1] = 0b00000100;
        fnt[2] = 0b01000000;
        fnt[3] = 0b00110000;
        fnt[4] = 0b00001110;
        return(PI_NORMAL);
    }

    if(c==0xde){  //'ﾞ'
        fnt[0] = 0b00000111;
        fnt[1] = 0b00000000;
        fnt[2] = 0b00000111;
        fnt[3] = 0b00000000;
        fnt[4] = 0b00000000;
        return(PI_NORMAL);
    }

    if(c==0xdf){  //'ﾟ'
        fnt[0] = 0b00000111;
        fnt[1] = 0b00000101;
        fnt[2] = 0b00000111;
        fnt[3] = 0b00000000;
        fnt[4] = 0b00000000;
        return(PI_NORMAL);
    }

// ****************
//   ELSE
// ****************

    if(c==' '){
        fnt[0] = 0b00000000;
        fnt[1] = 0b00000000;
        fnt[2] = 0b00000000;
        fnt[3] = 0b00000000;
        fnt[4] = 0b00000000;
        return(PI_NORMAL);
    }

    if(c=='u'){
        fnt[0] = 0b00000100;
        fnt[1] = 0b00000010;
        fnt[2] = 0b01111111;
        fnt[3] = 0b00000010;
        fnt[4] = 0b00000100;
        return(PI_NORMAL);
    }

    if(c=='d'){
        fnt[0] = 0b00010000;
        fnt[1] = 0b00100000;
        fnt[2] = 0b01111111;
        fnt[3] = 0b00100000;
        fnt[4] = 0b00010000;
        return(PI_NORMAL);
    }

    if(c=='r'){
        fnt[0] = 0b00001000;
        fnt[1] = 0b01001001;
        fnt[2] = 0b00101010;
        fnt[3] = 0b00011100;
        fnt[4] = 0b00001000;
        return(PI_NORMAL);
    }

    if(c=='l'){
        fnt[0] = 0b00001000;
        fnt[1] = 0b00011100;
        fnt[2] = 0b00101010;
        fnt[3] = 0b01001001;
        fnt[4] = 0b00001000;
        return(PI_NORMAL);
    }

    if(c=='a'){
        fnt[0] = 0b01111111;
        fnt[1] = 0b01111111;
        fnt[2] = 0b01111111;
        fnt[3] = 0b01111111;
        fnt[4] = 0b01111111;
        return(PI_NORMAL);
    }

    if(c=='+'){
        fnt[0] = 0b00001000;
        fnt[1] = 0b00001000;
        fnt[2] = 0b01111111;
        fnt[3] = 0b00001000;
        fnt[4] = 0b00001000;
        return(PI_NORMAL);
    }

    if(c=='-'){
        fnt[0] = 0b00001000;
        fnt[1] = 0b00001000;
        fnt[2] = 0b00001000;
        fnt[3] = 0b00001000;
        fnt[4] = 0b00001000;
        return(PI_NORMAL);
    }

    if(c=='='){
        fnt[0] = 0b00010100;
        fnt[1] = 0b00010100;
        fnt[2] = 0b00010100;
        fnt[3] = 0b00010100;
        fnt[4] = 0b00010100;
        return(PI_NORMAL);
    }

    if(c==')'){
        fnt[0] = 0b00000000;
        fnt[1] = 0b00000000;
        fnt[2] = 0b00000000;
        fnt[3] = 0b01000001;
        fnt[4] = 0b00111110;
        return(PI_NORMAL);
    }

    if(c=='('){
        fnt[0] = 0b00111110;
        fnt[1] = 0b01000001;
        fnt[2] = 0b00000000;
        fnt[3] = 0b00000000;
        fnt[4] = 0b00000000;
        return(PI_NORMAL);
    }

    if(c==']'){
        fnt[0] = 0b00000000;
        fnt[1] = 0b00000000;
        fnt[2] = 0b00000000;
        fnt[3] = 0b01000001;
        fnt[4] = 0b01111111;
        return(PI_NORMAL);
    }

    if(c=='['){
        fnt[0] = 0b01111111;
        fnt[1] = 0b01000001;
        fnt[2] = 0b00000000;
        fnt[3] = 0b00000000;
        fnt[4] = 0b00000000;
        return(PI_NORMAL);
    }

    if(c=='>'){
        fnt[0] = 0b00000000;
        fnt[1] = 0b01000001;
        fnt[2] = 0b00100010;
        fnt[3] = 0b00010100;
        fnt[4] = 0b00001000;
        return(PI_NORMAL);
    }

    if(c=='['){
        fnt[0] = 0b00001000;
        fnt[1] = 0b00010100;
        fnt[2] = 0b00100010;
        fnt[3] = 0b01000001;
        fnt[4] = 0b00000000;
        return(PI_NORMAL);
    }

    if(c=='*'){
        fnt[0] = 0b00100010;
        fnt[1] = 0b00010100;
        fnt[2] = 0b00001000;
        fnt[3] = 0b00010100;
        fnt[4] = 0b00100010;
        return(PI_NORMAL);
    }

    if(c=='/'){
        fnt[0] = 0b01000000;
        fnt[1] = 0b01100000;
        fnt[2] = 0b00011000;
        fnt[3] = 0b00000110;
        fnt[4] = 0b00000001;
        return(PI_NORMAL);
    }

    if(c=='"'){
        fnt[0] = 0b00000000;
        fnt[1] = 0b00000111;
        fnt[2] = 0b00000000;
        fnt[3] = 0b00000111;
        fnt[4] = 0b00000000;
        return(PI_NORMAL);
    }

    if(c=='!'){
        fnt[0] = 0b00000000;
        fnt[1] = 0b00000000;
        fnt[2] = 0b11011111;
        fnt[3] = 0b00000000;
        fnt[4] = 0b00000000;
        return(PI_NORMAL);
    }

    if(c==','){
        fnt[0] = 0b00000000;
        fnt[1] = 0b01000000;
        fnt[2] = 0b00110000;
        fnt[3] = 0b00000000;
        fnt[4] = 0b00000000;
        return(PI_NORMAL);
    }

    if(c=='.'){
        fnt[0] = 0b00000000;
        fnt[1] = 0b00000000;
        fnt[2] = 0b01100000;
        fnt[3] = 0b00000000;
        fnt[4] = 0b00000000;
        return(PI_NORMAL);
    }

    if(c==':'){
        fnt[0] = 0b00000000;
        fnt[1] = 0b00000000;
        fnt[2] = 0b00110110;
        fnt[3] = 0b00000000;
        fnt[4] = 0b00000000;
        return(PI_NORMAL);
    }

    if(c==';'){
        fnt[0] = 0b00000000;
        fnt[1] = 0b01000000;
        fnt[2] = 0b00110110;
        fnt[3] = 0b00000000;
        fnt[4] = 0b00000000;
        return(PI_NORMAL);
    }

// ELSE
    fnt[0] = 0b00000110;
    fnt[1] = 0b00001001;
    fnt[2] = 0b01110001;
    fnt[3] = 0b00000001;
    fnt[4] = 0b00000010;
    return(PI_FAILER);

}

//******************************************************************************************
//   Function Name : LCD_dsp
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
void LCD_dsp(unsigned char in_line, unsigned char in_page, unsigned char in_clm,
unsigned char in_dat, unsigned char in_mode)
{
    unsigned char tmp_c;

// *************************
//  0.Initialize
// *************************
    if(in_clm < 64){
        LCD_BSF(PI_P_CS1);
        LCD_BCF(PI_P_CS2);
    }else if(in_clm > 127){
        LCD_BCF(PI_P_CS1);
        LCD_BSF(PI_P_CS2);
        in_clm = 63 ;
    }else{
        LCD_BCF(PI_P_CS1);
        LCD_BSF(PI_P_CS2);
        in_clm = in_clm - 64 ;
    }

// *************************
//  1.Display ON
// *************************
//  (1)Set data
    LCD_BCF(PI_P_RW);
    LCD_BCF(PI_P_DI);
    LCD_MOVF_DB((unsigned short)0b00111111);

//  (2)Enable signal
    LCD_ENSIG();

// *************************
//  2.Display Start Line(0-63)
// *************************
    if(in_mode == PI_LINE){
//  (1)Set data
        LCD_BCF(PI_P_RW);
        LCD_BCF(PI_P_DI);
        tmp_c = 0b11000000 | in_line;
        LCD_MOVF_DB(tmp_c);

//  (2)Enable signal
        LCD_ENSIG();
    }

// *************************
//  3.Page Adress set(0-7)
// *************************
    if(in_mode == PI_PAGE){
//  (1)Set data
        LCD_BCF(PI_P_RW);
        LCD_BCF(PI_P_DI);
        tmp_c = 0b10111000 | (in_page & 0b00000111 );
        LCD_MOVF_DB(tmp_c);

//  (2)Enable signal
        LCD_ENSIG();
    }

// *************************
//  4.Set Colmn Adress(0-63)
// *************************
//  (1)Set data
    LCD_BCF(PI_P_RW);
    LCD_BCF(PI_P_DI);
    tmp_c = 0b01000000 | (in_clm & 0b00111111 );
    LCD_MOVF_DB(tmp_c);

//  (2)Enable signal
    LCD_ENSIG();

// *************************
//  5.Status Read
// *************************

// *************************
//  6.Write Display Data
// *************************
//  (1)Set data
    LCD_BCF(PI_P_RW);
    LCD_BSF(PI_P_DI);
    LCD_MOVF_DB(in_dat);

//  (2)Enable signal
    LCD_ENSIG();

    LCD_MOVF_DB((unsigned short)0b00111111);
    LCD_BCF(PI_P_DI);

// *************************
//  7.Read Display Data
// *************************

}


//******************************************************************************************
//   Function Name : LCD_read
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
void LCD_read(unsigned char in_line, unsigned char in_page, unsigned char in_clm,
unsigned char *out_dat, unsigned char in_mode)
{
    unsigned char tmp_c;

// *************************
//  0.Initialize
// *************************
    if(in_clm < 64){
        LCD_BSF(PI_P_CS1);
        LCD_BCF(PI_P_CS2);
    }else if(in_clm > 127){
        LCD_BCF(PI_P_CS1);
        LCD_BSF(PI_P_CS2);
        in_clm = 63 ;
    }else{
        LCD_BCF(PI_P_CS1);
        LCD_BSF(PI_P_CS2);
        in_clm = in_clm - 64 ;
    }

// *************************
//  1.Display ON
// *************************
//  (1)Set data
    LCD_BCF(PI_P_RW);
    LCD_BCF(PI_P_DI);
    LCD_MOVF_DB((unsigned short)0b00111111);

//  (2)Enable signal
    LCD_ENSIG();

// *************************
//  2.Display Start Line(0-63)
// *************************
    if(in_mode == PI_LINE){
//  (1)Set data
        LCD_BCF(PI_P_RW);
        LCD_BCF(PI_P_DI);
        tmp_c = 0b11000000 | in_line;
        LCD_MOVF_DB(tmp_c);

//  (2)Enable signal
        LCD_ENSIG();
    }

// *************************
//  3.Page Adress set(0-7)
// *************************
    if(in_mode == PI_PAGE){
//  (1)Set data
        LCD_BCF(PI_P_RW);
        LCD_BCF(PI_P_DI);
        tmp_c = 0b10111000 | (in_page & 0b00000111 );
        LCD_MOVF_DB(tmp_c);

//  (2)Enable signal
        LCD_ENSIG();
    }

// *************************
//  4.Set Colmn Adress(0-63)
// *************************
//  (1)Set data
    LCD_BCF(PI_P_RW);
    LCD_BCF(PI_P_DI);
    tmp_c = 0b01000000 | (in_clm & 0b00111111 );
    LCD_MOVF_DB(tmp_c);

//  (2)Enable signal
    LCD_ENSIG();

// *************************
//  5.Status Read
// *************************

// *************************
//  6.Write Display Data
// *************************

// *************************
//  7.Read Display Data
// *************************
//  (1)Set data
    LCD_RDTRS_DB();
    LCD_BSF(PI_P_RW);
    LCD_BSF(PI_P_DI);

//  (2)Enable signal
    LCD_ENSIG_R();
    LCD_RED_DB(out_dat);
    LCD_BCF(PI_P_RW);
    NopN(5); 
    LCD_WRTRS_DB();
//
    LCD_MOVF_DB((unsigned short)0b00111111);
    LCD_BCF(PI_P_DI);
}

//******************************************************************************************
//   Function Name : LCD_MOVF_DB
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
void LCD_MOVF_DB(unsigned char dat)
{
    unsigned short  tmp_s;
    tmp_s = PORTD & 0xFF00;
    tmp_s = tmp_s | dat ;  
    PORTD = tmp_s;
}

//******************************************************************************************
//   Function Name : LCD_ENSIG
//   Title         : Enable Signal
//   Input         : 
//   Output        : 
//******************************************************************************************
void LCD_ENSIG(void)
{
    NopN(1);  //450[nS]<
//
    LCD_BCF(PI_P_E);
    NopN(1);  //450[nS]<
//
    LCD_BSF(PI_P_E);
    NopN(1);  //450[nS]<

}


//******************************************************************************************
//   Function Name : LCD_ENSIG_R
//   Title         : Enable Signal
//   Input         : 
//   Output        : 
//******************************************************************************************
void LCD_ENSIG_R(void)
{
    NopN(5);
//
    LCD_BCF(PI_P_E);
    NopN(5);
//
    LCD_BSF(PI_P_E);
    NopN(5);

}

//******************************************************************************************
//   Function Name : LCD_BCF
//   Title         : BSF
//   Input         : 
//   Output        : 
//******************************************************************************************
void LCD_BCF(unsigned char pos)
{
    PORTD = PORTD & ~(1 << pos);
}

//******************************************************************************************
//   Function Name : LCD_BSF
//   Title         : BSF Control
//   Input         : 
//   Output        : 
//******************************************************************************************
void LCD_BSF(unsigned char pos)
{
    PORTD = PORTD | (1 << pos);
}

//******************************************************************************************
//   Function Name : LCD_WRTRS_DB
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
void LCD_WRTRS_DB(void)
{
    TRISD = 0xC000;
}

//******************************************************************************************
//   Function Name : LCD_RDTRS_DB
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
void LCD_RDTRS_DB(void)
{
    TRISD = 0xC0FF;
}


//******************************************************************************************
//   Function Name : LCD_RED_DB
//   Title         : Read DB0 - DB7
//   Input         : 
//   Output        : 
//******************************************************************************************
void LCD_RED_DB(unsigned char *dat)
{
    unsigned short tmp_dat;
    tmp_dat = PORTD;
    *dat = tmp_dat & 0b0000000011111111; 

}


//******************************************************************************************
//   Function Name : NopN
//   Title         : 
//   Input         : 
//   Output        :
//   Description   : OSC:80MHz ==> 80MHz / 2(PIC) * 40 ==> 1MHz(1μS) / n < 
//******************************************************************************************
void NopN(unsigned int n)
{
unsigned int lp,lp1;
for(lp=0;lp<n;lp++){
    for(lp1=0;lp1<4;lp1++){
        asm("NOP");
        asm("NOP");
        asm("NOP");
        asm("NOP");
        asm("NOP");
        asm("NOP");
        asm("NOP");
        asm("NOP");
        asm("NOP");
        asm("NOP");
        }
    }
}

//******************************************************************************************
//   Function Name : SendUARTStr
//   Title         : Send UART Strings
//   Input         :
//   Output        :
//******************************************************************************************
void SendUARTStr(char in_s[])
{
    unsigned int lp = 0;

    while(in_s[lp] != 0){
        SendUART(in_s[lp]);
        lp++; 
    }
}

//******************************************************************************************
//   Function Name : InitUART
//   Title         : Initialize UART
//   Input         :
//   Output        :
//******************************************************************************************
void InitUART(void)
{
// **************************
// (1)Define U1MODE
// **************************
    U1MODEbits.UARTEN = 0;        // Bit15 TX, RX DISABLED, ENABLE at end of func
    U1MODEbits.USIDL = 0;         // Bit13 Continue in Idle
    U1MODEbits.IREN = 0;          // Bit12 No IR translation
    U1MODEbits.RTSMD = 0;         // Bit11 Simplex Mode
    U1MODEbits.UEN0 = 0;          // Bits8,9 TX,RX enabled, CTS,RTS not
    U1MODEbits.UEN1 = 0; 
    U1MODEbits.WAKE = 0;          // Bit7 No Wake up (since we don't sleep here)
    U1MODEbits.LPBACK = 0;        // Bit6 No Loop Back
    U1MODEbits.ABAUD = 0;         // Bit5 No Autobaud (would require sending '55')
//  U1MODEbits.RXINV = 0;         // Bit4 IdleState = 1
    U1MODEbits.URXINV = 0; 
    U1MODEbits.BRGH = 0;          // Bit3 16 clocks per bit period
    U1MODEbits.PDSEL1 = 0;        // Bits1,2 8bit, No Parity
    U1MODEbits.PDSEL0 = 0; 
    U1MODEbits.STSEL = 0;         // Bit0 One Stop Bit


// **************************
// (2)Define U1BRG (16Bit;U1BRGL+U1BRGH)
//     BAUDRATE(Register)=SYSCLK/32/BAUDRATE-1
// **************************
//  U1BRG = 25;         // BAUDRATE = 8MHz/32/9600-1     = 0d25  ※9600BPS(8MHz)
//  U1BRG = 23;         // BAUDRATE = 7.37MHz/32/9600-1  = 0d23  ※9600BPS(7.37MHz)
//  U1BRG = 257;        // BAUDRATE = 79.23MHz/32/9600-1 = 0d257 ※9600BPS(79.23MHz)
    U1BRG = 259;        // BAUDRATE = 80MHz/32/9600-1    = 0d259 ※9600BPS(80MHz)

// **************************
// (3)Define U1STA
// **************************
    U1STAbits.UTXISEL1 = 0;       //Bit15 Int when Char is transferred (1/2 config!)
    U1STAbits.UTXINV = 0;         //Bit14 N/A, IRDA config
    U1STAbits.UTXISEL0 = 0;       //Bit13 Other half of Bit15
    U1STAbits.UTXBRK = 0;         //Bit11 Disabled
    U1STAbits.UTXEN = 0;          //Bit10 TX pins controlled by periph
    U1STAbits.UTXBF = 0;          //Bit9 *Read Only Bit*
    U1STAbits.TRMT = 0;           //Bit8 *Read Only bit*
    U1STAbits.URXISEL0 = 0;       //Bits6,7 Int. on character recieved
    U1STAbits.URXISEL1 = 0; 
    U1STAbits.ADDEN = 0;          //Bit5 Address Detect Disabled
    U1STAbits.RIDLE = 0;          //Bit4 *Read Only Bit*
    U1STAbits.PERR = 0;           //Bit3 *Read Only Bit*
    U1STAbits.FERR = 0;           //Bit2 *Read Only Bit*
    U1STAbits.OERR = 0;           //Bit1 *Read Only Bit*
    U1STAbits.URXDA = 0;          //Bit0 *Read Only Bit*

    U1MODEbits.UARTEN = 1;        // And turn the peripheral on

    U1STAbits.UTXEN = 1;

}

//******************************************************************************************
//   Function Name : SendUART
//   Title         : Send UART
//   Input         :
//   Output        :
//******************************************************************************************
void SendUART(char in_c)
{
    while(U1STAbits.UTXBF != 0);
    U1TXREG = in_c;
}

//******************************************************************************************
//   Function Name : RecUART
//   Title         : Recive UART
//   Input         :
//   Output        :
//******************************************************************************************
void RecUART(char *out_c)
{
    while(U1STAbits.URXDA == 0);
    *out_c = U1RXREG;
}

//******************************************************************************************
//   Function Name : Timer
//   Title         : wait function
//   Input         : Count value (100mS)
//   Output        :
//   Description   : Internal OSC
//******************************************************************************************
void Timer(unsigned int S01)
{
unsigned int lp;
// ***********************************************
// 1.Define T2CON Register
// ***********************************************
//  T2CON = 0b1000000000100000;  //  1/64,16Bit 
    T2CON = 0b1000000000110000;  //  1/256,16Bit 

// ***********************************************
// 2.Set PR2-Register
// ***********************************************
//  PR2 = 0x186A;  // 10Hz  (0x186a;0d6250)   //FRC    8MHz     8MHz/2/64/10
//  PR2 = 0x167D;  // 10Hz  (0x167D;0d5758)   //FRC    7.37MHz  7.37MHz/2/64/10
//  PR2 = 0x3C72;  // 10Hz  (0x3C72;0d15474)  //FRC    79.23MHz 79.23MHz/2/256/10
    PR2 = 0x3D09;  // 10Hz  (0x3D09;0d15625)  //FRC    80MHz    80MHz/2/256/10

// ***********************************************
// 3.Timer
// ***********************************************
    TMR2 = 0; 

    for(lp=0;lp<S01;lp++){  
        IFS0bits.T2IF = 0;
        while(1){
            if(IFS0bits.T2IF != 0 )break;   //See Manual P.25 (T2IF)
        }
    }
}


//******************************************************************************************
//   Function Name : InitADC
//   Title         : Initialize A/D Converter
//   Input         :
//   Output        :
//******************************************************************************************
void InitADC(void)
{
// *******************************
// 1. Configure the A/D module
// *******************************
// a) Select port pins as analog inputs(AD1PCFG<15:0>)
    AD1PCFGLbits.PCFG0  = 0; //PCFG(15-0) 1:Digital mode, 0:Analog mode
    AD1PCFGLbits.PCFG1  = 1; 
    AD1PCFGLbits.PCFG2  = 1; 
    AD1PCFGLbits.PCFG3  = 1; 
    AD1PCFGLbits.PCFG4  = 1;
    AD1PCFGLbits.PCFG5  = 1; 
    AD1PCFGLbits.PCFG6  = 1; 
    AD1PCFGLbits.PCFG7  = 1; 
    AD1PCFGLbits.PCFG8  = 1; 
    AD1PCFGLbits.PCFG9  = 1;
    AD1PCFGLbits.PCFG10 = 1; 
    AD1PCFGLbits.PCFG11 = 1; 
    AD1PCFGLbits.PCFG12 = 1; 
    AD1PCFGLbits.PCFG13 = 1; 
    AD1PCFGLbits.PCFG14 = 1; 
    AD1PCFGLbits.PCFG15 = 1; 
//
    AD1CHS0bits.CH0SA0  = 0; //Channel 0 positive input is AN0
    AD1CHS0bits.CH0SA1  = 0; //Channel 0 positive input is AN0
    AD1CHS0bits.CH0SA2  = 0; //Channel 0 positive input is AN0
    AD1CHS0bits.CH0SA3  = 0; //Channel 0 positive input is AN0
//
    AD1CHS0bits.CH0NB   = 0; //Channel 0 negative input is VREF
//
    AD1CHS123bits.CH123NA0 = 0; //CH1, CH2, CH3 negative input is VREF-
    AD1CHS123bits.CH123NA1 = 0; //CH1, CH2, CH3 negative input is VREF-
    AD1CHS123bits.CH123SA  = 0; //0 = CH1 positive input is AN0, CH2 positive input is AN1, CH3 positive input is AN2
//
    AD1CSSH = 0x00;        //ADC1 PORT CONFIGURATION REGISTER HIGH
    AD1CSSL = 0x01;        //ADC1 PORT CONFIGURATION REGISTER LOW

// b) Select voltage reference source to match expected range on analog inputs(AD1CON2<15:13>)
    AD1CON2bits.VCFG = 0;  //VR+:AVDD , VR-:AVSS 

// c) Select the analog conversion clock to match desired data rate with processor clock (AD1CON3<7:0>)
    AD1CON3bits.ADCS = 0;  //TCY/2

// d) Select the appropriate sample/conversion sequence (AD1CON1<7:5> and AD1CON3<12:8>)
    AD1CON1bits.SSRC = 0x7;//Internal counter ends sampling and starts conversion (auto-convert)
    AD1CON3bits.SAMC = 31;  //31 TAD
    AD1CON3bits.ADCS = 0b111111;  //ADC Conversion Clock Select bits (TCY (ADCS<7:0> + 1) = 64 TCY = TAD)

// e) Select how conversion results are presented in the buffer (AD1CON1<9:8>)
    AD1CON1bits.FORM = 0;  //Integer (0000 00dd dddd dddd)

// e) 10-bit or 12-bit Operation Mode bit (AD1CON1<10>)
    AD1CON1bits.AD12B = 1; //1 = 12-bit, 1-channel ADC operation
//  AD1CON1bits.AD12B = 0; //0 = 10-bit, 4-channel ADC operation

// f) Select interrupt rate (AD1CON2<5:2>)
    AD1CON2bits.SMPI = 0;  //Interrupts at the completion of conversion for each sample/convert sequence

// g) Turn on A/D module (AD1CON1<15>)
    AD1CON1bits.ADON = 1;  // Turn on the A/D converter

// *******************************
// 2. Configure A/D interrupt (if required)
// *******************************
// a) Clear the AD1IF bit
//  IFS0bits.AD1IF = 0;   // Clear the A/D interrupt flag bit

// b) Select A/D interrupt priority
//  IEC0bits.AD1IE = 1;   // Enable A/D interrupt 
}

//******************************************************************************************
//   Function Name : GetADC
//   Title         : Get A/D Converter Value
//   Input         :
//   Output        :
//******************************************************************************************
void GetADC(int *dat)
{
    AD1CON1bits.SAMP=1;
    IFS0bits.AD1IF = 0;

    while(IFS0bits.AD1IF==0);
    *dat = (unsigned int)ADC1BUF0;
}