//******************************************************************************************
//  PIC18F14K50 Sample Program (Capacity mater)
//   Project      :
//   Program Name :
//   Programer    :
//   Create date  :  Version 1.0    H24.02.08
//   Replace date :
//   History      :
//   Laungage     :  MPLAB C18 
//******************************************************************************************
//   Description
//    (1)OSC    48MHz (12MHz Crystal * PLL4)
//    (2)I/O PORT  
//         PORTC(0)    :  DCM16117A(E)
//         PORTC(1)    :  DCM16117A(RS)
//         PORTC(7-4)  :  DCM16117A(DB7-4)
//
//         PORTB(4)    :  Push Switch
//         PORTB(6)    :  Supply Senser Singnal
//         PORTC(2)AN6 :  Senser Output
//
//******************************************************************************************
#include	<p18f14k50.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 CPUDIV=NOCLKDIV //CPU System Clock Selection bit(No CPU System Clock divide)
#pragma config USBDIV = OFF //USB Clock Selection bit(USB Clock comes directly from the OSC1/OSC2 oscillator block; no divide)
#pragma config FOSC = HS //Oscillator Selection bits(HS oscillator)
#pragma config PLLEN = ON //X PLL Enable bit(Oscillator multiplied by 4)
#pragma config PCLKEN = OFF //Primary Clock Enable Bit(Primary clock is under software control)
#pragma config FCMEN = OFF
#pragma config IESO = OFF //Internal/External Oscillator Switchover bit(Oscillator Switchover mode disabled)
#pragma config PWRTEN = OFF,BOREN = OFF,BORV = 19
#pragma config WDTEN = OFF,WDTPS = 1
#pragma config MCLRE = OFF //MCLR Pin Enable bit(RE3 input pin enabled; MCLR disabled)
#pragma config HFOFST = OFF,STVREN = OFF,LVP = OFF,BBSIZ = OFF,XINST = OFF
#pragma config CP0 = OFF,CP1 = OFF,CPB = OFF,CPD = OFF,WRT0 = OFF,WRT1 = OFF,WRTB = OFF,WRTC = OFF,WRTD = OFF,EBTR0 = OFF,EBTR1 = OFF,EBTRB = OFF
//
//Define function
//
#define   LCD_E         0
#define   LCD_RS        1
#define   LCD_DB4       4
#define   LCD_DB5       5
#define   LCD_DB6       6
#define   LCD_DB7       7
#define   TERM_0        0
#define   TERM_1        1
#define   TERM_2        2
#define   TERM_CAP_SIG  6
#define   TERM_CAP_SNS  2
#define   TERM_CHK_SW   4
#define   PI_NORMAL     0
#define   PI_FAILURE    1
#define   PI_OVER       2
#define   PI_POS0       0
#define   PI_POS1       1
#define   PI_POSN       2
#define   PI_L          0
#define   PI_H          1
//
#define   PI_1KHZ       1
#define   PI_10KHZ      2
#define   PI_100KHZ     3
//
//#define PI_CHECK_LOOP    20
#define   PI_CHECK_LOOP    10
#define   PI_CHECK_DEFCAP  300
#define   PI_CHECK_MINCNT  10
//
//
//Define function
//
void Demo01(void);
void Demo02(void);
void Demo03(void);
void Demo04(unsigned int, unsigned int);
void Init_POS0(void);
void Init_POS1(void);
void Init_LCD(void);
void LCD_Disp(unsigned char);
void LCD_CLR(void);
void LCD_SETH(unsigned char);
void LCD_SETL(unsigned char);
void BCF(unsigned int);
void BSF(unsigned int);
void TERM_BCF(unsigned int);
void TERM_BSF(unsigned int);
void mnop(unsigned int);
void Int_Timer1(void);
void Timer0(unsigned char);
void Timer3(void);
void Wait_1mS(unsigned int);
void Wait_1mS3(unsigned int);
void Init_ADC(void);
void IntFVR(void);
void GetADC(unsigned int *);
void LCD_Disp_S(unsigned char *, unsigned char);
void Chk_data_ave(unsigned int *, unsigned char);
void Chk_data(unsigned int *, unsigned char);
void Dsp_data(unsigned int);
void Sel_range(unsigned char *, unsigned int *);
void isr (void);

volatile unsigned int       G_int_counter=0; 
volatile unsigned char      G_over_flg=PI_NORMAL;     
volatile unsigned char      G_f_mode=PI_100KHZ;   
volatile unsigned char      G_wave_status = PI_L;  

