//******************************************************************************************
//  PIC18F4520 Sample Program
//   Project      :  RTL8019AS LAN Contoller samples
//   Program Name :
//   Programer    :
//   Create date  :  Version 1.0    H25.02.10
//   Replace date :
//   History      :
//   Language     :  MPLAB C18 Version 3.34
//******************************************************************************************
//   Description
//     1)Define I/O PORTS
//         PORTA(0-2) [I/O]  :  PIC General Purpose I/O Port (Used A/D Converter)
//         PORTA(3)   [O]    :  RTL8019AS(IOCHRDY)
//         PORTB(0-4) [O]    :  RTL8019AS(SA0-SA4)
//         PORTB(5)   [I]    :  RTL8019AS(INT4)     <PORTB Interrupt-on-Change>
//         PORTC(0-7) [I/O]  :  PIC Genaral Purpose I/O Port
//         PORTC(7)   [I]    :  PIC Serial comunication EUSART PORT(Rx)
//         PORTC(6)   [O]    :  PIC Serial comunication EUSART PORT(Tx)
//         PORTD(0-7) [I/O]  :  RTL8019AS(SD0-SD7)
//         PORTE(0)   [O]    :  RTL8019AS(IORB)
//         PORTE(1)   [O]    :  RTL8019AS(IOWB)
//         PORTE(2)   [O]    :  RTL8019AS(RSTDRV)
//     2)Oscillator
//         40MHz (10MHz Crystal * PLL4)
//     3)Define RTL8019AS
//         Write buffer start point   : 0x4000
//         Send Paket size (1 record) : 60 - 1514 [bytes]    
//******************************************************************************************
#include	<p18f4520.h>
#include	<stdio.h>
#include	<string.h>
#include	<stdlib.h>
#include	<math.h>
#include	<ctype.h>
#include	<io.h>
#include	<adc.h>

// ---------------------------
//  Define configration words
// ---------------------------
#pragma config OSC=HSPLL     //Oscillator Selection : HS-PLL Enabled
#pragma config FCMEN=OFF     //Fail-Safe Clock Monitor Enable bit:
#pragma config IESO=OFF      //Internal/External Oscillator Switchover bit:
#pragma config PWRT=OFF      //Power-up Timer:
#pragma config BOREN=OFF     //Brown-out Reset Enable bits:
#pragma config BORV=3        //Brown-out Voltage:
#pragma config WDT=OFF       //Watchdog Timer:
#pragma config WDTPS=1       //Watchdog Postscaler:   1:1
#pragma config MCLRE=ON      //MCLR Pin Enable bit:  MCLR pin enabled; RE3 input pin disabled
//#pragma config MCLRE=OFF   //MCLR Pin Enable bit:  RE3 input pin enabled; MCLR disabled
#pragma config LPT1OSC=OFF   //Low-Power Timer1 Oscillator Enable bit: Timer1 configured for higher power operation
#pragma config PBADEN=OFF    //PORTB A/D Enable bit: PORTB<4:0> pins are configured as digital I/O on Reset
//#pragma config PBADEN=ON   //PORTB A/D Enable bit: PORTB<4:0> pins are configured as analog input channels on Reset
#pragma config CCP2MX=PORTBE //CCP2 MUX bit: CCP2 input/output is multiplexed with RB3
//#pragma config CCP2MX=PORTC//CCP2 MUX bit: CCP2 input/output is multiplexed with RC1
#pragma config STVREN=OFF    //Stack Overflow Reset Enable bit: Stack full/underflow will not cause Reset
#pragma config LVP=OFF       //Low Voltage ICSP:
#pragma config XINST=OFF     //Extended Instruction Set Enable bit:
#pragma config DEBUG=OFF     //Background Debugger Enable:
#pragma config CP0=OFF       //Code Protection Block 0:
#pragma config CP1=OFF       //Code Protection Block 1:
#pragma config CP2=OFF       //Code Protection Block 2:
#pragma config CP3=OFF       //Code Protection Block 3:
#pragma config CPB=OFF       //Boot Block Code Protection:
#pragma config CPD=OFF       //Data EEPROM Code Protection:
#pragma config WRT0=OFF      //Write Protection Block 0:
#pragma config WRT1=OFF      //Write Protection Block 1:
#pragma config WRT2=OFF      //Write Protection Block 2:
#pragma config WRT3=OFF      //Write Protection Block 3:
#pragma config WRTB=OFF      //Boot Block Write Protection:
#pragma config WRTC=OFF      //Configuration Register Write Protection: 
#pragma config WRTD=OFF      //Data EEPROM Write Protection:
#pragma config EBTR0=OFF     //Table Read Protection Block 0: 
#pragma config EBTR1=OFF     //Table Read Protection Block 1:
#pragma config EBTR2=OFF     //Table Read Protection Block 2:  
#pragma config EBTR3=OFF     //Table Read Protection Block 3:
#pragma config EBTRB=OFF     //Boot Block Table Read Protection: 

// ---------------------------
//  Define Parameter
// ---------------------------
// (1)Status 
//
#define   PI_NORMAL           0
#define   PI_FAILURE          1
#define   PI_ERR_LENMIN       2
#define   PI_ERR_LENMAX       3
#define   PI_ERR_OVERFLOW     4
#define   PI_ERR_READERR      5
#define   PI_NODATA           6
#define   PI_SEND_BUFMAX      100    // Maximum 1514 Byte
#define   PI_SEND_BUFMIN      64     // Minimum   64 Bytes
#define   PI_SEND_DATMIN      46     // Minimum   46 Bytes
#define   PI_RECIVE_BUFMAX    100    // Maximum 1514 Byte
#define   PI_TMPLINE_MAX      20   

// ---------------------------
//  Define RTL8019AS Register
// ---------------------------
// (1)RTL8019AS Register
//
#define   PI_REG_CR              0x00
#define   PI_REG_CLDA0           0x01
#define   PI_REG_PSTART          0x02
#define   PI_REG_PAR0            0x03
#define   PI_REG_9346CR          0x04 
#define   PI_REG_CLDA1           0x05
#define   PI_REG_PSTOP           0x06
#define   PI_REG_PAR1            0x07
#define   PI_REG_BPAGE           0x08
#define   PI_REG_BNRY            0x09
#define   PI_REG_PAR2            0x0A
#define   PI_REG_CONFIG0         0x0B
#define   PI_REG_TSR             0x0C
#define   PI_REG_TPSR            0x0D
#define   PI_REG_PAR3            0x0E
#define   PI_REG_CONFIG1         0x0F
#define   PI_REG_NCR             0x10
#define   PI_REG_TBCR0           0x11
#define   PI_REG_PAR4            0x12
#define   PI_REG_CONFIG2         0x13
#define   PI_REG_FIFO            0x14
#define   PI_REG_TBCR1           0x15
#define   PI_REG_PAR5            0x16
#define   PI_REG_CONFIG3         0x17
#define   PI_REG_ISR             0x18
#define   PI_REG_CURR            0x19
#define   PI_REG_TEST            0x1A
#define   PI_REG_CRDA0           0x1B
#define   PI_REG_RSAR0           0x1C
#define   PI_REG_MAR0            0x1D
#define   PI_REG_CSNSAV          0x1E
#define   PI_REG_CRDA1           0x1F
#define   PI_REG_RSAR1           0x20
#define   PI_REG_MAR1            0x21
#define   PI_REG_HLTCLK          0x22
#define   PI_REG_8019ID0         0x23
#define   PI_REG_RBCR0           0x24
#define   PI_REG_MAR2            0x25
#define   PI_REG_8019ID1         0x26
#define   PI_REG_RBCR1           0x27
#define   PI_REG_MAR3            0x28
#define   PI_REG_INTR            0x29
#define   PI_REG_RSR             0x2A
#define   PI_REG_RCR             0x2B
#define   PI_REG_MAR4            0x2C
#define   PI_REG_FMWP            0x2D
#define   PI_REG_CNTR0           0x2E
#define   PI_REG_TCR             0x2F
#define   PI_REG_MAR5            0x30
#define   PI_REG_CONFIG4         0x31
#define   PI_REG_CNTR1           0x32
#define   PI_REG_DCR             0x33
#define   PI_REG_MAR6            0x34
#define   PI_REG_CNTR2           0x35
#define   PI_REG_IMR             0x36
#define   PI_REG_MAR7            0x37
//
// (2)RTL8019AS Register Address 
//
#define   PI_REG_ADDR_0          0x00
#define   PI_REG_ADDR_1          0x01
#define   PI_REG_ADDR_2          0x02
#define   PI_REG_ADDR_3          0x03
//
#define   PI_REG_ADDR_CR         0x00
#define   PI_REG_ADDR_CLDA0      0x01
#define   PI_REG_ADDR_PSTART     0x01
#define   PI_REG_ADDR_PAR0       0x01
#define   PI_REG_ADDR_9346CR     0x01
#define   PI_REG_ADDR_CLDA1      0x02
#define   PI_REG_ADDR_PSTOP      0x02
#define   PI_REG_ADDR_PAR1       0x02
#define   PI_REG_ADDR_BPAGE      0x02
#define   PI_REG_ADDR_BNRY       0x03
#define   PI_REG_ADDR_PAR2       0x03
#define   PI_REG_ADDR_CONFIG0    0x03
#define   PI_REG_ADDR_TSR        0x04
#define   PI_REG_ADDR_TPSR       0x04
#define   PI_REG_ADDR_PAR3       0x04
#define   PI_REG_ADDR_CONFIG1    0x04
#define   PI_REG_ADDR_NCR        0x05
#define   PI_REG_ADDR_TBCR0      0x05
#define   PI_REG_ADDR_PAR4       0x05
#define   PI_REG_ADDR_CONFIG2    0x05
#define   PI_REG_ADDR_FIFO       0x06
#define   PI_REG_ADDR_TBCR1      0x06
#define   PI_REG_ADDR_PAR5       0x06
#define   PI_REG_ADDR_CONFIG3    0x06
#define   PI_REG_ADDR_ISR        0x07
#define   PI_REG_ADDR_CURR       0x07
#define   PI_REG_ADDR_TEST       0x07
#define   PI_REG_ADDR_CRDA0      0x08
#define   PI_REG_ADDR_RSAR0      0x08
#define   PI_REG_ADDR_MAR0       0x08
#define   PI_REG_ADDR_CSNSAV     0x08
#define   PI_REG_ADDR_CRDA1      0x09
#define   PI_REG_ADDR_RSAR1      0x09
#define   PI_REG_ADDR_MAR1       0x09
#define   PI_REG_ADDR_HLTCLK     0x09
#define   PI_REG_ADDR_8019ID0    0x0A
#define   PI_REG_ADDR_RBCR0      0x0A
#define   PI_REG_ADDR_MAR2       0x0A
#define   PI_REG_ADDR_8019ID1    0x0B
#define   PI_REG_ADDR_RBCR1      0x0B
#define   PI_REG_ADDR_MAR3       0x0B
#define   PI_REG_ADDR_INTR       0x0B
#define   PI_REG_ADDR_RSR        0x0C
#define   PI_REG_ADDR_RCR        0x0C
#define   PI_REG_ADDR_MAR4       0x0C
#define   PI_REG_ADDR_FMWP       0x0C
#define   PI_REG_ADDR_CNTR0      0x0D
#define   PI_REG_ADDR_TCR        0x0D
#define   PI_REG_ADDR_MAR5       0x0D
#define   PI_REG_ADDR_CONFIG4    0x0D
#define   PI_REG_ADDR_CNTR1      0x0E
#define   PI_REG_ADDR_DCR        0x0E
#define   PI_REG_ADDR_MAR6       0x0E
#define   PI_REG_ADDR_CNTR2      0x0F
#define   PI_REG_ADDR_IMR        0x0F
#define   PI_REG_ADDR_MAR7       0x0F
#define   PI_REG_ADDR_SOFTRESET  0x18
#define   PI_REG_ADDR_DMAPORT    0x10
//
// (3)RTL8019AS Register Page 
//
#define   PI_REG_PAGE_CR         0x00
#define   PI_REG_PAGE_CR_0       0x00
#define   PI_REG_PAGE_CR_1       0x01
#define   PI_REG_PAGE_CR_2       0x02
#define   PI_REG_PAGE_CR_3       0x03
#define   PI_REG_PAGE_CLDA0      0x00
#define   PI_REG_PAGE_PSTART     0x00
#define   PI_REG_PAGE_PSTART_0   0x00
#define   PI_REG_PAGE_PAR0       0x01
#define   PI_REG_PAGE_PSTART_2   0x02
#define   PI_REG_PAGE_9346CR     0x03
#define   PI_REG_PAGE_CLDA1      0x00
#define   PI_REG_PAGE_PSTOP      0x00
#define   PI_REG_PAGE_PSTOP_0    0x00
#define   PI_REG_PAGE_PAR1       0x01
#define   PI_REG_PAGE_PSTOP_2    0x02
#define   PI_REG_PAGE_BPAGE      0x03
#define   PI_REG_PAGE_BNRY       0x00
#define   PI_REG_PAGE_PAR2       0x01
#define   PI_REG_PAGE_CONFIG0    0x03
#define   PI_REG_PAGE_TSR        0x00
#define   PI_REG_PAGE_TPSR       0x00
#define   PI_REG_PAGE_TPSR_0     0x00
#define   PI_REG_PAGE_PAR3       0x01
#define   PI_REG_PAGE_TPSR_2     0x02
#define   PI_REG_PAGE_CONFIG1    0x03
#define   PI_REG_PAGE_NCR        0x00
#define   PI_REG_PAGE_TBCR0      0x00
#define   PI_REG_PAGE_PAR4       0x01
#define   PI_REG_PAGE_CONFIG2    0x03
#define   PI_REG_PAGE_FIFO       0x00
#define   PI_REG_PAGE_TBCR1      0x00
#define   PI_REG_PAGE_PAR5       0x01
#define   PI_REG_PAGE_CONFIG3    0x03
#define   PI_REG_PAGE_ISR        0x00
#define   PI_REG_PAGE_CURR       0x01
#define   PI_REG_PAGE_TEST       0x03
#define   PI_REG_PAGE_CRDA0      0x00
#define   PI_REG_PAGE_RSAR0      0x00
#define   PI_REG_PAGE_MAR0       0x01
#define   PI_REG_PAGE_CSNSAV     0x03
#define   PI_REG_PAGE_CRDA1      0x00
#define   PI_REG_PAGE_RSAR1      0x00
#define   PI_REG_PAGE_MAR1       0x01
#define   PI_REG_PAGE_HLTCLK     0x03
#define   PI_REG_PAGE_8019ID0    0x00
#define   PI_REG_PAGE_RBCR0      0x00
#define   PI_REG_PAGE_MAR2       0x01
#define   PI_REG_PAGE_8019ID1    0x00
#define   PI_REG_PAGE_RBCR1      0x00
#define   PI_REG_PAGE_MAR3       0x01
#define   PI_REG_PAGE_INTR       0x03
#define   PI_REG_PAGE_RSR        0x00
#define   PI_REG_PAGE_RCR        0x00
#define   PI_REG_PAGE_RCR_0      0x00
#define   PI_REG_PAGE_MAR4       0x01
#define   PI_REG_PAGE_RCR_2      0x02
#define   PI_REG_PAGE_FMWP       0x03
#define   PI_REG_PAGE_CNTR0      0x00
#define   PI_REG_PAGE_TCR        0x00
#define   PI_REG_PAGE_TCR_0      0x00
#define   PI_REG_PAGE_MAR5       0x01
#define   PI_REG_PAGE_TCR_2      0x02
#define   PI_REG_PAGE_CONFIG4    0x03
#define   PI_REG_PAGE_CNTR1      0x00
#define   PI_REG_PAGE_DCR        0x00
#define   PI_REG_PAGE_DCR_0      0x00
#define   PI_REG_PAGE_MAR6       0x01
#define   PI_REG_PAGE_DCR_2      0x02
#define   PI_REG_PAGE_CNTR2      0x00
#define   PI_REG_PAGE_IMR        0x00
#define   PI_REG_PAGE_IMR_0      0x00
#define   PI_REG_PAGE_MAR7       0x01
#define   PI_REG_PAGE_IMR_2      0x02
#define   PI_REG_PAGE_DMAPORT    0x00
#define   PI_REG_PAGE_DMAPORT_0  0x00

// ---------------------------
//  Define Structure
// ---------------------------
// (1)Send packet
struct PKT_SEND_def {
    unsigned char  send_mac[6];
    unsigned char  system_mac[6];
    unsigned char  pkt_type[2];
    unsigned char  pkt_data[(PI_SEND_BUFMAX + 4)];   //data + FSC(4)
};
union PKT_SEND_REC_def {
    struct PKT_SEND_def data;
    unsigned char  record[];
}PKT_SEND_REC;

// (2)Packet data record
struct ARP_HEAD_def {
    unsigned char  hard_type[2];
    unsigned char  proc_type[2];
    unsigned char  hard_len;
    unsigned char  proc_len;
    unsigned char  op_code[2];
    unsigned char  arp_sys_mac[6];
    unsigned char  arp_sys_ip[4];
    unsigned char  arp_send_mac[6];
    unsigned char  arp_send_ip[4];
    unsigned char  dummy_1[];
};

struct REC_ARP_HEAD_def {
    unsigned char  send_mac[6];
    unsigned char  system_mac[6];
    unsigned char  pkt_type[2];
//
    unsigned char  hard_type[2];
    unsigned char  proc_type[2];
    unsigned char  hard_len;
    unsigned char  proc_len;
    unsigned char  op_code[2];
    unsigned char  arp_sys_mac[6];
    unsigned char  arp_sys_ip[4];
    unsigned char  arp_send_mac[6];
    unsigned char  arp_send_ip[4];
    unsigned char  dummy_1[];
};

struct UDP_HEAD_def {
    unsigned char  ip_ver_head;
    unsigned char  ip_tos;
    unsigned char  ip_packet_length[2];
    unsigned char  ip_chk_number[2];
    unsigned char  ip_flg_offset[2];
    unsigned char  ip_ttl;
    unsigned char  ip_protocol;
    unsigned char  ip_chk_sum[2];
    unsigned char  ip_system_ip[4];
    unsigned char  ip_send_ip[4];
//
    unsigned char  udp_system_port[2];
    unsigned char  udp_send_port[2];
    unsigned char  udp_length[2];
    unsigned char  udp_chk_sum[2];
    unsigned char  dummy_1[];
};

struct REC_UDP_HEAD_def {
    unsigned char  eth_send_mac[6];
    unsigned char  eth_system_mac[6];
    unsigned char  eth_pkt_type[2];
//
    unsigned char  ip_ver_head;
    unsigned char  ip_tos;
    unsigned char  ip_packet_length[2];
    unsigned char  ip_chk_number[2];
    unsigned char  ip_flg_offset[2];
    unsigned char  ip_ttl;
    unsigned char  ip_protocol;
    unsigned char  ip_chk_sum[2];
    unsigned char  ip_system_ip[4];
    unsigned char  ip_send_ip[4];
//
    unsigned char  udp_system_port[2];
    unsigned char  udp_send_port[2];
    unsigned char  udp_length[2];
    unsigned char  udp_chk_sum[2];
    unsigned char  dummy_1[];
};