void main(void)
{
    unsigned int       adc_data=0; 
    int                adc_data_s=0; 
    unsigned int       max_capa_data=0; 
    unsigned int       min_capa_data=0; 
    unsigned int       ref_capa_data=0; 
    unsigned int       cap_data=0; 
    long               l_tmp1;  // -2,147,483,648 <= LONG(32bit) <= 2,147,483,647
    double             df_tmp1;
    double             df_tmp2;
    unsigned char      f_mode;

// *************************************
//   1.Initialize Segment
// *************************************
// (1)Define I/O port
    PORTA = 0b00000000;
    PORTB = 0b00000000;
    PORTC = 0b00000000;

    TRISA = 0b11111111;
    TRISB = 0b10111111;
    TRISC = 0b00001100;

// (2)Select A/D Converter
    ANSEL  = 0b00000000;  //ALL Degital PORT
    ANSELH = 0b00000000;  //ALL Degital PORT

// (3)Initialized LCD
    Init_LCD();

// (4)Initialized Fixed Voltage Reference
    IntFVR();

// (5)Initialized A/D Converter
    Init_ADC();

// (6)Initialized Timer
    Int_Timer1();

// *************************************
//   2.Program Main
// *************************************
    while(1){
// **************
//  A.Initialize
// **************
// (1)Demo Message(Start Message)
//      Demo01();

// (2)Select range and reference capacity
        Sel_range(&f_mode, &max_capa_data);

// (3)Set default value 
//  2-1)no capacity
        Wait_1mS(4000);
        Chk_data_ave(&min_capa_data,f_mode);
        ref_capa_data = max_capa_data - min_capa_data ;
        Demo04(min_capa_data, max_capa_data);
        Wait_1mS(500);

// **************
//  B.Program loop
// **************
// (1)Get data
        while(1){
            G_over_flg=PI_NORMAL;
            Chk_data_ave(&adc_data, f_mode);

// (2)Compute
            adc_data_s = adc_data - min_capa_data ; 
            if(adc_data_s<0) adc_data_s=0 ;//
            df_tmp1 = (double)adc_data_s ;
            if(f_mode == PI_100KHZ) df_tmp2 = df_tmp1 / (double)ref_capa_data * 100;
            else if(f_mode == PI_10KHZ) df_tmp2 = df_tmp1 / (double)ref_capa_data * 1000;
            else if(f_mode == PI_1KHZ)  df_tmp2 = df_tmp1 / (double)ref_capa_data * 10000;
            else df_tmp2 = 0;
            adc_data = (unsigned int)df_tmp2;

// (3)Output 
            Dsp_data(adc_data);

// (4)Wait 
            Wait_1mS(2000);

// (5)Check Switch 
            if((PORTB & 0b00010000)==0)break;
        }
    }
}

//******************************************************************************************
//   Function name : Demo01
//   Title         : 
//   Input         :
//   Output        :
//******************************************************************************************
void Demo01(void)
{
    unsigned char msg[9];

//  (1)Start message

    strcpypgm2ram(msg," Start 1");
    LCD_Disp_S(msg,PI_POS0);
    strcpypgm2ram(msg,"8F14K50 ");
    LCD_Disp_S(msg,PI_POS1);


}


//******************************************************************************************
//   Function name : Demo02
//   Title         : 
//   Input         :
//   Output        :
//******************************************************************************************
void Demo02(void)
{
    unsigned char msg[9];

//  (1)Message
    strcpypgm2ram(msg,"Push 100");
    LCD_Disp_S(msg,PI_POS0);

    strcpypgm2ram(msg,"00pF KEY");
    LCD_Disp_S(msg,PI_POS1);

//  (2)Wait
    Wait_1mS(500);
}


//******************************************************************************************
//   Function name : Demo03
//   Title         : 
//   Input         :
//   Output        :
//******************************************************************************************
void Demo03(void)
{
   unsigned char msg[9];

//  (1)Message
    strcpypgm2ram(msg,"Start Ca");
    LCD_Disp_S(msg,PI_POS0);
    strcpypgm2ram(msg,"pa meter");
    LCD_Disp_S(msg,PI_POS1);


//  (2)Wait
    Wait_1mS(500);

}

//******************************************************************************************
//   Function name : Demo04
//   Title         : 
//   Input         :
//   Output        :
//******************************************************************************************
void Demo04(unsigned int min_d, unsigned int max_d)
{
    unsigned char tmp_line[9];

//  (1)Message
    LCD_CLR();

    sprintf(tmp_line, "%d",min_d);
    LCD_Disp_S(tmp_line,PI_POS0);

    sprintf(tmp_line, "%d",max_d);
    LCD_Disp_S(tmp_line,PI_POS1);

//  (2)Wait
    Wait_1mS(500);

}