union PKT_DATA_REC_def {
    unsigned char record[PI_RECIVE_BUFMAX];
    struct ARP_HEAD_def     arp;
    struct REC_ARP_HEAD_def rec_arp;
    struct UDP_HEAD_def     udp;
    struct REC_UDP_HEAD_def rec_udp;
} PKT_DATA_REC; 

// (3)MAC address
static unsigned char MAC_ADDRESS[6];

// (4)MAC address
static unsigned char IP_ADDRESS[4];

// ---------------------------
//  Define Function
// ---------------------------
void Wait_above_1uS(unsigned int);
void Timer(void);
void Wait_1mS(unsigned int);
void Init_ADC(void);
void GetADC(unsigned int *);
void Init_USART(void);
void SendUART(unsigned char );
void RecUSART(unsigned char * );
void PIC_PUT_PORT(unsigned char);
void init_RTL8019(void);
void RTL8019_READ_REGISTER(unsigned char, unsigned char, unsigned char *);
void RTL8019_WRITE_REGISTER(unsigned char, unsigned char, unsigned char );
void RTL8019_UPDATE_REGISTER(unsigned char, unsigned char, unsigned char, unsigned char );
void RTL8019_SET_REGISTER_PAGE(unsigned char);
void RTL8019_READ_REGISTER_REC(unsigned char, unsigned char *);
void RTL8019_WRITE_REGISTER_REC(unsigned char, unsigned char );
char RTL8019_WRITE_SNDBUF(unsigned char *, unsigned int );
char Datasend_RTL8019(unsigned char *, unsigned int);
char Recordsend_RTL8019(unsigned char *, unsigned int);
void RTL8019_SOFT_RESET(void);
void RTL8019_RB_ON(void);
void RTL8019_RB_OFF(void);
void RTL8019_WB_ON(void);
void RTL8019_WB_OFF(void);
void RTL8019_RST_ON(void);
void RTL8019_RST_OFF(void);
void RTL8019_CHRDY_ON(void);
void RTL8019_CHRDY_OFF(void);
void RTL8019_SD_PUT(unsigned char);
void RTL8019_SD_GET(unsigned char *);
void RTL8019_SA_PUT(unsigned char);
void RTL8019_SET_MAC(void);
char RTL8019_READ_RECBUF(unsigned char *, unsigned int  * );
void RTL8019_BUFFOVER_PRC(void);
char Send_Paket(unsigned char *, unsigned char *,unsigned char *, unsigned int);
void ARPpaket_getMAC(unsigned char *, unsigned char *);
void Recive_paket(void);
void Calc_check_sum(unsigned char *, unsigned char *, unsigned int);
void Deb_dump(unsigned char);
void prog01(void);
void prog02(unsigned char *);
void Proc_main(void);
void user_main(void);
void Proc_arp(void);
void Proc_udp(void);
void UDP_send(void);   
void UDP_chksum(unsigned char *, unsigned char *);
//
volatile unsigned char  G_PAGE=0; 
volatile unsigned char  G_CLM=0; 

void main(void)
{
    unsigned char ip[4];

// *************************************
//   1.Initialize 
// *************************************
// (0)Select A/D Converter
    ADCON1=0b00001111;    //ALL Degital Port

// (1)PORT
    PORTA=0b00000000;
    PORTB=0b00000000;
    PORTC=0b00000000;
    PORTD=0b00000000;
    PORTE=0b00000000;

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

// (3)TRIS
    TRISA=0b11110111;
    TRISB=0b11100000;
    TRISC=0b11111111;   
    TRISD=0b11111111;
//  TRISD=0b00000000;
    TRISE=0b00000000;   //Caution !!! TRISE[4]:PSPMODE Flag

// (4)Initialized RTL8019AS
    init_RTL8019();

// (5)Initialized UART
//  Init_USART();

// (6)Define IP address
    IP_ADDRESS[0] = 192;
    IP_ADDRESS[1] = 168;
    IP_ADDRESS[2] =   0;
    IP_ADDRESS[3] =  20;

// (7)Wait
    Wait_1mS((unsigned int)1000);

// *************************************
//   2.Program Main
// *************************************
    while(1){
        Proc_main();
        user_main();
    };
}

//******************************************************************************************
//   Function Name : user_main
//   Title         : user main program
//   Input         : 
//   Output        :
//******************************************************************************************
void user_main(void){
}

//******************************************************************************************
//   Function Name : Proc_main
//   Title         : main process
//   Input         : 
//   Output        :
//******************************************************************************************
void Proc_main(void){

// *********************
//  1.Recive Packet
// *********************
    Recive_paket();

// *********************
//  2.To classify the type of the Packet
// *********************
    if(PKT_DATA_REC.rec_arp.pkt_type[0] == 0x08 &&  PKT_DATA_REC.rec_arp.pkt_type[1] == 0x06){
        Proc_arp();
        return;
    }else if(PKT_DATA_REC.rec_udp.eth_pkt_type[0] == 0x08 &&  PKT_DATA_REC.rec_udp.eth_pkt_type[1] == 0x00){
        Proc_udp();
        return;
    }
}

//******************************************************************************************
//   Function Name : Proc_arp
//   Title         : ARP recive Process
//   Input         : 
//   Output        :
//******************************************************************************************
void Proc_arp(void){
    unsigned char send_mac_address[6];
    unsigned char send_mac_ip[4];
    unsigned char in_type[4];
    unsigned int lp;

// *********************
//  1.Check IP address
// *********************
    if(PKT_DATA_REC.rec_arp.arp_send_ip[0] == IP_ADDRESS[0]
    && PKT_DATA_REC.rec_arp.arp_send_ip[1] == IP_ADDRESS[1]
    && PKT_DATA_REC.rec_arp.arp_send_ip[2] == IP_ADDRESS[2]
    && PKT_DATA_REC.rec_arp.arp_send_ip[3] == IP_ADDRESS[3]){

// *********************
//  2.Send ARP packet
// *********************
//  (1)Send MAC Address
        for(lp=0;lp<6;lp++)send_mac_address[lp]=PKT_DATA_REC.rec_arp.system_mac[lp];

//  (2)Paket type
        in_type[0]=0x08;
        in_type[1]=0x06;

//  (3)Send IP Address
        for(lp=0;lp<4;lp++)send_mac_ip[lp] = PKT_DATA_REC.rec_arp.arp_sys_ip[lp];

// *********************
//  2.Set ARP Header
// *********************
//  (1)Buffer Initialize
        for(lp=0;lp<PI_RECIVE_BUFMAX;lp++)PKT_DATA_REC.record[lp] = 0x00;

//  (2)Set data field
        PKT_DATA_REC.arp.hard_type[0] = 0x00;
        PKT_DATA_REC.arp.hard_type[1] = 0x01;
        PKT_DATA_REC.arp.proc_type[0] = 0x08;
        PKT_DATA_REC.arp.proc_type[1] = 0x00;
        PKT_DATA_REC.arp.hard_len     = 0x06;
        PKT_DATA_REC.arp.proc_len     = 0x04;
        PKT_DATA_REC.arp.op_code[0]   = 0x00;
        PKT_DATA_REC.arp.op_code[1]   = 0x02;   // Send:0001h, Recive:0002h
        for(lp=0;lp<6;lp++)PKT_DATA_REC.arp.arp_sys_mac[lp]   = MAC_ADDRESS[lp];
        for(lp=0;lp<4;lp++)PKT_DATA_REC.arp.arp_sys_ip[lp]    = IP_ADDRESS[lp];
        for(lp=0;lp<6;lp++)PKT_DATA_REC.arp.arp_send_mac[lp]  = send_mac_address[lp];
        for(lp=0;lp<4;lp++)PKT_DATA_REC.arp.arp_send_ip[lp]   = send_mac_ip[lp];

//   (3)Send ARP Paket
        Send_Paket(send_mac_address, in_type, &PKT_DATA_REC.record[0], (unsigned int)60);

    }
}


//******************************************************************************************
//   Function Name : Proc_udp
//   Title         : 
//   Input         : 
//   Output        :
//******************************************************************************************
void Proc_udp(void){   

// *********************
//  1.Port Number 10000 (0x2710)
// *********************
    if(PKT_DATA_REC.rec_udp.udp_send_port[0] == 0x27 &&  PKT_DATA_REC.rec_udp.udp_send_port[1] == 0x10){
        prog01();
        return;
    }
}

//******************************************************************************************
//   Function Name : UDP_send
//   Title         : 
//   Input         : 
//   Output        :
//******************************************************************************************
void UDP_send(void){   

}

//******************************************************************************************
//   Function Name : prog01
//   Title         : 
//   Input         : 
//   Output        :
//******************************************************************************************
void prog01(void){
    unsigned char mac[6];
    unsigned char send_mac_address[6];
    unsigned char in_type[4];
    unsigned int  lp;
    unsigned int  data_length;
    unsigned char rec_ip[4];
    unsigned char rec_port[2];
    unsigned char sys_port[2];
    unsigned char chk_number[2];
    unsigned char udp_len;
    unsigned char TMP_record[PI_TMPLINE_MAX];
    unsigned int  data_len;

// *********************
//  1.Initialize
// *********************
// (1)Set MAC address
    for(lp=0;lp<6;lp++)mac[lp] = PKT_DATA_REC.rec_udp.eth_system_mac[lp];

// (2)Set IP address
    for(lp=0;lp<4;lp++)rec_ip[lp] = PKT_DATA_REC.rec_udp.ip_system_ip[lp];

// (3)Set port number
    for(lp=0;lp<2;lp++)rec_port[lp] = PKT_DATA_REC.rec_udp.udp_send_port[lp];
    for(lp=0;lp<2;lp++)sys_port[lp] = PKT_DATA_REC.rec_udp.udp_system_port[lp];

// (4)Set packet number
    for(lp=0;lp<2;lp++)chk_number[lp] = PKT_DATA_REC.rec_udp.ip_chk_number[lp];

// (5)Set udp length
    udp_len = PKT_DATA_REC.rec_udp.udp_length[1];

// (6)Set data
    data_len = udp_len - 8 ;
    if(data_len > PI_TMPLINE_MAX ) data_len = PI_TMPLINE_MAX;
    for(lp=0;lp<data_len;lp++)TMP_record[lp] =  PKT_DATA_REC.rec_udp.dummy_1[lp];

// *********************
//  2.Send Paket
// *********************
// (0)Clear buffer
    for(lp=0;lp<PI_RECIVE_BUFMAX;lp++)PKT_DATA_REC.record[lp] = 0x00;

// (1)Paket type (UDP)
    in_type[0]=0x08;
    in_type[1]=0x00;

// (2)Set data
    PKT_DATA_REC.udp.ip_ver_head = 0x45;
    PKT_DATA_REC.udp.ip_tos      = 0x00;
    PKT_DATA_REC.udp.ip_packet_length[0] = 0x00;
    PKT_DATA_REC.udp.ip_packet_length[1] = 0x20;
    PKT_DATA_REC.udp.ip_chk_number[0]    = chk_number[0];
    PKT_DATA_REC.udp.ip_chk_number[1]    = chk_number[1];
    PKT_DATA_REC.udp.ip_flg_offset[0]    = 0x00;
    PKT_DATA_REC.udp.ip_flg_offset[1]    = 0x00;
    PKT_DATA_REC.udp.ip_ttl              = 0x80;
    PKT_DATA_REC.udp.ip_protocol         = 0x11;
    for(lp=0;lp<4;lp++)PKT_DATA_REC.udp.ip_system_ip[lp] = IP_ADDRESS[lp];
    for(lp=0;lp<4;lp++)PKT_DATA_REC.udp.ip_send_ip[lp]   = rec_ip[lp];
//
    for(lp=0;lp<2;lp++)PKT_DATA_REC.udp.udp_system_port[lp] = sys_port[lp];
    for(lp=0;lp<2;lp++)PKT_DATA_REC.udp.udp_send_port[lp]   = rec_port[lp];
    PKT_DATA_REC.udp.udp_length[0]      = 0x00;
    PKT_DATA_REC.udp.udp_length[1]      = udp_len;

    for(lp=0;lp<data_len;lp++)PKT_DATA_REC.udp.dummy_1[lp] = TMP_record[lp];

// (3)Set check sum
    UDP_chksum(PKT_DATA_REC.udp.ip_chk_sum, PKT_DATA_REC.udp.udp_chk_sum);

// (4)Send Test Paket
    data_len = udp_len + 34 ;   // udb_len + ethernet_header(14) + ip_header(20)
    if(data_len >PI_SEND_BUFMAX )data_len=PI_SEND_BUFMAX;
    Send_Paket(mac, in_type, &PKT_DATA_REC.record[0], (unsigned int)data_len);
}

//******************************************************************************************
//   Function Name : UDP_chksum
//   Title         : 
//   Input         : 
//   Output        :
//******************************************************************************************
void UDP_chksum(unsigned char ip_chksum[], unsigned char udp_chksum[]){   
    unsigned long int sum1;
    unsigned long int sum1_over;
    unsigned long int sum2;
    unsigned long int sum2_over;
    unsigned int  data_len;
    unsigned int  lp,lp1;

// *********************
//  1.Calculate IP checksum
// *********************

    sum1 =   (unsigned long int)PKT_DATA_REC.udp.ip_ver_head          * 0x100
          +  (unsigned long int)PKT_DATA_REC.udp.ip_tos
          +  (unsigned long int)PKT_DATA_REC.udp.ip_packet_length[0]  * 0x100
          +  (unsigned long int)PKT_DATA_REC.udp.ip_packet_length[1] 
          +  (unsigned long int)PKT_DATA_REC.udp.ip_chk_number[0]     * 0x100
          +  (unsigned long int)PKT_DATA_REC.udp.ip_chk_number[1] 
          +  (unsigned long int)PKT_DATA_REC.udp.ip_flg_offset[0]     * 0x100
          +  (unsigned long int)PKT_DATA_REC.udp.ip_flg_offset[1]
          +  (unsigned long int)PKT_DATA_REC.udp.ip_ttl               * 0x100
          +  (unsigned long int)PKT_DATA_REC.udp.ip_protocol 
          +  (unsigned long int) PKT_DATA_REC.udp.ip_system_ip[0]     * 0x100
          +  (unsigned long int) PKT_DATA_REC.udp.ip_system_ip[1]
          +  (unsigned long int) PKT_DATA_REC.udp.ip_system_ip[2]     * 0x100
          +  (unsigned long int) PKT_DATA_REC.udp.ip_system_ip[3]
          +  (unsigned long int) PKT_DATA_REC.udp.ip_send_ip[0]       * 0x100
          +  (unsigned long int) PKT_DATA_REC.udp.ip_send_ip[1]
          +  (unsigned long int)PKT_DATA_REC.udp.ip_send_ip[2]        * 0x100
          +  (unsigned long int)PKT_DATA_REC.udp.ip_send_ip[3]  ;

    sum1_over = sum1 / 0x10000;
    sum1 = sum1 % 0x10000 + sum1_over;
    sum1 = 0xffff - sum1 ;
    ip_chksum[0] = (unsigned char)(sum1 / 0x100);
    ip_chksum[1] = (unsigned char)(sum1 % 0x100);

// *********************
//  2.Calculate UDP checksum
// *********************

    sum2 =    (unsigned long int)PKT_DATA_REC.udp.udp_system_port[0]   * 0x100
          +   (unsigned long int)PKT_DATA_REC.udp.udp_system_port[1] 
          +   (unsigned long int)PKT_DATA_REC.udp.udp_send_port[0]     * 0x100
          +   (unsigned long int)PKT_DATA_REC.udp.udp_send_port[1] 
          +   (unsigned long int)PKT_DATA_REC.udp.udp_length[0]        * 0x100
          +   (unsigned long int)PKT_DATA_REC.udp.udp_length[1] 
//
          +   (unsigned long int)PKT_DATA_REC.udp.ip_system_ip[0]      * 0x100
          +   (unsigned long int)PKT_DATA_REC.udp.ip_system_ip[1]
          +   (unsigned long int)PKT_DATA_REC.udp.ip_system_ip[2]      * 0x100
          +   (unsigned long int)PKT_DATA_REC.udp.ip_system_ip[3]
          +   (unsigned long int)PKT_DATA_REC.udp.ip_send_ip[0]        * 0x100
          +   (unsigned long int)PKT_DATA_REC.udp.ip_send_ip[1]
          +   (unsigned long int)PKT_DATA_REC.udp.ip_send_ip[2]        * 0x100
          +   (unsigned long int)PKT_DATA_REC.udp.ip_send_ip[3] 
          +   (unsigned long int)PKT_DATA_REC.udp.ip_protocol
          +   (unsigned long int)PKT_DATA_REC.udp.udp_length[0]        * 0x100
          +   (unsigned long int)PKT_DATA_REC.udp.udp_length[1] ;

    data_len = (( (unsigned int)PKT_DATA_REC.udp.udp_length[0] * (unsigned int)0xff 
                + (unsigned int)PKT_DATA_REC.udp.udp_length[1] ) - 8 + 1 ) / 2 ;

    lp1=0;
    for(lp=0;lp<data_len;lp++){
        sum2 = sum2 
        + (unsigned long int)PKT_DATA_REC.udp.dummy_1[lp1]   * 0x100
        + (unsigned long int)PKT_DATA_REC.udp.dummy_1[lp1+1];
        lp1=lp1+2;
    }

    sum2_over = sum2 / 0x10000;
    sum2 = sum2 % 0x10000 + sum2_over;
    sum2 = 0xffff - sum2 ;

    udp_chksum[0] = sum2 / 0x100;
    udp_chksum[1] = sum2 % 0x100;
}

//******************************************************************************************
//   Function Name : ARPpaket_getMAC
//   Title         : Get MAC address 
//   Input         : 
//   Output        :
//******************************************************************************************
void ARPpaket_getMAC(unsigned char ip[], unsigned char mac[]){
    unsigned char send_mac_address[6];
    unsigned char in_type[4];
    unsigned int  lp;

// *********************
//  1.Initialize
// *********************
//  (0)Initialize
    for(lp=0;lp<PI_RECIVE_BUFMAX;lp++)PKT_DATA_REC.record[lp] = 0x00;

//  (1)Send MAC Address
    send_mac_address[0]=0xff;
    send_mac_address[1]=0xff;
    send_mac_address[2]=0xff;
    send_mac_address[3]=0xff;
    send_mac_address[4]=0xff;
    send_mac_address[5]=0xff;

//  (2)Paket type
    in_type[0]=0x08;
    in_type[1]=0x06;

// *********************
//  2.Set ARP Header
// *********************
    PKT_DATA_REC.arp.hard_type[0] = 0x00;
    PKT_DATA_REC.arp.hard_type[1] = 0x01;
    PKT_DATA_REC.arp.proc_type[0] = 0x08;
    PKT_DATA_REC.arp.proc_type[1] = 0x00;
    PKT_DATA_REC.arp.hard_len     = 0x06;
    PKT_DATA_REC.arp.proc_len     = 0x04;
    PKT_DATA_REC.arp.op_code[0]   = 0x00;   // Send:0001h, Recive:0002h
    PKT_DATA_REC.arp.op_code[1]   = 0x01;   // Send:0001h, Recive:0002h
    for(lp=0;lp<6;lp++)PKT_DATA_REC.arp.arp_sys_mac[lp]   = MAC_ADDRESS[lp];
    for(lp=0;lp<4;lp++)PKT_DATA_REC.arp.arp_sys_ip[lp]    = 0x00;
    for(lp=0;lp<6;lp++)PKT_DATA_REC.arp.arp_send_mac[lp]  = 0xff;
    for(lp=0;lp<4;lp++)PKT_DATA_REC.arp.arp_send_ip[lp]   = ip[lp];

// *********************
//  3.Send ARP Packet
// *********************
    Send_Paket(send_mac_address, in_type, &PKT_DATA_REC.record[0], (unsigned int)60);

// *********************
//  4.Recive Packet
// *********************
    Recive_paket();

// *********************
//  5.Set MAC address
// *********************
    for(lp=0;lp<6;lp++)mac[lp] = PKT_DATA_REC.record[lp+6];

}