//******************************************************************************************
//   Function name : Sel_range
//   Title         : Select range (100pF/1000pF/10000pF)
//   Input         :
//   Output        :
//   Description   :   
//******************************************************************************************
void Sel_range(unsigned char *f_mode, unsigned int *adc_data)
{
    unsigned char msg[9];
    unsigned char msg1[9];
    unsigned int  tmp_adc_data; 

//  (1)Initialize
    *f_mode = PI_100KHZ ;

//  (2)Start Program
    while(1){
        LCD_CLR();
        if(*f_mode == PI_100KHZ){
            strcpypgm2ram(msg,"  100pF ");
            LCD_Disp_S(msg,PI_POS0);
        }else if(*f_mode == PI_10KHZ){
            strcpypgm2ram(msg," 1000pF ");
            LCD_Disp_S(msg,PI_POS0);
        }else{
            strcpypgm2ram(msg,"10000pF ");
            LCD_Disp_S(msg,PI_POS0);
        }
        LCD_Disp_S(msg,PI_POS0);
        strcpypgm2ram(msg,"range ? ");
        LCD_Disp_S(msg,PI_POS1);

        while(1){
            Chk_data_ave(&tmp_adc_data, PI_100KHZ);
            if(tmp_adc_data>PI_CHECK_DEFCAP){
                G_f_mode = *f_mode ;
                Wait_1mS(500);
                Chk_data_ave(adc_data, *f_mode);

                strcpypgm2ram(msg,"Selected");
                LCD_Disp_S(msg,PI_POS0);
                switch(*f_mode){
                    case PI_100KHZ :  
                          strcpypgm2ram(msg," 100pF  ");
                          break;
                    case PI_10KHZ : 
                          strcpypgm2ram(msg," 1000pF ");
                          break;
                    default:
                          strcpypgm2ram(msg," 10000pF");
                }
                LCD_Disp_S(msg,PI_POS1);
                while(1){
                    Chk_data_ave(&tmp_adc_data, *f_mode);
                    if(tmp_adc_data < PI_CHECK_DEFCAP) {
                        return;
                    }
                }                
            }

            if((PORTB & 0b00010000)==0){
                switch(*f_mode){
                    case PI_100KHZ : 
                          *f_mode = PI_10KHZ;
                          break;
                    case PI_10KHZ : 
                          *f_mode = PI_1KHZ;
                          break;
                    default:
                          *f_mode = PI_100KHZ;
                }
                break;
            }
        }
    Wait_1mS(500);
    }
}

//******************************************************************************************
//   Function name : Chk_data
//   Title         : Check adc data
//   Input         :
//   Output        :
//   Description   :   
//******************************************************************************************
void Chk_data(unsigned int *res_data, unsigned char f_mode)
{
//  1.Set frequency
    G_f_mode=f_mode;

//  2.Wait
    Wait_1mS(100);

//  3.Get adc_data
    GetADC(res_data);
    if(*res_data==1023)G_over_flg=PI_OVER;
}

//******************************************************************************************
//   Function name : Chk_data_ave
//   Title         : Check adc data average
//   Input         :
//   Output        :
//   Description   :   
//******************************************************************************************
void Chk_data_ave(unsigned int *res_data, unsigned char f_mode)
{
    unsigned char lp;
    unsigned int s_adc_data;
    unsigned int adc_data;

//  1.Set frequency
    G_f_mode=f_mode;

//  2.Wait
    Wait_1mS(100);

//  3.Get adc_data
    s_adc_data = 0;
    for(lp=0;lp<PI_CHECK_LOOP;lp++){
        GetADC(&adc_data);
        if(adc_data==1023)G_over_flg=PI_OVER;
        s_adc_data = s_adc_data + adc_data ;
    }
    *res_data = s_adc_data / PI_CHECK_LOOP;
}

//******************************************************************************************
//   Function name : Dsp_data
//   Title         : 
//   Input         :
//   Output        :
//******************************************************************************************
void Dsp_data(unsigned int adc_data)
{

    unsigned char tmp_line[20];

// 1.Clear display
    LCD_CLR();

// 2.Put data
    if(adc_data==32767)adc_data=0;
    if(G_over_flg==PI_OVER){
        G_over_flg=PI_NORMAL;
        strcpypgm2ram(tmp_line,"********");
    }else if(adc_data>10000){
        strcpypgm2ram(tmp_line,"********");
    }else{
        sprintf(tmp_line, "%d",adc_data);
    }
    LCD_Disp_S(tmp_line,PI_POS0);

// 3.Put message
    strcpypgm2ram(tmp_line," [pF]   ");
    LCD_Disp_S(tmp_line,PI_POS1);

}