//******************************************************************************************
//   Function Name : Recive_paket
//   Title         : 
//   Input         : 
//   Output        :
//******************************************************************************************
void Recive_paket(void){
//  unsigned char PKT_DATA_REC[PI_RECIVE_BUFMAX];
    unsigned char send_mac_address[6];
    unsigned char system_mac_address[6];
    unsigned char in_type[4];
    unsigned int  lp;
    unsigned int  read_data_length;
    unsigned int  put_data_length;
    char          status;
    unsigned char tmp_isr;
    unsigned char bnry;
    unsigned char curr;

// *********************
//  0.Initialize
// *********************
//  (1)Send MAC Address
    send_mac_address[0]=0xff;
    send_mac_address[1]=0xff;
    send_mac_address[2]=0xff;
    send_mac_address[3]=0xff;
    send_mac_address[4]=0xff;
    send_mac_address[5]=0xff;

//  (2)System MAC Address
    for(lp=0;lp<6;lp++) system_mac_address[lp] = MAC_ADDRESS[lp];

//  (3)Paket type
    in_type[0]=0x08;
    in_type[1]=0x00;

// *********************
//  1.main process
// *********************
    while(1){

//  (1)Check Recive data
        RTL8019_READ_REGISTER_REC(PI_REG_ADDR_ISR, &tmp_isr);
//
        RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_CR, (unsigned char)0x22);
        RTL8019_READ_REGISTER_REC(PI_REG_ADDR_BNRY, &bnry);
        RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_CR, (unsigned char)0x42);
        RTL8019_READ_REGISTER_REC(PI_REG_ADDR_CURR, &curr);
        RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_CR, (unsigned char)0x22);


//  (2)Read data and set data
        if(((tmp_isr & 0b00000001)!=0) 
        && ((curr > (bnry + 1)) 
        || ((curr < (0x46 + 6 )) && (bnry > (0x5f - 6))) && ((curr + 26 ) > (bnry + 1)) )){
            status = RTL8019_READ_RECBUF( &PKT_DATA_REC.record[0], &read_data_length );
            if(read_data_length < PI_SEND_BUFMAX) put_data_length = read_data_length;
            else put_data_length = PI_SEND_BUFMAX;
            if(put_data_length>0){
                tmp_isr &= 0b11111110;
                RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_ISR,tmp_isr);
                return;
            }
        }
    }

}

//******************************************************************************************
//   Function Name : init_RTL8019
//   Title         : Initialized RTL8019AS
//   Input         : 
//   Output        :
//******************************************************************************************
void init_RTL8019(void)
{
// ---------------------------
// 0.Default value 
// ----------------------------
    RTL8019_RB_ON();
    RTL8019_WB_ON();
    RTL8019_RST_OFF();
    RTL8019_CHRDY_ON();

// ----------------------------
// 1.Hardware reset (RSTDIV=>H)  >800[ns]
// ----------------------------
    RTL8019_RST_ON();
    Wait_above_1uS((unsigned int)5);     // > 1[uS]
    RTL8019_RST_OFF();
    Wait_1mS((unsigned int)5);           // > 2[mS]

// ----------------------------
// 2.Software reset 
// ----------------------------
    RTL8019_SOFT_RESET();

// ----------------------------
// 3.Page 0
// ----------------------------
// (1)Page 0
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_CR, (unsigned char)0x21);

// (2)Set DCR Register
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_DCR, (unsigned char)0b01000000);


// (3)Clear DMA Transfer Size
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_RBCR0, (unsigned char)0);
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_RBCR1, (unsigned char)0);

// (4)Set mode
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_RCR, (unsigned char)0x20);
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_TCR, (unsigned char)0x02);

// (5)Set address
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_TPSR,  (unsigned char)0x40);   //Send   buffer start address (4000h)
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_PSTART,(unsigned char)0x46);   //Recive buffer start address (4600h)
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_BNRY,  (unsigned char)0x46);   //Initialized BNRY pointer    (4600h) 
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_PSTOP, (unsigned char)0x60);   //Recive buffer end   address (6000h)

// (6)Set config
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_IMR, (unsigned char)0x00);
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_ISR, (unsigned char)0xFF);

// ----------------------------
// 4.Page 1
// ----------------------------
// (1)Page 1
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_CR, (unsigned char)0x61);

// (2)Set MAC Address

// (3)Set recive MAC address
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_CURR, (unsigned char)0x47);

// (4)Set Multicast Address
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_MAR0, (unsigned char)0x00);
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_MAR1, (unsigned char)0x00);
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_MAR2, (unsigned char)0x00);
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_MAR3, (unsigned char)0x00);
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_MAR4, (unsigned char)0x00);
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_MAR5, (unsigned char)0x00);

// ----------------------------
// 5.Page 0
// ----------------------------
// (1)Page 0
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_CR, (unsigned char)0x21);

// (2)Set RCR
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_RCR, (unsigned char)0x04);

// (3)Active Controller
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_CR, (unsigned char)0x22);

// (4)Active Controller
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_TCR, (unsigned char)0x00);

// (5)Define IMR Register (Define Interrupts)
    RTL8019_WRITE_REGISTER_REC(PI_REG_PAGE_IMR, (unsigned char)0x01);   //Enable recive paket interrupts

// ----------------------------
// 6.Set MAC addcress
// ----------------------------
    RTL8019_SET_MAC();
}

//******************************************************************************************
//   Function Name : RTL8019_SOFT_RESET
//   Title         : RTL8019AS software reset
//   Input         : 
//   Output        :
//******************************************************************************************
void RTL8019_SOFT_RESET(void)
{
   unsigned char tmp_c;
// *********************
//  1.Read register
// *********************
    RTL8019_READ_REGISTER_REC(PI_REG_ADDR_SOFTRESET, &tmp_c);

// *********************
//  2.Write register
// *********************   
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_SOFTRESET,tmp_c);

}

//******************************************************************************************
//   Function Name : RTL8019_SET_MAC
//   Title         : RTL8019AS read MAC address from serial EEP rom
//   Input         : 
//   Output        :
//   Description   : MAC_ADDRESS[6]
//******************************************************************************************
void RTL8019_SET_MAC(void)
{
unsigned char tmp_c;
unsigned int  lp;

// *********************
//  1.Set DMA data bytes (12 bytes : MAC(2) * 6 )  
// *********************
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_RBCR1, (unsigned char)0x00);
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_RBCR0, (unsigned char)12);

// *********************
//  2.Set DMA start points (MAC start point)  
// *********************
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_RSAR1, (unsigned char)0x00);
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_RSAR0, (unsigned char)0x00);

// *********************
//  3.Start Remote read  
// *********************
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_CR, (unsigned char)0x0A);

// *********************
//  4.Read buffer  
// *********************
    for(lp=0;lp<6;lp++){
        RTL8019_READ_REGISTER_REC(PI_REG_ADDR_DMAPORT, &MAC_ADDRESS[lp]);
        RTL8019_READ_REGISTER_REC(PI_REG_ADDR_DMAPORT, &tmp_c);
    }

// *********************
//  5.Set MAC address  
// *********************
// (1)Page 1
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_CR, (unsigned char)0x61);

// (2)Set MAC address
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_PAR0,MAC_ADDRESS[0] );
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_PAR1,MAC_ADDRESS[1] );
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_PAR2,MAC_ADDRESS[2] );
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_PAR3,MAC_ADDRESS[3] );
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_PAR4,MAC_ADDRESS[4] );
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_PAR5,MAC_ADDRESS[5] );

// (3)Page 0
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_CR, (unsigned char)0x22);

}

//******************************************************************************************
//   Function Name : Send_Paket
//   Title         : Send paket 
//   Input         : 
//   Output        :
//******************************************************************************************
char Send_Paket(unsigned char send_mac[],unsigned char in_type[], 
                unsigned char in_data[], unsigned int data_length)
{
unsigned int lp;
unsigned int record_length;
unsigned int riv_data_length;

// *********************
//  0.Initialize
// *********************
    if(data_length > PI_SEND_BUFMAX) data_length = PI_SEND_BUFMAX;
//
    if(data_length < PI_SEND_DATMIN){
        riv_data_length = PI_SEND_DATMIN;
    }else{
        riv_data_length = data_length;    
    }
//
    record_length = riv_data_length + 14;  // 14 <== 6 *2 ([RT]MAC address) + 2 (type) 

// *********************
//  1.Set Header
// *********************
// (1)Set send MAC address
    for(lp=0;lp<6;lp++){
        PKT_SEND_REC.data.send_mac[lp] = send_mac[lp];
    }
// (2)Set system MAC address
    for(lp=0;lp<6;lp++){
        PKT_SEND_REC.data.system_mac[lp] = MAC_ADDRESS[lp];
    }
// (3)Set type
    PKT_SEND_REC.data.pkt_type[1] = in_type[1];
    PKT_SEND_REC.data.pkt_type[0] = in_type[0];

// *********************
//  2.Set Data
// *********************
    for(lp=0;lp<data_length;lp++){
        PKT_SEND_REC.data.pkt_data[lp] =in_data[lp]; 
    }
    if(data_length < riv_data_length) {
        for(lp=data_length;lp<riv_data_length;lp++){
            PKT_SEND_REC.data.pkt_data[lp] =0x00; 
        }
    }

// *********************
//  3.Send Paket
// *********************
    Recordsend_RTL8019(&PKT_SEND_REC.record[0], record_length);

}