//******************************************************************************************
//   Function Name : Init_ADC
//   Title         : 
//   Input         : 
//   Output        :
//   Description   :  Analog Channel Select (RC2:AN6)
//******************************************************************************************
void Init_ADC(void)
{
// *******************************************************
// 0.Define ANSEL(ANALOG SELECT REGISTER) and ANSELH(ANALOG SELECT REGISTER 2) 
//   ANSEL[7] ANS7: RC3 Analog Select Control bit
//       1 = Digital input buffer of RC3 is disabled
//       0 = Digital input buffer of RC3 is enabled
//   ANSEL[6] ANS6: RC2 Analog Select Control bit
//       1 = Digital input buffer of RC2 is disabled
//       0 = Digital input buffer of RC2 is enabled
//   ANSEL[5] ANS5: RC1 Analog Select Control bit
//       1 = Digital input buffer of RC1 is disabled
//       0 = Digital input buffer of RC1 is enabled
//   ANSEL[4] ANS4: RC0 Analog Select Control bit
//       1 = Digital input buffer of RC0 is disabled
//       0 = Digital input buffer of RC0 is enabled
//   ANSEL[3] ANS3: RA4 Analog Select Control bit
//       1 = Digital input buffer of RA4 is disabled
//       0 = Digital input buffer of RA4 is enabled
//   ANSEL[2-0] Unimplemented: Read as ‘0’
//
//   ANSELH[7-4] Unimplemented: Read as ‘0’
//   ANSELH[3] ANS11: RB5 Analog Select Control bit
//       1 = Digital input buffer of RB5 is disabled
//       0 = Digital input buffer of RB5 is enabled
//   ANSELH[2] ANS10: RB4 Analog Select Control bit
//       1 = Digital input buffer of RB4 is disabled
//       0 = Digital input buffer of RB4 is enabled
//   ANSELH[1] ANS9: RC7 Analog Select Control bit
//       1 = Digital input buffer of RC7 is disabled
//       0 = Digital input buffer of RC7 is enabled
//   ANSELH[0] ANS8: RC6 Analog Select Control bit
//       1 = Digital input buffer of RC6 is disabled
//       0 = Digital input buffer of RC6 is enabled
// *******************************************************
    ANSEL  = 0b01000000;  //Select ANS6
    ANSELH = 0b00000000; 

// *******************************************************
// 1.Define ADCON0(A/D CONTROL REGISTER 0) Register  
//     ADCON0(7-6) Unimplemented: Read as ‘0’
//     ADCON0(5-2) CHS<3:0>: Analog Channel Select bits
//         0000 = Reserved
//         0001 = Reserved
//         0010 = Reserved
//         0011 = AN3
//         0100 = AN4
//         0101 = AN5
//         0110 = AN6
//         0111 = AN7
//         1000 = AN8
//         1001 = AN9
//         1010 = AN10
//         1011 = AN11
//         1100 = Reserved
//         1101 = Reserved
//         1110 = DAC
//         1111 = FVR
//     ADCON0(1) GO/DONE: A/D Conversion Status bit
//         1 = A/D conversion cycle in progress. Setting this bit starts an A/D conversion cycle.
//             This bit is automatically cleared by hardware when the A/D conversion has completed.
//         0 = A/D conversion completed/not in progress
//     ADCON0(0) ADON: ADC Enable bit
//         1 = ADC is enabled
//         0 = ADC is disabled and consumes no operating current
// ******************************************************* 

    ADCON0 = 0b00011001;     //Select AN6


// *******************************************************
// 2.Define ADCON1(A/D CONTROL REGISTER 1) Register  
//     ADCON1(7-4) Unimplemented: Read as ‘0’
//     ADCON1(3-2) PVCFG<1:0>: Positive Voltage Reference select bit
//        00 = Positive voltage reference supplied internally by VDD.
//        01 = Positive voltage reference supplied externally through VREF+ pin.
//        10 = Positive voltage reference supplied internally through FVR.
//        11 = Reserved.
//     ADCON1(1-0) NVCFG<1:0>: Negative Voltage Reference select bit
//        00 = Positive voltage reference supplied internally by VSS.
//        01 = Positive voltage reference supplied externally through VREF- pin.
//        10 = Reserved.
//        11 = Reserved.
// *******************************************************

    ADCON1 = 0b00001000;


// *******************************************************
// 3.Define ADCON2(A/D CONTROL REGISTER 2) Register  
//      ADCON2(7) ADFM: A/D Conversion Result Format Select bit
//          1 = Right justified
//          0 = Left justified
//      ADCON2(6) Unimplemented: Read as ‘0’
//      ADCON2(5-3) ACQT<2:0>: A/D Acquisition time select bits. Acquisition time is the duration that the A/D charge
//                   holding capacitor remains connected to A/D channel from the instant the GO/DONE bit is set until
//                   conversions begins.
//          000 = 0(1)
//          001 = 2 TAD
//          010 = 4 TAD
//          011 = 6 TAD
//          100 = 8 TAD
//          101 = 12 TAD
//          110 = 16 TAD
//          111 = 20 TAD
//      ADCON2(2-0) ADCS<2:0>: A/D Conversion Clock Select bits
//          000 = FOSC/2
//          001 = FOSC/8
//          010 = FOSC/32
//          011 = FRC(1) (clock derived from a dedicated internal oscillator = 600 kHz nominal)
//          100 = FOSC/4
//          101 = FOSC/16
//          110 = FOSC/64
//          111 = FRC(1) (clock derived from a dedicated internal oscillator = 600 kHz nominal)
// *******************************************************
    
//  ADCON2 = 0b10111110;
//  ADCON2 = 0b10001000;
    ADCON2 = 0b10111110;
}

//******************************************************************************************
//   Function Name : IntFVR
//   Title         : Initialized Fixed Voltage Reference 
//   Input         :
//   Output        :
//******************************************************************************************
void IntFVR(void)
{
// *******************************************************
// 1.Define REFCON0(REFERENCE CONTROL REGISTER 0)
//     REFCON0(7) FVR1EN: Fixed Voltage Reference 1 Enable bit
//       0 = FVR is disabled
//       1 = FVR is enabled    !!! FVR ; 1.024V Fixed Reference Voltage 
//     REFCON0(6) FVR1ST: Fixed Voltage Reference 1 Stable bit
//       0 = FVR is not stable
//       1 = FVR is stable
//     REFCON0(5-4) FVR1S<1:0>: Fixed Voltage Reference 1 Voltage Select bits
//       00 = Reserved, do not use
//       01 = 1.024V (x1)
//       10 = 2.048V (x2)
//       11 = 4.096V (x4)
//     REFCON0(bit 3-0)
//       Unimplemented: Read as ‘0’
// *******************************************************

    REFCON0 = 0b11100000;

}