//******************************************************************************************
//   Function Name : Recordsend_RTL8019
//   Title         : Record send 
//   Input         : 
//   Output        :
//******************************************************************************************
char Recordsend_RTL8019(unsigned char in_str[], unsigned int data_length)
{
    unsigned char tmp_c;
    unsigned char len1,len0;

// *********************
//  0.Initialize
// *********************
    len0 = (unsigned char)(data_length & 0x00ff);
    len1 = (unsigned char)((data_length & 0xff00) >> 8);

// *********************
//  1.Check TXP Bit
// *********************
    while(1){
        RTL8019_READ_REGISTER_REC(PI_REG_ADDR_CR, &tmp_c);
        if((tmp_c & 0b00000100) == 0) break;
    }

// *********************
//  2.Set Buffer
// *********************
// (1)Set Page 0
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_CR,(unsigned char)0x22);

// (2)Set send buffer
    RTL8019_WRITE_SNDBUF(in_str, data_length);

// *********************
//  3.Set TBCR register
// *********************
// (1)Paket length
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_TBCR1, len1);
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_TBCR0, len0);

// *********************
//  4.Send command
// *********************
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_CR, 0x26);
    return(PI_NORMAL);
}

//******************************************************************************************
//   Function Name : RTL8019_READ_RECBUF
//   Title         : RTL8019AS read recive buffer
//   Input         : 
//   Output        :
//   Description   : Remote DMA recive  ( Start point 4600h[define PSTART register])
//                                      ( End   point 6000h[define PSTOP  register]) 
//                          Page 0 - 57 (4600h - 7FFFh)
//******************************************************************************************
char RTL8019_READ_RECBUF(unsigned char out_data[], unsigned int  *data_length )
{
    unsigned char tmp_c;
    unsigned char bnry;
    unsigned char bnry_1;
    unsigned char curr;
    unsigned char page;
    unsigned char min_page            = 0x46;   // 4600h - 5f00h (page) 
    unsigned char last_page           = 0x5f;   // 4600h - 5f00h (page) 
    unsigned char frame_manager[4];
    unsigned int  data_point;
    unsigned int  lp;
    unsigned int  data_size;
    unsigned int  tmp_size;
    unsigned int  tmp_size_1;
    unsigned int  tmp_size_2;
    unsigned char tmp_size_H;
    unsigned char tmp_size_L;

// *********************
//  0.Initialize
// *********************
    for(lp=0;lp<PI_RECIVE_BUFMAX;lp++){
        out_data[lp]=0x00;
    }

// *********************
//  1.Check Buffer Overflow
// *********************
    RTL8019_READ_REGISTER_REC(PI_REG_ADDR_ISR, &tmp_c);
    if((tmp_c & 0b00010000) != 0){
        RTL8019_BUFFOVER_PRC();
        *data_length = 0;
        return(PI_ERR_OVERFLOW);
    }

// *********************
//  2.Read BNRY register
// *********************
// (1)Stop DMA and Page 0  
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_CR, (unsigned char)0x22);

// (2)Read BNRY register
    RTL8019_READ_REGISTER_REC(PI_REG_ADDR_BNRY, &bnry);

// *********************
//  3.Read CURR register
// *********************
// (1)Set Page 1
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_CR, (unsigned char)0x42);

// (2)Read CURR register
    RTL8019_READ_REGISTER_REC(PI_REG_ADDR_CURR, &curr);

// (3)Set Page 0
   RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_CR, (unsigned char)0x22);

// *********************
//  4.Check read data
// *********************
    if(curr == (bnry + 1)){
        *data_length = 0;
        return(PI_NODATA);
    }

// *********************
//  5.Read Frame Management record (4 Bytes)
// *********************
//  (1)Set DMA data bytes 
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_RBCR1, 0x00);
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_RBCR0, 0x04);

//  (2)Set DMA start points
    if(bnry >= 0x5f) bnry_1 = 0x46;
    else bnry_1 = bnry + 1 ;
// 
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_RSAR1, bnry_1);
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_RSAR0, 0x00);

//  (3)Start Remote read 
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_CR, (unsigned char)0x0A);

//  (4)Read buffer 
    RTL8019_READ_REGISTER_REC(PI_REG_ADDR_DMAPORT, &frame_manager[0]);   //RSR register
    RTL8019_READ_REGISTER_REC(PI_REG_ADDR_DMAPORT, &frame_manager[1]);   //Next paket point 
    RTL8019_READ_REGISTER_REC(PI_REG_ADDR_DMAPORT, &frame_manager[2]);   //recive paket size low
    RTL8019_READ_REGISTER_REC(PI_REG_ADDR_DMAPORT, &frame_manager[3]);   //recive paket size High

//  (5)Calculate size 
    data_point = 0;
    data_size  = (unsigned int)frame_manager[3] * 0xff + (unsigned int)frame_manager[2];

//  (6)Check read error 
    if((frame_manager[0] & 0b00000001) == 0){
        bnry = bnry + (( data_size + 4 ) / 256 + 1);
        if(bnry > last_page) bnry = bnry - last_page - 1;
        RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_BNRY, bnry); 
        *data_length = 0;
        return(PI_ERR_READERR);
    }

// *********************
//  9.Page reverse
// *********************
    tmp_size   = ( last_page - bnry ) * 0xff + 0xff - 4;   //Caution: 4 Bytes Frame Management record 
    if( tmp_size < data_size){
        tmp_size_1 = data_size - tmp_size;
        tmp_size_2 = data_size - tmp_size_1;
    }

// *********************
//  10.Read Data
// *********************
//  (1)Set DMA data bytes 
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_RBCR1, frame_manager[3]);   //size high
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_RBCR0, frame_manager[2]);   //size low

//  (2)Set DMA start points
    if(bnry >= 0x5f) bnry_1 = 0x46;
    else bnry_1 = bnry + 1 ;
// 
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_RSAR1,(unsigned char)bnry_1);
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_RSAR0, 0x04);

//  (3)Start Remote read 
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_CR, (unsigned char)0x0A);

//  (4)Read buffer 
    for(lp=0;lp<data_size;lp++){
        if(data_point < PI_RECIVE_BUFMAX ){
            RTL8019_READ_REGISTER_REC(PI_REG_ADDR_DMAPORT, &out_data[data_point]);
            data_point++;
        }else{
            RTL8019_READ_REGISTER_REC(PI_REG_ADDR_DMAPORT, &tmp_c);
        }        
    }

//  (5)Update BNRY register 
    bnry = bnry + (( data_size + 4 ) / 256 + 1);
    if(bnry > last_page) bnry = bnry - last_page - 1 + min_page;
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_BNRY, bnry); 

//  (6)Set data length 
    *data_length = data_point;
    return(PI_NORMAL);

}

//******************************************************************************************
//   Function Name : RTL8019_BUFFOVER_PRC
//   Title         : RTL8019AS buffer overflow process
//   Input         : 
//   Output        :
//   Description   :
//******************************************************************************************
void RTL8019_BUFFOVER_PRC(void)
{
 

}

//******************************************************************************************
//   Function Name : RTL8019_WRITE_SNDBUF
//   Title         : RTL8019AS write send buffer
//   Input         : 
//   Output        :
//   Description   : Remote DMA send ( Start point 4000h[define TPSR register]) 
//******************************************************************************************
char RTL8019_WRITE_SNDBUF(unsigned char in_data[], unsigned int  data_length )
{
    unsigned char len1,len0;
    unsigned int  lp;
    unsigned char tmp_c;

// *********************
//  0.Initialize
// *********************
    len0 = (unsigned char)(data_length & 0x00ff);
    len1 = (unsigned char)((data_length & 0xff00) >> 8);

// *********************
//  1.Clear Remote DMA
// *********************
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_ISR, (unsigned char)0x40);

// *********************
//  2.Set RSAR and RBCR register
// *********************
// (1)Start point 0x4000
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_RSAR1, (unsigned char)0x40);
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_RSAR0, (unsigned char)0x00);

// (2)Paket length
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_RBCR1, len1);
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_RBCR0, len0);

// *********************
//  3.Set CR register
// *********************
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_CR, (unsigned char)0x12);

// *********************
//  4.Write send buffer
// *********************
    for(lp=0;lp<data_length;lp++){
        RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_DMAPORT, in_data[lp]);
    }

// *********************
//  5.Check flag
// *********************
    while(1){
        RTL8019_READ_REGISTER_REC(PI_REG_ADDR_ISR, &tmp_c);
        if((tmp_c & 0b01000000) != 0)break;
    }
    return(PI_NORMAL);
}

//******************************************************************************************
//   Function Name : RTL8019_UPDATE_REGISTER
//   Title         : RTL8019AS update register
//   Input         : 
//   Output        :
//******************************************************************************************
void RTL8019_UPDATE_REGISTER(unsigned char in_register, unsigned char in_register_page, 
                             unsigned char in_position, unsigned char bit_value)
{
    unsigned char tmp_reg_buffer;
// *********************
//  1.Set page
// *********************
    RTL8019_SET_REGISTER_PAGE(in_register_page);

// *********************
//  2.Read register
// *********************
    RTL8019_READ_REGISTER_REC(in_register, &tmp_reg_buffer);

// *********************
//  3.Update record
// *********************
    if(bit_value == 0){
        tmp_reg_buffer &= ~( 1 << in_position );
    }else{
        tmp_reg_buffer |= ( 1 << in_position );
    }

// *********************
//  4.Write register
// *********************   
    RTL8019_WRITE_REGISTER_REC(in_register,tmp_reg_buffer);
}