//******************************************************************************************
//   Function Name : GetADC
//   Title         : 
//   Input         : 
//   Output        :
//   Description   :
//******************************************************************************************
void GetADC(unsigned int *adc_data)
{
    unsigned char Dat_L,Dat_H;


// *****************
//  1.Start ADC
// *****************
//   GO/DONE: A/D Conversion Status bit
    ADCON0 = ADCON0 | 0b00000010;

// *****************
//  2.Get data 
// *****************
    while((ADCON0 & 0b00000010)!=0);
    Dat_H = ADRESH;
    Dat_L = ADRESL;

// *****************
//  3.Edit data
// *****************
    *adc_data = (unsigned int)Dat_H * (unsigned int)256 + (unsigned int)Dat_L;


}

//******************************************************************************************
//   Function name : LCD_Disp_S
//   Title         : 
//   Input         :
//   Output        :
//******************************************************************************************
void LCD_Disp_S(unsigned char in_str[], unsigned char flg)
{
    unsigned int lp;
    unsigned int no;

    if(flg == PI_POS0){
        Init_POS0();
    }else if(flg == PI_POS1){
        Init_POS1();
    }


    no=strlen(in_str);
    for(lp=0;lp<no;lp++){
        LCD_Disp(in_str[lp]);
    }
}

//******************************************************************************************
//   Function name : Init_POS0
//   Title         : LCDの1〜8に書き込む
//   Input         :
//   Output        :
//******************************************************************************************
void Init_POS0(void)
{
    LCD_SETH(0b10000000);  //PORTB = 0b10000000;
    BCF(LCD_RS);           //RS
    BSF(LCD_E );           //Enable-Signal
    mnop(10);
    BCF(LCD_E);            //Enable-Signal	
    Wait_1mS(10);

    LCD_SETH(0b00000000);  //PORTB = 0b00000000;
    BCF(LCD_RS);           //RS
    BSF(LCD_E );           //Enable-Signal
    mnop(10);
    BCF(LCD_E);            //Enable-Signal	
    Wait_1mS(10);
}

//******************************************************************************************
//   Function name : Init_POS1
//   Title         : LCDの9〜16に書き込む
//   Input         :
//   Output        :
//******************************************************************************************
void Init_POS1(void)
{
    LCD_SETH(0b11000000);  //PORTB = 0b11000000;
    BCF(LCD_RS);           //RS
    BSF(LCD_E );           //Enable-Signal
    mnop(10);
    BCF(LCD_E);            //Enable-Signal	
    Wait_1mS(10);


    LCD_SETH(0b00000000);  //PORTB = 0b00000000;
    BCF(LCD_RS);           //RS
    BSF(LCD_E );           //Enable-Signal
    mnop(10);
    BCF(LCD_E);            //Enable-Signal	
    Wait_1mS(10);
}

//******************************************************************************************
//   Function Name : Init_LCD
//   Title         : インストラクションによるLCDの初期化
//   Input         : 
//   Output        :
//******************************************************************************************
void Init_LCD(void)
{
// 1.ファンクションセット
// (1)15mS以上待つ
    Wait_1mS(100);

// (2)ファンクションセット(1); 	
    LCD_SETH(0b00110000); //PORTB = 0b00110000;
    BCF(LCD_RS);          //RS
    BSF(LCD_E );          //Enable-Signal
    mnop(10);
    BCF(LCD_E);           //Enable-Signal

// (3)4.1mS以上待つ
    Wait_1mS(10);

// (4)ファンクションセット(2)

    LCD_SETH(0b00110000); //PORTB = 0b00110000;
    BCF(LCD_RS);          //RS
    BSF(LCD_E );          //Enable-Signal
    mnop(10);
    BCF(LCD_E);           //Enable-Signa

// (5)100μS以上待つ
    Wait_1mS(10);

// (6)ファンクションセット(3)

    LCD_SETH(0b00110000); //PORTB = 0b00110000;
    BCF(LCD_RS);          //RS
    BSF(LCD_E );          //Enable-Signal
    mnop(10);
    BCF(LCD_E);           //Enable-Signa
    Wait_1mS(10);

// 2.表示設定
// 
// (1)ファンクションセット
    LCD_SETH(0b00100000); //PORTB = 0b00100000;
    BCF(LCD_RS);          //RS
    BSF(LCD_E );          //Enable-Signal
    mnop(10);
    BCF(LCD_E);           //Enable-Signa
    Wait_1mS(10);

    LCD_SETH(0b00100000); //PORTB = 0b00100000;
    BCF(LCD_RS);          //RS
    BSF(LCD_E );          //Enable-Signal
    mnop(10);
    BCF(LCD_E);           //Enable-Signa
    Wait_1mS(10);

    LCD_SETH(0b10000000); //PORTB = 0b10000000;
    BCF(LCD_RS);          //RS
    BSF(LCD_E );          //Enable-Signal
    mnop(10);
    BCF(LCD_E);           //Enable-Signa
    Wait_1mS(10);
// 
// (2)表示OFF

    LCD_SETH(0b00000000); //PORTB = 0b00000000;
    BCF(LCD_RS);          //RS
    BSF(LCD_E );          //Enable-Signal
    mnop(10);
    BCF(LCD_E);           //Enable-Signa
    Wait_1mS(10);

    LCD_SETH(0b10000000); //PORTB = 0b10000000;
    BCF(LCD_RS);          //RS
    BSF(LCD_E );          //Enable-Signal
    mnop(10);
    BCF(LCD_E);           //Enable-Signa
    Wait_1mS(10);
// 
// (3)表示クリア

    LCD_SETH(0b00000000); //PORTB = 0b00000000;
    BCF(LCD_RS);          //RS
    BSF(LCD_E );          //Enable-Signal
    mnop(10);
    BCF(LCD_E);           //Enable-Signa
    Wait_1mS(10);


    LCD_SETH(0b00010000); //PORTB = 0b00010000;
    BCF(LCD_RS);          //RS
    BSF(LCD_E );          //Enable-Signal
    mnop(10);
    BCF(LCD_E);           //Enable-Signa
    Wait_1mS(10);
// 
// (4)エントリーモードセット

    LCD_SETH(0b00000000); //PORTB = 0b00000000;
    BCF(LCD_RS);          //RS
    BSF(LCD_E );          //Enable-Signal
    mnop(10);
    BCF(LCD_E);           //Enable-Signa
    Wait_1mS(10);

    LCD_SETH(0b01100000); //PORTB = 0b01100000;
    BCF(LCD_RS);          //RS
    BSF(LCD_E );          //Enable-Signal
    mnop(10);
    BCF(LCD_E);           //Enable-Signa
    Wait_1mS(10);

// 
// (5)表示ON

    LCD_SETH(0b00000000); //PORTB = 0b00000000;
    BCF(LCD_RS);          //RS
    BSF(LCD_E );          //Enable-Signal
    mnop(10);
    BCF(LCD_E);           //Enable-Signa
    Wait_1mS(10);

    LCD_SETH(0b11000000); //PORTB = 0b11000000;
    BCF(LCD_RS);          //RS
    BSF(LCD_E );          //Enable-Signal
    mnop(10);
    BCF(LCD_E);           //Enable-Signa
    Wait_1mS(10);

// 
//
// (6)DD RAM アドレスセット

    LCD_SETH(0b10000000); //PORTB = 0b10000000;
    BCF(LCD_RS);          //RS
    BSF(LCD_E );          //Enable-Signal
    mnop(10);
    BCF(LCD_E);           //Enable-Signa
    Wait_1mS(10);

    LCD_SETH(0b00000000); //PORTB = 0b00000000;
    BCF(LCD_RS);          //RS
    BSF(LCD_E );          //Enable-Signal
    mnop(10);
    BCF(LCD_E);           //Enable-Signa
    Wait_1mS(10);
}


//******************************************************************************************
//   Function Name : LCD_Disp
//   Title         : LCDに文字を表示する
//   Input         : 
//   Output        :
//******************************************************************************************
void LCD_Disp(unsigned char in_char)
{
    unsigned char tmp_c;

    LCD_SETH(in_char);
    BSF(LCD_RS);       //RS
    mnop(10);          //48MHz mode Only
    BSF(LCD_E );       //Enable-Signal
    mnop(10);
    BCF(LCD_E);        //Enable-Signa
    mnop(10);          //48MHz mode Only
    BCF(LCD_RS);       //RS
    mnop(10);


    LCD_SETL(in_char);
    BSF(LCD_RS);       //RS
    mnop(10);          //48MHz mode Only
    BSF(LCD_E );       //Enable-Signal
    mnop(10);
    BCF(LCD_E);        //Enable-Signa
    mnop(10);          //48MHz mode Only
    BCF(LCD_RS);       //RS
    mnop(10);

    Wait_1mS(10);
}

//******************************************************************************************
//   Function Name : LCD_CLR
//   Title         : LCDの画面クリア
//   Input         : 
//   Output        :
//******************************************************************************************
void LCD_CLR(void)
{
    LCD_SETH(0b00000000); //PORTB = 0b00000000;
    BCF(LCD_RS);          //RS
    BSF(LCD_E );          //Enable-Signal
    mnop(10);
    BCF(LCD_E);           //Enable-Signa
    Wait_1mS(10);

    LCD_SETH(0b00010000); //PORTB = 0b00010000;
    BCF(LCD_RS);          //RS
    BSF(LCD_E );          //Enable-Signal
    mnop(10);
    BCF(LCD_E);           //Enable-Signa
    Wait_1mS(10);

}

//******************************************************************************************
//   Function Name : LCD_SETH
//   Title         : LCDのDB(7-4)にデータ設定
//   Input         : 
//   Output        :
//******************************************************************************************
void LCD_SETH(unsigned char tmp_data)
{
    PORTC = PORTC & 0b00001111;

    PORTC = PORTC | (tmp_data & 0b11110000);


}

//******************************************************************************************
//   Function Name : LCDDBH
//   Title         : LCDのDB(3-0)にデータ設定
//   Input         : 
//   Output        :
//******************************************************************************************
void LCD_SETL(unsigned char tmp_data)
{
    PORTC = PORTC & 0b00001111;

    PORTC = PORTC | ((tmp_data & 0b00001111) << 4);

}

//******************************************************************************************
//   Function Name : BCF
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
void BCF(unsigned int pos)
{
    PORTC = PORTC & ~(1 << pos);

}

//******************************************************************************************
//   Function Name : BSF
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
void BSF(unsigned int pos)
{
     PORTC = PORTC | (1 << pos);
}