//******************************************************************************************
//   Function Name : RTL8019_READ_REGISTER
//   Title         : RTL8019AS read register
//   Input         : in_register[I]:register address, in_register_page[I]:register page
//   Output        : *reg_value[O]:Result value
//******************************************************************************************
void RTL8019_READ_REGISTER(unsigned char in_register, unsigned char in_register_page, unsigned char *reg_value)
{
// *********************
//  1.Set page
// *********************
    RTL8019_SET_REGISTER_PAGE(in_register_page);

// *********************
//  2.Read register
// *********************
    RTL8019_READ_REGISTER_REC(in_register, reg_value);
}

//******************************************************************************************
//   Function Name : RTL8019_WRITE_REGISTER
//   Title         : RTL8019AS write register
//   Input         : in_register[I]:register address, in_register_page[I]:register page, reg_value[I]:Value
//   Output        :
//******************************************************************************************
void RTL8019_WRITE_REGISTER(unsigned char in_register, unsigned char in_register_page, unsigned char reg_value)
{
// *********************
//  1.Set page
// *********************
    RTL8019_SET_REGISTER_PAGE(in_register_page);

// *********************
//  2.Write register
// *********************   
    RTL8019_WRITE_REGISTER_REC(in_register,reg_value);

}

//******************************************************************************************
//   Function Name : RTL8019_SET_REGISTER_PAGE
//   Title         : RTL8019AS set register page
//   Input         : 
//   Output        :
//******************************************************************************************
void RTL8019_SET_REGISTER_PAGE(unsigned char in_page)
{
    unsigned char tmp_reg_buffer;

// *********************
//  1.Read register
// *********************
    RTL8019_READ_REGISTER_REC(PI_REG_ADDR_CR, &tmp_reg_buffer);

// *********************
//  2.Set page
// *********************
    switch(in_page){
        case  PI_REG_ADDR_0:
            tmp_reg_buffer &= 0b00111111 ;
            break;
        case  PI_REG_ADDR_1:
            tmp_reg_buffer &= 0b00111111 ;
            tmp_reg_buffer |= 0b01000000 ;
            break;
        case  PI_REG_ADDR_2:
            tmp_reg_buffer &= 0b00111111 ;
            tmp_reg_buffer |= 0b10000000 ;
            break;
        case  PI_REG_ADDR_3:
            tmp_reg_buffer |= 0b11000000 ;
            break;
        default:
            tmp_reg_buffer &= 0b00111111 ;
            break;
    }

// *********************
//  3.Write register
// *********************   
    RTL8019_WRITE_REGISTER_REC(PI_REG_ADDR_CR,tmp_reg_buffer);

}

//******************************************************************************************
//   Function Name : RTL8019_READ_REGISTER_REC
//   Title         : RTL8019AS read register 1 record
//   Input         : 
//   Output        :
//******************************************************************************************
void RTL8019_READ_REGISTER_REC(unsigned char in_register, unsigned char *reg_value)
{
    unsigned char tmp_c;

// *********************
//  1.Default
// *********************
    RTL8019_SD_GET(&tmp_c);   // Set TRISn Read
    RTL8019_RB_ON();
    RTL8019_WB_ON();
    RTL8019_CHRDY_ON();
    Wait_above_1uS((unsigned int)1); 

// *********************
//  2.Main process
// *********************
//  (1)Set Register Address
    RTL8019_SA_PUT(in_register);
    Wait_above_1uS((unsigned int)1);  //  > 20nS 

//  (2)Set IORB bit
    RTL8019_RB_OFF();
    Wait_above_1uS((unsigned int)1);  //  > 50nS

//  (3)Set IOCHRDY bit
    RTL8019_CHRDY_OFF();
    Wait_above_1uS((unsigned int)1);  //  > 60nS from setting a IORB bit

//  (4)Get data
    RTL8019_SD_GET(reg_value);

// *********************
//  3.Function End
// *********************
    RTL8019_CHRDY_ON();
    RTL8019_RB_ON();
    Wait_above_1uS((unsigned int)1); 
}

//******************************************************************************************
//   Function Name : RTL8019_WRITE_REGISTER_REC
//   Title         : RTL8019AS write register 1 record
//   Input         : 
//   Output        :
//******************************************************************************************
void RTL8019_WRITE_REGISTER_REC(unsigned char in_register, unsigned char reg_value)
{
    unsigned char tmp_c;

// *********************
//  1.Default
// ********************* 
    RTL8019_RB_ON();
    RTL8019_WB_ON();
    RTL8019_CHRDY_ON();
    Wait_above_1uS((unsigned int)1); 

// *********************
//  2.Main process
// *********************
//  (1)Set Register Address
    RTL8019_SA_PUT(in_register);
    Wait_above_1uS((unsigned int)1);  //  > 20nS 

//  (2)Set IOWB bit
    RTL8019_WB_OFF();
    Wait_above_1uS((unsigned int)1);  //  > 50nS

//  (3)Put data
    RTL8019_SD_PUT(reg_value);
    Wait_above_1uS((unsigned int)1); 

//  (4)Set IOCHRDY bit
    RTL8019_CHRDY_OFF();
    Wait_above_1uS((unsigned int)1); 

// *********************
//  3.Function End
// *********************
    RTL8019_CHRDY_ON();
    RTL8019_WB_ON();
    RTL8019_SD_GET(&tmp_c);   // Set TRISn Read
    Wait_above_1uS((unsigned int)1); 
}

//******************************************************************************************
//   Function Name : PIC_PUT_PORT *
//   Title         : 
//   Input         : 
//   Output        :
//******************************************************************************************
void PIC_PUT_PORT(unsigned char put_data)
{
    TRISC = 0b00000000; 
    PORTC = put_data;
}

//******************************************************************************************
//   Function Name : RTL8019_RB_ON *
//   Title         : RTL8019AS(IORB)  High Level
//   Input         : 
//   Output        :
//******************************************************************************************
void RTL8019_RB_ON(void)
{
    PORTE |= 0b00000001;
}

//******************************************************************************************
//   Function Name : RTL8019_RB_OFF *
//   Title         : RTL8019AS(IORB)  Low Level
//   Input         : 
//   Output        :
//******************************************************************************************
void RTL8019_RB_OFF(void)
{
    PORTE &= 0b11111110 ;
}

//******************************************************************************************
//   Function Name : RTL8019_WB_ON *
//   Title         : RTL8019AS(IOWB)  High Level
//   Input         : 
//   Output        :
//******************************************************************************************
void RTL8019_WB_ON(void)
{
    PORTE |= 0b00000010;
}

//******************************************************************************************
//   Function Name : RTL8019_WB_OFF *
//   Title         : RTL8019AS(IOWB)  Low Level
//   Input         : 
//   Output        :
//******************************************************************************************
void RTL8019_WB_OFF(void)
{
    PORTE &= 0b11111101 ;
}

//******************************************************************************************
//   Function Name : RTL8019_RST_ON *
//   Title         : RTL8019AS(RSTDRV)  High Level
//   Input         : 
//   Output        :
//******************************************************************************************
void RTL8019_RST_ON(void)
{
    PORTE |= 0b00000100;
}

//******************************************************************************************
//   Function Name : RTL8019_RST_OFF *
//   Title         : RTL8019AS(RSTDRV)  Low Level
//   Input         : 
//   Output        :
//******************************************************************************************
void RTL8019_RST_OFF(void)
{
    PORTE &= 0b11111011 ;
}

//******************************************************************************************
//   Function Name : RTL8019_CHRDY_ON *
//   Title         : RTL8019AS(IOCHRDY)  High Level
//   Input         : 
//   Output        :
//******************************************************************************************
void RTL8019_CHRDY_ON(void)
{
    PORTA |= 0b00001000;
}

//******************************************************************************************
//   Function Name : RTL8019_CHRDY_OFF *
//   Title         : RTL8019AS(IOCHRDY)  Low Level
//   Input         : 
//   Output        :
//******************************************************************************************
void RTL8019_CHRDY_OFF(void)
{
    PORTA &= 0b11110111 ;
}

//******************************************************************************************
//   Function Name : RTL8019_SD_PUT *
//   Title         : RTL8019AS(SD)  Put data
//   Input         : 
//   Output        :
//******************************************************************************************
void RTL8019_SD_PUT(unsigned char put_dat)
{
    TRISD = 0x00;
    PORTD = put_dat;
}

//******************************************************************************************
//   Function Name : RTL8019_SD_GET *
//   Title         : RTL8019AS(SD)  Get data
//   Input         : 
//   Output        :
//******************************************************************************************
void RTL8019_SD_GET(unsigned char *get_dat)
{
    TRISD    = 0xFF;
    *get_dat = PORTD;
}

//******************************************************************************************
//   Function Name : RTL8019_SA_PUT *
//   Title         : RTL8019AS(SD)  Put address
//   Input         : 
//   Output        :
//******************************************************************************************
void RTL8019_SA_PUT(unsigned char put_dat)
{
    PORTB = ( put_dat & 0b00011111 );
}