//******************************************************************************************
//   Function Name : TERM_BCF
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
void TERM_BCF(unsigned int pos)
{
    PORTB = PORTB & ~(1 << pos);
}

//******************************************************************************************
//   Function Name : TERM_BSF
//   Title         : 
//   Input         : 
//   Output        : 
//******************************************************************************************
void TERM_BSF(unsigned int pos)
{
    PORTB = PORTB | (1 << pos);
}

//******************************************************************************************
//   Function Name : mnop
//   Title         : wait function
//   Input         : 
//   Output        : 
//******************************************************************************************
void mnop(unsigned int no)
{
    unsigned int lp;

    for(lp=0;lp<no;lp++){
        _asm
            NOP
        _endasm
    }
}

//******************************************************************************************
//   Function Name : Wait_1mS  ※Timer3
//   Title         : wait function
//   Input         : 
//   Output        : 
//******************************************************************************************
void Wait_1mS(unsigned int no)
{
    unsigned int lp;

    for(lp=0;lp<no;lp++){
        Timer3();
    }
}

//******************************************************************************************
//   Function Name : Timer0  ※Timer0 
//   Title         : 
//   Input         :
//   Output        :
//******************************************************************************************
void Timer0(unsigned char f_mode)
{
// *******************************************************
// 1.Define T0CON(TIMER0 CONTROL REGISTER) Register
//   T0CON(7) TMR0ON: Timer0 On/Off Control bit
//       1 = Enables Timer0
//       0 = Stops Timer0
//   T0CON(6) T08BIT: Timer0 8-bit/16-bit Control bit
//       1 = Timer0 is configured as an 8-bit timer/counter
//       0 = Timer0 is configured as a 16-bit timer/counter
//   T0CON(5) T0CS: Timer0 Clock Source Select bit
//       1 = Transition on T0CKI pin
//       0 = Internal instruction cycle clock (CLKO)
//   T0CON(4) T0SE: Timer0 Source Edge Select bit
//       1 = Increment on high-to-low transition on T0CKI pin
//       0 = Increment on low-to-high transition on T0CKI pin
//   T0CON(3) PSA: Timer0 Prescaler Assignment bit
//       1 = TImer0 prescaler is NOT assigned. Timer0 clock input bypasses prescaler.
//       0 = Timer0 prescaler is assigned. Timer0 clock input comes from prescaler output.
//   T0CON(2-0) T0PS2:T0PS0: Timer0 Prescaler Select bits
//       111 = 1:256 prescale value
//       110 = 1:128 prescale value
//       101 = 1:64 prescale value
//       100 = 1:32 prescale value
//       011 = 1:16 prescale value
//       010 = 1:8 prescale value
//       001 = 1:4 prescale value
//       000 = 1:2 prescale value
// *******************************************************
    T0CON = 0b10001000; //16bit 


// *******************************************************
// 2.Define TMR0 Register
// *******************************************************
//   TMR0 data ( OSC :12MHz, 4X PLLON, 1:1 Prescale value, 0.001[S];1000Hz )
//     1mS(1000Hz)   : 12MHz * 4(PLLON) / 4(PIC) / 1(Prescale) / 1000(1000Hz) ==> 0d12,000(Count) ==> 0x2EE0(Count)
//     TMR1 = 0xFFFF - 0x2EE0 ==> 0xD11F
//     0.05mS(20KHz) : 12MHz * 4(PLLON) / 4(PIC) / 1(Prescale) / 20000(20KHz) ==> 0d600(Count)    ==> 0x0258(Count)
//     TMR1 = 0xFFFF - 0x0258 ==> 0xFDA7
//     0.5mS(2KHz)   : 12MHz * 4(PLLON) / 4(PIC) / 1(Prescale) / 2000(2KHz)   ==> 0d6,000(Count)  ==> 0x1770(Count)
//     TMR1 = 0xFFFF - 0x1770 ==> 0xE88F
//   
    if(f_mode == PI_10KHZ){            // 10KHz
        TMR0H = 0xFD;
        TMR0L = 0xA0;
    }else if(f_mode == PI_1KHZ){       //  1KHz
        TMR0H = 0xE8;
        TMR0L = 0x85;
    }

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

}

//******************************************************************************************
//   Function Name : Int_Timer1  ※Timer1
//   Title         : 
//   Input         :
//   Output        :
//******************************************************************************************
void Int_Timer1(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(0) TMR1IF(TMR1 Overflow Interrupt Flag bit)
//          1 = Enables, 0 = Disables
    PIR1 = PIR1 | 0b00000001;

//  (3)Define PIE1(PERIPHERAL INTERRUPT ENABLE)Register
//       PIE1(0) TMR1IE(TMR1 Overflow Interrupt Enable bit)
//          1 = Enables, 0 = Disables
    PIE1 = PIE1 | 0b00000001;

//  (4)Define IPR1(PERIPHERAL INTERRUPT PRIORITY REGISTER 1)
//       IPR1(0) TMR1IP(TMR1 Overflow Interrupt Priority bit)
//           1 = High priority, 0 = Low priority
//  IPR1 = IPR1 | 0b00000001;
    IPR1 = IPR1 | 0b00000000;

// *******************************************************
// 2.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)  T1RUN: Timer1 System Clock Status bit
//                      1 = Main system clock is derived from Timer1 oscillator
//                      0 = Main system clock is derived from another source
//*   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)  TMR1ON: Timer1 On bit
//                      1 = Enables Timer1
//                      0 = Stops Timer1
// *******************************************************

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

// *******************************************************
// 3.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.
// *******************************************************
//     0.005mS(200KHz) : 12MHz * 4(PLLON) / 4(PIC) / 1(Prescale) / 200000(200KHz) ==> 0d60(Count)     ==> 0x003C(Count)
//     TMR1 = 0xFFFF - 0x003C ==> 0xFFC3
//     0.05mS(20KHz)   : 12MHz * 4(PLLON) / 4(PIC) / 1(Prescale) / 20000(20KHz)   ==> 0d600(Count)    ==> 0x0258(Count)
//     TMR1 = 0xFFFF - 0x0258 ==> 0xFDA7
//     0.5mS(2KHz)     : 12MHz * 4(PLLON) / 4(PIC) / 1(Prescale) / 2000(2KHz)     ==> 0d6,000(Count)  ==> 0x1770(Count)
//     TMR1 = 0xFFFF - 0x1770 ==> 0xE88F
//   
#define  PII_1KHZ_H       0xE8
#define  PII_1KHZ_L       0xB0    //Adjust
#define  PII_10KHZ_H      0xFD
#define  PII_10KHZ_L      0xC5    //Adjust
#define  PII_100KHZ_H     0xFF
#define  PII_100KHZ_L     0xDC    //Adjust

    if(G_f_mode == PI_100KHZ){           //100KHz
        TMR1H = PII_100KHZ_H;
        TMR1L = PII_100KHZ_L;
    }else if(G_f_mode == PI_10KHZ){      // 10KHz
        TMR1H = PII_10KHZ_H;
        TMR1L = PII_10KHZ_L;
    }else if(G_f_mode == PI_1KHZ){       //  1KHz
        TMR1H = PII_1KHZ_H;
        TMR1L = PII_1KHZ_L;
    }
}

//******************************************************************************************
//   Function Name : Timer3   ※Timer3 (OK)
//   Title         : Wait 1[mS]
//   Input         :
//   Output        :
//******************************************************************************************
void Timer3(void)
{
// *******************************************************
// 1.Define T3CON(TIMER3 CONTROL REGISTER) Register
//   T3CON(7)  RD16: 16-bit Read/Write Mode Enable bit
//       1 = Enables register Read/Write of Timer3 in one 16-bit operation
//       0 = Enables register Read/Write of Timer3 in two 8-bit operations
//   T3CON(6) Unimplemented: Read as ‘0’
//   T3CON(5-4) T3CKPS1:T3CKPS0: Timer3 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
//   T3CON(3) T3CCP1: Timer3 and Timer1 to CCP1 Enable bits
//       1 = Timer3 is the clock source for compare/capture of ECCP1
//       0 = Timer1 is the clock source for compare/capture of ECCP1
//   T3CON(2) T3SYNC: Timer3 External Clock Input Synchronization Control bit
//            (Not usable if the system clock comes from Timer1/Timer3)
//       When TMR3CS = 1:
//            1 = Do not synchronize external clock input
//            0 = Synchronize external clock input
//       When TMR3CS = 0:
//            This bit is ignored. Timer3 uses the internal clock when TMR3CS = 0.
//   T3CON(1) TMR3CS: Timer3 Clock Source Select bit
//       1 = External clock input from Timer1 oscillator or T1CKI
//          (on the rising edge after the first falling edge)
//       0 = Internal clock (FOSC/4)
//   T3CON(0) TMR3ON: Timer3 On bit
//       1 = Enables Timer3
//       0 = Stops Timer3
// *******************************************************

    T3CON = 0b10000001; //16bit 


// *******************************************************
// 2.Define TMR3 Register
// *******************************************************
//   TMR3 data ( OSC:12MHz, 4X PLLON, 1:1 Prescale value, 0.001[S];1000Hz )
//     1mS(1000Hz): 12MHz * 4(PLLON) / 4(PIC) / 1(Prescale) / 1000(1000Hz)==> 0d12,000(Count) ==> 0x2EE0(Count)
//     TMR1 = 0xFFFF - 0x2EE0 ==> 0xD11F
//  
    TMR3H = 0xD1;
    TMR3L = 0x1F;

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

}

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

// *******************
// 1.Reset Timer
// *******************

    PIR1bits.TMR1IF = 0;

    if(G_f_mode == PI_100KHZ){           //100KHz
        TMR1H = PII_100KHZ_H;
        TMR1L = PII_100KHZ_L;
    }else if(G_f_mode == PI_10KHZ){      // 10KHz
        TMR1H = PII_10KHZ_H;
        TMR1L = PII_10KHZ_L;
    }else if(G_f_mode == PI_1KHZ){       //  1KHz
        TMR1H = PII_1KHZ_H;
        TMR1L = PII_1KHZ_L;
    }

// *******************
// 2.Make Wave
// *******************
    if(G_wave_status == PI_L){
        PORTB = 0b01000000;
        G_wave_status = PI_H;
    }else{
        PORTB = 0b00000000;
        G_wave_status = PI_L;
    }
}