//******************************************************************************************
//   Function Name : Init_ADC
//   Title         : 
//   Input         : 
//   Output        :
//   Description   : Selected AN0
//******************************************************************************************
void Init_ADC(void)
{
// *******************************************************
// 1.Define ADCON0(A/D CONTROL REGISTER 0) Register  
//     ADCON0(7-6) Unimplemented: Read as e0f
//     ADCON0(5-2) CHS3:CHS0: Analog Channel Select bits
//         0000 = Channel 0 (AN0)
//         0001 = Channel 1 (AN1)
//         0010 = Channel 2 (AN2)
//         0011 = Channel 3 (AN3)
//         0100 = Channel 4 (AN4)
//         0101 = Channel 5 (AN5)(1,2)
//         0110 = Channel 6 (AN6)(1,2)
//         0111 = Channel 7 (AN7)(1,2)
//         1000 = Channel 8 (AN8)
//         1001 = Channel 9 (AN9)
//         1010 = Channel 10 (AN10)
//         1011 = Channel 11 (AN11)
//         1100 = Channel 12 (AN12)
//         1101 = Unimplemented)(2)
//         1110 = Unimplemented)(2)
//         1111 = Unimplemented)(2)
//     ADCON0(1) GO/DONE: A/D Conversion Status bit
//         When ADON = 1:
//            1 = A/D conversion in progress
//         0 = A/D Idle
//     ADCON0(0) ADON: A/D On bit
//            1 = A/D Converter module is enabled
//            0 = A/D Converter module is disabled
// *******************************************************
    ADCON0 = 0b00000001;

// *******************************************************
// 2.Define ADCON1(A/D CONTROL REGISTER 1) Register  
//     ADCON1(7-6) Unimplemented: Read as e0f
//     ADCON1(5) VCFG1: Voltage Reference Configuration bit (VREF- source)
//           1 = VREF- (AN2)
//           0 = VSS
//     ADCON1(4) VCFG0: Voltage Reference Configuration bit (VREF+ source)
//           1 = VREF+ (AN3)
//           0 = VDD
//     ADCON1(3-0) PCFG3:PCFG0: A/D Port Configuration Control bits:
//                     12 11 10  9  8  7  6  5  4  3  2  1  0 
//                0000  A  A  A  A  A  A  A  A  A  A  A  A  A
//                0001  A  A  A  A  A  A  A  A  A  A  A  A  A
//                0010  A  A  A  A  A  A  A  A  A  A  A  A  A
//                0011  D  A  A  A  A  A  A  A  A  A  A  A  A
//                0100  D  D  A  A  A  A  A  A  A  A  A  A  A
//                0101  D  D  D  A  A  A  A  A  A  A  A  A  A
//                0110  D  D  D  D  A  A  A  A  A  A  A  A  A
//                0111  D  D  D  D  D  A  A  A  A  A  A  A  A
//                1000  D  D  D  D  D  D  A  A  A  A  A  A  A
//                1001  D  D  D  D  D  D  D  A  A  A  A  A  A
//                1010  D  D  D  D  D  D  D  D  A  A  A  A  A
//                1011  D  D  D  D  D  D  D  D  D  A  A  A  A
//                1100  D  D  D  D  D  D  D  D  D  D  A  A  A
//                1101  D  D  D  D  D  D  D  D  D  D  D  A  A
//                1110  D  D  D  D  D  D  D  D  D  D  D  D  A
//                1111  D  D  D  D  D  D  D  D  D  D  D  D  D
// *******************************************************
    ADCON1 = 0b00001110;    //AN0 Degital Only

// *******************************************************
// 3.Define ADCON2(A/D CONTROL REGISTER 2) Register  
//     ADCON2(7) ADFM: A/D Result Format Select bit
//            1 = Right justified
//            0 = Left justified
//     ADCON2(6) Unimplemented: Read as e0f
//     ADCON2(5-3) ACQT2:ACQT0: A/D Acquisition Time Select bits
//           111 = 20 TAD
//           110 = 16 TAD
//           101 = 12 TAD
//           100 =  8 TAD
//           011 =  6 TAD
//           010 =  4 TAD
//           001 =  2 TAD
//           000 =  0 TAD
//     ADCON2(2-0) ADCS2:ADCS0: A/D Conversion Clock Select bits
//           111 = FRC (clock derived from A/D RC oscillator)
//           110 = FOSC/64
//           101 = FOSC/16
//           100 = FOSC/4
//           011 = FRC (clock derived from A/D RC oscillator)
//           010 = FOSC/32
//           001 = FOSC/8
//           000 = FOSC/2
// *******************************************************
    ADCON2 = 0b10111110;

}

//******************************************************************************************
//   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;            //18F4520 Only

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

// *****************
//  3.Edit data
// *****************
    *adc_data = Dat_H * 256 + Dat_L;

}

//******************************************************************************************
//   Function Name : Wait_above_1uS
//   Title         : Wait 1[uS] * n
//   Input         : 
//   Output        : 
//   Description   :    10(STEP),OSC:10MHz,PLL:ON 
//                      ==> 10MHz * 4(PLL) / 4(PIC) / 10 ==> 1MHz(1uS) 
//******************************************************************************************
void Wait_above_1uS(unsigned int n)
{
unsigned int lp;
for(lp=0;lp<n;lp++){
    _asm
    NOP
    NOP
    NOP
    NOP
    NOP
    NOP
    NOP
    NOP
    NOP
    NOP
    _endasm
    }
}

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

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

//******************************************************************************************
//  Function Name : Timer *
//  Title         : wait function (1mS)
//  Input         :
//  Output        :
//******************************************************************************************
void Timer(void)
{
// *******************************************************
// 1.Define T1CON(TIMER1 CONTROL REGISTER) Register
//*   T1CON(7)  RD16: 16-bit Read/Write Mode Enable bit
//                      1 = Enables register read/write of TImer1 in one 16-bit operation
//                      0 = Enables register read/write of Timer1 in two 8-bit operations
//*   T1CON(6)  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)  bit 0 TMR1ON: Timer1 On bit
//                      1 = Enables Timer1
//                      0 = Stops Timer1
// *******************************************************

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

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

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

}

//****************************************************************************
//   Function Name : Deb_dump
//   Title         : Debug UART dump
//   Input         : 
//   Output        : 
//   Description   : 
//****************************************************************************
void Deb_dump(unsigned char in_char)
{
    unsigned char in_char_h,in_char_l;
    unsigned char dmp_char_h,dmp_char_l;

    in_char_h = ( in_char >> 4 ) & 0b00001111;
    in_char_l =   in_char        & 0b00001111;

    switch(in_char_h){
        case  0x0a :  dmp_char_h = 'a'; break;
        case  0x0b :  dmp_char_h = 'b'; break;
        case  0x0c :  dmp_char_h = 'c'; break;
        case  0x0d :  dmp_char_h = 'd'; break;
        case  0x0e :  dmp_char_h = 'e'; break;
        case  0x0f :  dmp_char_h = 'f'; break;
        default:      dmp_char_h = in_char_h | 0x30 ;
    }

    switch(in_char_l){
        case  0x0a :  dmp_char_l = 'a'; break;
        case  0x0b :  dmp_char_l = 'b'; break;
        case  0x0c :  dmp_char_l = 'c'; break;
        case  0x0d :  dmp_char_l = 'd'; break;
        case  0x0e :  dmp_char_l = 'e'; break;
        case  0x0f :  dmp_char_l = 'f'; break;
        default:      dmp_char_l = in_char_l | 0x30 ;
    }

    SendUART('[');
    SendUART(dmp_char_h );
    SendUART(dmp_char_l );
    SendUART(']');
}

//****************************************************************************
//   Function Name : Init_USART *
//   Title         : 
//   Input         : 
//   Output        : 
//   Description   : 
//****************************************************************************
void Init_USART(void)
{
// *******************************************************
// 0.Define PORT
// *******************************************************
    TRISC |= 0b10000000;

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

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

// *******************************************************
// 3.Define BAUDCON(BAUD RATE CONTROL) Register
//    BAUDCON(7) ABDOVF: Auto-Baud Detect Overflow bit
//      Asynchronous mode:
//        1 = Auto-baud timer overflowed
//        0 = Auto-baud timer did not overflow
//    BAUDCON(6) RCIDL: Receive Idle Flag bit
//      Asynchronous mode:
//        1 = Receiver is Idle
//        0 = Start bit has been detected and the receiver is active
//    BAUDCON(5) RXDTP: Data/Receive Polarity Select bit
//      Asynchronous mode:
//        1 = Receive data (RX) is inverted (active-low)
//        0 = Receive data (RX) is not inverted (active-high)
//    BAUDCON(4) TXCKP: Clock/Transmit Polarity Select bit
//      Asynchronous mode:
//        1 = Idle state for transmit (TX) is low
//        0 = Idle state for transmit (TX) is high
//    BAUDCON(3) BRG16: 16-bit Baud Rate Generator bit
//        1 = 16-bit Baud Rate Generator is used (SPBRGH:SPBRG)
//        0 = 8-bit Baud Rate Generator is used (SPBRG)
//    BAUDCON(2) Unimplemented: Read as e0f
//    BAUDCON(1) WUE: Wake-up Enable bit
//      Asynchronous mode:
//        1 = Receiver is waiting for a falling edge. No character will be received but RCIF will be set on 
//            the falling edge. WUE will automatically clear on the rising edge.
//        0 = Receiver is operating normally
//    BAUDCON(0) ABDEN: Auto-Baud Detect Enable bit
//      Asynchronous mode:
//        1 = Auto-Baud Detect mode is enabled (clears when auto-baud is complete)
//        0 = Auto-Baud Detect mode is disabled
// *******************************************************
    BAUDCON = 0b00001000;

// *******************************************************
// 3.Define BRG(EUSART Baud Rate Generator Register) Register
// *******************************************************
//  SYNC = 0, BRGH = 1, BRG16 = 1 or SYNC = 1, BRG16 = 1
//  BRG = 40000000(Hz)/4/9600(BPS)-1 ==> 0d1040 ==> 0x410 

// (1)Define SPBRGH(EUSART Baud Rate Generator Register, High Byte) Register
    SPBRGH = 0x4;

// (2)Define SPBRG(EUSART Baud Rate Generator Register, Low Byte) Register
    SPBRG = 0x10;

}

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

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