/***********************************************************************************************************************
* DISCLAIMER
* This software is supplied by Renesas Electronics Corporation and is only intended for use with Renesas products.
* No other uses are authorized. This software is owned by Renesas Electronics Corporation and is protected under all
* applicable laws, including copyright laws. 
* THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING THIS SOFTWARE, WHETHER EXPRESS, IMPLIED
* OR STATUTORY, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NON-INFRINGEMENT.  ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY
* LAW, NEITHER RENESAS ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE FOR ANY DIRECT,
* INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR
* ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
* Renesas reserves the right, without notice, to make changes to this software and to discontinue the availability 
* of this software. By using this software, you agree to the additional terms and conditions found by accessing the 
* following link:
* http://www.renesas.com/disclaimer
*
* Copyright (C) 2011, 2018 Renesas Electronics Corporation. All rights reserved.
***********************************************************************************************************************/

/***********************************************************************************************************************
* File Name    : r_main.c
* Version      : CodeGenerator for RL78/G14 V2.05.02.10 [30 May 2018]
* Device(s)    : R5F104PK
* Tool-Chain   : CCRL
* Description  : This file implements main function.
* Creation Date: 2019/02/10
***********************************************************************************************************************/

/***********************************************************************************************************************
Includes
***********************************************************************************************************************/
#include "r_cg_macrodriver.h"
#include "r_cg_cgc.h"
#include "r_cg_port.h"
#include "r_cg_serial.h"
#include "r_cg_adc.h"
#include "r_cg_timer.h"
/* Start user code for include. Do not edit comment generated here */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
/* End user code. Do not edit comment generated here */
#include "r_cg_userdefine.h"

/***********************************************************************************************************************
Pragma directive
***********************************************************************************************************************/
/* Start user code for pragma. Do not edit comment generated here */
/* End user code. Do not edit comment generated here */

/***********************************************************************************************************************
Global variables and functions
***********************************************************************************************************************/
/* Start user code for global. Do not edit comment generated here */
#define PI_NORMAL         0
#define PI_FAILER         1
#define PI_RETURN_H       2
#define PI_RETURN_L       3
#define PI_MODE_EXECL     4
#define PI_MODE_NOEXECL   5
#define PI_MODE_EEP_WRITE 6
#define PI_INTR_ON        7
#define PI_INTR_OFF       8
#define PI_FELICA         9
#define PI_TYPE_A         10
#define PI_TYPE_B         11
#define PI_ISO15693       12
#define PI_ALL            13
//
#define PI_TIM_CAN_CS_0   100
#define PI_TIM_CAN_CS_1   100
#define PI_TIM_CAN_CS_W1  100

#define PI_M_MV_FOR_DEF   100
#define PI_M_MV_REV_DEF   2500
//
#define PI_CANSPI_CMD_RESET     0b11000000
#define PI_CANSPI_CMD_READ      0b00000011
#define PI_CANSPI_CMD_RDRXB0    0b10010000
#define PI_CANSPI_CMD_RDRXB1    0b10010010
#define PI_CANSPI_CMD_RDRXB2    0b10010100
#define PI_CANSPI_CMD_RDRXB3    0b10010110
#define PI_CANSPI_CMD_WRITE     0b00000010
#define PI_CANSPI_CMD_LDTXB0    0b01000000
#define PI_CANSPI_CMD_LDTXB1    0b01000001
#define PI_CANSPI_CMD_LDTXB2    0b01000010
#define PI_CANSPI_CMD_LDTXB3    0b01000011
#define PI_CANSPI_CMD_LDTXB4    0b01000100
#define PI_CANSPI_CMD_LDTXB5    0b01000101
#define PI_CANSPI_CMD_LDTXB6    0b01000110
#define PI_CANSPI_CMD_LDTXB7    0b01000111
#define PI_CANSPI_CMD_RTS0      0b10000001
#define PI_CANSPI_CMD_RTS1      0b10000010
#define PI_CANSPI_CMD_RTS2      0b10000100
#define PI_CANSPI_CMD_RDSTAT    0b10100000
#define PI_CANSPI_CMD_RXSTAT    0b10110000
#define PI_CANSPI_CMD_BITMOD    0b00000101
//
#define PI_CANSPI_REGADDR_RXF0SIDH  0b00000000
#define PI_CANSPI_REGADDR_RXF0SIDL  0b00000001
#define PI_CANSPI_REGADDR_RXF0EID8  0b00000010
#define PI_CANSPI_REGADDR_RXF0EID0  0b00000011
#define PI_CANSPI_REGADDR_RXF1SIDH  0b00000100
#define PI_CANSPI_REGADDR_RXF1SIDL  0b00000101
#define PI_CANSPI_REGADDR_RXF1EID8  0b00000110
#define PI_CANSPI_REGADDR_RXF1EID0  0b00000111
#define PI_CANSPI_REGADDR_RXF2SIDH  0b00001000
#define PI_CANSPI_REGADDR_RXF2SIDL  0b00001001
#define PI_CANSPI_REGADDR_RXF2EID8  0b00001010
#define PI_CANSPI_REGADDR_RXF2EID0  0b00001011
#define PI_CANSPI_REGADDR_BFPCTRL   0b00001100
#define PI_CANSPI_REGADDR_TXRTSCTRL 0b00001101
#define PI_CANSPI_REGADDR_CANSTAT   0b00001110
#define PI_CANSPI_REGADDR_CANCTRL   0b00001111
//
#define PI_CANSPI_REGADDR_RXF3SIDH  0b00010000
#define PI_CANSPI_REGADDR_RXF3SIDL  0b00010001
#define PI_CANSPI_REGADDR_RXF3EID8  0b00010010
#define PI_CANSPI_REGADDR_RXF3EID0  0b00010011
#define PI_CANSPI_REGADDR_RXF4SIDH  0b00010100
#define PI_CANSPI_REGADDR_RXF4SIDL  0b00010101
#define PI_CANSPI_REGADDR_RXF4EID8  0b00010110
#define PI_CANSPI_REGADDR_RXF4EID0  0b00010111
#define PI_CANSPI_REGADDR_RXF5SIDH  0b00011000
#define PI_CANSPI_REGADDR_RXF5SIDL  0b00011001
#define PI_CANSPI_REGADDR_RXF5EID8  0b00011010
#define PI_CANSPI_REGADDR_RXF5EID0  0b00011011
#define PI_CANSPI_REGADDR_TEC       0b00011100
#define PI_CANSPI_REGADDR_REC       0b00011101
#define PI_CANSPI_REGADDR_CANSTAT1  0b00011110
#define PI_CANSPI_REGADDR_CANCTRL1  0b00011111
//
#define PI_CANSPI_REGADDR_RXM0SIDH  0b00100000
#define PI_CANSPI_REGADDR_RXM0SIDL  0b00100001
#define PI_CANSPI_REGADDR_RXM0EID8  0b00100010
#define PI_CANSPI_REGADDR_RXM0EID0  0b00100011
#define PI_CANSPI_REGADDR_RXM1SIDH  0b00100100
#define PI_CANSPI_REGADDR_RXM1SIDL  0b00100101
#define PI_CANSPI_REGADDR_RXM1EID8  0b00100110
#define PI_CANSPI_REGADDR_RXM1EID0  0b00100111
#define PI_CANSPI_REGADDR_CNF3      0b00101000
#define PI_CANSPI_REGADDR_CNF2      0b00101001
#define PI_CANSPI_REGADDR_CNF1      0b00101010
#define PI_CANSPI_REGADDR_CANINTE   0b00101011
#define PI_CANSPI_REGADDR_CANINTF   0b00101100
#define PI_CANSPI_REGADDR_EFLG      0b00101101
#define PI_CANSPI_REGADDR_CANSTAT2  0b00101110
#define PI_CANSPI_REGADDR_CANCTRL2  0b00101111
//
#define PI_CANSPI_REGADDR_TXB0CTRL  0b00110000
#define PI_CANSPI_REGADDR_TXB0SIDH  0b00110001
#define PI_CANSPI_REGADDR_TXB0SIDL  0b00110010
#define PI_CANSPI_REGADDR_TXB0EID8  0b00110011
#define PI_CANSPI_REGADDR_TXB0EID0  0b00110100
#define PI_CANSPI_REGADDR_TXB0DLC   0b00110101
#define PI_CANSPI_REGADDR_TXB0D0    0b00110110
#define PI_CANSPI_REGADDR_TXB0D1    0b00110111
#define PI_CANSPI_REGADDR_TXB0D2    0b00111000
#define PI_CANSPI_REGADDR_TXB0D3    0b00111001
#define PI_CANSPI_REGADDR_TXB0D4    0b00111010
#define PI_CANSPI_REGADDR_TXB0D5    0b00111011
#define PI_CANSPI_REGADDR_TXB0D6    0b00111100
#define PI_CANSPI_REGADDR_TXB0D7    0b00111101
#define PI_CANSPI_REGADDR_CANSTAT3  0b00111110
#define PI_CANSPI_REGADDR_CANCTRL3  0b00111111
//
#define PI_CANSPI_REGADDR_TXB1CTRL  0b01000000
#define PI_CANSPI_REGADDR_TXB1SIDH  0b01000001
#define PI_CANSPI_REGADDR_TXB1SIDL  0b01000010
#define PI_CANSPI_REGADDR_TXB1EID8  0b01000011
#define PI_CANSPI_REGADDR_TXB1EID0  0b01000100
#define PI_CANSPI_REGADDR_TXB1DLC   0b01000101
#define PI_CANSPI_REGADDR_TXB1D0    0b01000110
#define PI_CANSPI_REGADDR_TXB1D1    0b01000111
#define PI_CANSPI_REGADDR_TXB1D2    0b01001000
#define PI_CANSPI_REGADDR_TXB1D3    0b01001001
#define PI_CANSPI_REGADDR_TXB1D4    0b01001010
#define PI_CANSPI_REGADDR_TXB1D5    0b01001011
#define PI_CANSPI_REGADDR_TXB1D6    0b01001100
#define PI_CANSPI_REGADDR_TXB1D7    0b01001101
#define PI_CANSPI_REGADDR_CANSTAT4  0b01001110
#define PI_CANSPI_REGADDR_CANCTRL4  0b01001111
//
#define PI_CANSPI_REGADDR_TXB2CTRL  0b01010000
#define PI_CANSPI_REGADDR_TXB2SIDH  0b01010001
#define PI_CANSPI_REGADDR_TXB2SIDL  0b01010010
#define PI_CANSPI_REGADDR_TXB2EID8  0b01010011
#define PI_CANSPI_REGADDR_TXB2EID0  0b01010100
#define PI_CANSPI_REGADDR_TXB2DLC   0b01010101
#define PI_CANSPI_REGADDR_TXB2D0    0b01010110
#define PI_CANSPI_REGADDR_TXB2D1    0b01010111
#define PI_CANSPI_REGADDR_TXB2D2    0b01011000
#define PI_CANSPI_REGADDR_TXB2D3    0b01011001
#define PI_CANSPI_REGADDR_TXB2D4    0b01011010
#define PI_CANSPI_REGADDR_TXB2D5    0b01011011
#define PI_CANSPI_REGADDR_TXB2D6    0b01011100
#define PI_CANSPI_REGADDR_TXB2D7    0b01011101
#define PI_CANSPI_REGADDR_CANSTAT5  0b01011110
#define PI_CANSPI_REGADDR_CANCTRL5  0b01011111
//
#define PI_CANSPI_REGADDR_RXB0CTRL  0b01100000
#define PI_CANSPI_REGADDR_RXB0SIDH  0b01100001
#define PI_CANSPI_REGADDR_RXB0SIDL  0b01100010
#define PI_CANSPI_REGADDR_RXB0EID8  0b01100011
#define PI_CANSPI_REGADDR_RXB0EID0  0b01100100
#define PI_CANSPI_REGADDR_RXB0DLC   0b01100101
#define PI_CANSPI_REGADDR_RXB0D0    0b01100110
#define PI_CANSPI_REGADDR_RXB0D1    0b01100111
#define PI_CANSPI_REGADDR_RXB0D2    0b01101000
#define PI_CANSPI_REGADDR_RXB0D3    0b01101001
#define PI_CANSPI_REGADDR_RXB0D4    0b01101010
#define PI_CANSPI_REGADDR_RXB0D5    0b01101011
#define PI_CANSPI_REGADDR_RXB0D6    0b01101100
#define PI_CANSPI_REGADDR_RXB0D7    0b01101101
#define PI_CANSPI_REGADDR_CANSTAT6  0b01101110
#define PI_CANSPI_REGADDR_CANCTRL6  0b01101111
//
#define PI_CANSPI_REGADDR_RXB1CTRL  0b01110000
#define PI_CANSPI_REGADDR_RXB1SIDH  0b01110001
#define PI_CANSPI_REGADDR_RXB1SIDL  0b01110010
#define PI_CANSPI_REGADDR_RXB1EID8  0b01110011
#define PI_CANSPI_REGADDR_RXB1EID0  0b01110100
#define PI_CANSPI_REGADDR_RXB1DLC   0b01110101
#define PI_CANSPI_REGADDR_RXB1D0    0b01110110
#define PI_CANSPI_REGADDR_RXB1D1    0b01110111
#define PI_CANSPI_REGADDR_RXB1D2    0b01111000
#define PI_CANSPI_REGADDR_RXB1D3    0b01111001
#define PI_CANSPI_REGADDR_RXB1D4    0b01111010
#define PI_CANSPI_REGADDR_RXB1D5    0b01111011
#define PI_CANSPI_REGADDR_RXB1D6    0b01111100
#define PI_CANSPI_REGADDR_RXB1D7    0b01111101
#define PI_CANSPI_REGADDR_CANSTAT7  0b01111110
#define PI_CANSPI_REGADDR_CANCTRL7  0b01111111
//


#define PI_SPI_DATMAX           20
#define PI_UART_DATMAX          20
#define PI_UART_R_DATMAX        20
#define PI_CANSPI_DATAMAX       8

volatile unsigned char G_arv_char      ;
volatile unsigned char G_arv_char2     ;
volatile uint16_t      G_buffer16      ;
volatile unsigned char G_SPI_data[PI_SPI_DATMAX];
volatile unsigned char G_SPI_read_data[PI_SPI_DATMAX];
volatile unsigned char G_SPI_data_num;
volatile unsigned char G_UART_data[PI_UART_DATMAX];
volatile unsigned char G_UART_read_data[PI_UART_R_DATMAX];
volatile unsigned char G_UART_data_num;
volatile unsigned char G_UART_read_data_num;
volatile uint8_t       G_TAU0_Channel1_tim_flag;
volatile uint8_t       G_TAU0_Channel1_LN_put_flag;
//
volatile uint16_t      G_CANSPI_DATA_IDEN;                        //CAN Identifier
volatile unsigned char G_CANSPI_DATA_DLC;                         //CAN Data Length Code
volatile unsigned char G_CANSPI_DATA_DATA[PI_CANSPI_DATAMAX];     //CAN DATA (Max 8)
volatile unsigned char G_CANSPI_DATA_DATA_num;                    //CAN DATA number
volatile unsigned char G_CANSPI_DATA_ID1;
volatile unsigned char G_CANSPI_DATA_ID2;
//
void Program_main(void)    ;
//
void uart0_echo(void)         ;
void uart0_POSE_KEY(void)     ;
void uart0_message(uint8_t  *);
void uart0_dump(unsigned char);
void uart0_dump_b(unsigned char);
//
void TMR0_wait(unsigned int)  ;
void TMR0_M_wait(unsigned int);
//
void CANSPI_CS_H(void);
void CANSPI_CS_L(void);
void CANSPI_RST_H(void);
void CANSPI_RST_L(void);
char CANSPI_CHK_INT(void);
void CANSPI_CAN_exec(void);
void CANSPI_CAN_setdatfld(void);
void CANSPI_data(unsigned char );
void CANSPI_rts(unsigned char  );
void CANSPI_mod(unsigned char, unsigned char , unsigned char , unsigned char  );
void CANSPI_io(unsigned char , unsigned char , unsigned char  );
void CANSPI_init(void);
void CANSPI_test(void);
//
void SPI_CHK_SSR02(char);
void SPI_CHK_SSR03(char);

/* End user code. Do not edit comment generated here */
void R_MAIN_UserInit(void);

/***********************************************************************************************************************
* Function Name: main
* Description  : This function implements main function.
* Arguments    : None
* Return Value : None
***********************************************************************************************************************/
void main(void)
{
    R_MAIN_UserInit();
    /* Start user code. Do not edit comment generated here */     
    while (1U)
    {
        Program_main();       
    }
    /* End user code. Do not edit comment generated here */
}

/***********************************************************************************************************************
* Function Name: R_MAIN_UserInit
* Description  : This function adds user code before implementing main function.
* Arguments    : None
* Return Value : None
***********************************************************************************************************************/
void R_MAIN_UserInit(void)
{
    /* Start user code. Do not edit comment generated here */
    EI();
    R_TAU0_Create();
    R_PORT_Create();
    R_SAU0_Create(); 
    R_UART0_Start();  
    R_CSI11_Create();  
    CANSPI_init();
    uart0_message((uint8_t  *)"RL78/G14 (Tx0) Connected OK >");
    R_CSI11_Start(); 	
     
    /* End user code. Do not edit comment generated here */
}

/* Start user code for adding. Do not edit comment generated here */


/***********************************************************************************************************************
* Function Name:  Program_main
* Description  :  This function is the user's main program .
*                 If you do not write the main program here, it will disappear when you generate it .
* Arguments    : 
* Return Value : None
***********************************************************************************************************************/
void Program_main(void)
{ 
  
    CANSPI_test();

}
 
/***********************************************************************************************************************
* Function Name: CANSPI_test
* Description  : This function is a test program of the SPI interface .
* Arguments    : 
* Return Value : None
* Caution !!!  : 
***********************************************************************************************************************/
void CANSPI_test(void)
{
    unsigned char lp;
    
// **********************************
//  1.Initialize
// **********************************
// (1) Initializes the MCP2515T device .
    CANSPI_init();

// **********************************
//  2.Setting register
//   ( Set Configuration mode )
// **********************************
// ============================================
//  A.Set the bound rate 
//    NBT = SyncSeg * TQ + PropSeg * TQ + PS1 * TQ + PS2 * TQ  
//    Feq = 1 / NBT
//    a)Default rate [OSC:20MHz] 
//       3  * ( 2 * 2 / 20[MHz] )     ==> 0.000 000 6[S]
//       1 / ( 3  * 2 * 2 / 20[MHz])  ==> 1.666 667[MHz] 
//    b)125[KBPS]    [OSC:20MHz]
//       1[S] / 125 000[BPS] ==> 0.000 008[S]
//       BRP:3 ==> TQ:0.6[uS],  SyncSeg:( 0.6 ) + PropSeg( 0.6 * 7 ) + PS1:( 0.6* 5 )  
//    c)125[KBPS]    [OSC:8MHz]
//       1[S] / 125 000[BPS] ==> 0.000 008[S]
//       BRP:1 ==> TQ:0.5[uS],  SyncSeg:( 0.5 ) + PropSeg( 0.5 * 7 ) + PS1:( 0.5* 7 )  
// ============================================
// (1)Switch to Configration mode to make special register setting
//      CANCTRL(CAN CONTROL REGISTER)
//         CANCTRL[7-5] REQOP: Request Operation Mode bits <2:0>
//              000 = Set Normal Operation mode
//              001 = Set Sleep mode
//              010 = Set Loopback mode
//              011 = Set Listen-only mode
//              100 = Set Configuration mode
//            All other values for REQOP bits are invalid and should not be used On power-up, REQOP = b�f111�f
//         CANCTRL[4] ABAT: Abort All Pending Transmissions bit
//                1 = Request abort of all pending transmit buffers           / 0 = Terminate request to abort all transmissions
//         CANCTRL[3] OSM: One Shot Mode bit
//                1 = Enabled. Message will only attempt to transmit one time / 0 = Disabled. Messages will reattempt transmission, if required
//         CANCTRL[2] CLKEN: CLKOUT Pin Enable bit
//                1 = CLKOUT pin enabled                                      / 0 = CLKOUT pin disabled (Pin is in high-impedance state)
//         CANCTRL[1-0] CLKPRE: CLKOUT Pin Prescaler bits <1:0>
//               00 = FCLKOUT = System Clock/1
//               01 = FCLKOUT = System Clock/2
//               10 = FCLKOUT = System Clock/4
//               11 = FCLKOUT = System Clock/8
    CANSPI_io((unsigned char)PI_CANSPI_CMD_WRITE, (unsigned char)PI_CANSPI_REGADDR_CANCTRL, (unsigned char)0b10000000 ); 
    TMR0_M_wait(1);    
    
// (2)Set Configration register
    CANSPI_io((unsigned char)PI_CANSPI_CMD_WRITE, (unsigned char)PI_CANSPI_REGADDR_CNF1, (unsigned char)(0b00000000 | 1));    // 125KHz
    TMR0_M_wait(1);    

    CANSPI_io((unsigned char)PI_CANSPI_CMD_WRITE, (unsigned char)PI_CANSPI_REGADDR_CNF2, (unsigned char)0b10111110 );         // 125KHz
    TMR0_M_wait(1);    
   
    CANSPI_io((unsigned char)PI_CANSPI_CMD_WRITE, (unsigned char)PI_CANSPI_REGADDR_CNF3, (unsigned char)0b00000000 ); 
    TMR0_M_wait(1);    
 
    
// ****************************************************
//  3.Starts CAN communication.
//    ( Set Normal Operation mode )
// ****************************************************	
    CANSPI_CAN_exec();

// ****************************************************
//  4.This function writes the data to be sent on the CAN into the buffer.
// ****************************************************	
    while(1){
//  4-1)Data A	    
//  (1)Write to the buffer
//    1-1)Set Identifier
        G_CANSPI_DATA_ID1 = 0b11110000;
        G_CANSPI_DATA_ID2 = 0b11100000;        //As Identifier is 12 bit data, it is set to the upper 3 bits
//    1-2)Set data number	
        G_CANSPI_DATA_DATA_num = 8;  
//    1-3)Set the data	
        for(lp=0;lp<G_CANSPI_DATA_DATA_num;lp++) {      
//          G_CANSPI_DATA_DATA[lp] = 0b11011011; 
            G_CANSPI_DATA_DATA[lp] = lp;
        }	
        CANSPI_CAN_setdatfld();

//  (2)Output from buffer to CAN line	
        G_SPI_data_num = 0;      
        CANSPI_data((unsigned char )PI_CANSPI_CMD_RTS0 );

        TMR0_M_wait(3000);    
	
//  4-2)Data B	    
//  (1)Write to the buffer
//    1-1)Set Identifier
        G_CANSPI_DATA_ID1 = 0b11110000;
        G_CANSPI_DATA_ID2 = 0b11100000;        //As Identifier is 12 bit data, it is set to the upper 3 bits
//    1-2)Set data number	
        G_CANSPI_DATA_DATA_num = 8;  
//    1-3)Set the data	
        for(lp=0;lp<G_CANSPI_DATA_DATA_num;lp++) {      
            G_CANSPI_DATA_DATA[lp] = 0b11110000; 
//          G_CANSPI_DATA_DATA[lp] = lp;
        }	
        CANSPI_CAN_setdatfld();

//  (2)Output from buffer to CAN line	
        G_SPI_data_num = 0;      
        CANSPI_data((unsigned char )PI_CANSPI_CMD_RTS0 );

        TMR0_M_wait(3000); 	
	

//  4-3)Data C	    
//  (1)Write to the buffer
//    1-1)Set Identifier
        G_CANSPI_DATA_ID1 = 0b00000011;
        G_CANSPI_DATA_ID2 = 0b00000000;        //As Identifier is 12 bit data, it is set to the upper 3 bits
//    1-2)Set data number	
        G_CANSPI_DATA_DATA_num = 8;  
//    1-3)Set the data	
        for(lp=0;lp<G_CANSPI_DATA_DATA_num;lp++) {      
            G_CANSPI_DATA_DATA[lp] = 0b11000011; 
//          G_CANSPI_DATA_DATA[lp] = lp;
        }	
        CANSPI_CAN_setdatfld();

//  (2)Output from buffer to CAN line	
        G_SPI_data_num = 0;      
        CANSPI_data((unsigned char )PI_CANSPI_CMD_RTS0 );

        TMR0_M_wait(3000); 		
    }        
}


/***********************************************************************************************************************
* Function Name: CANSPI_init
* Description  : This function initializes the MCP2515T device .
* Arguments    : 
* Return Value : None
* Caution !!!  : 
***********************************************************************************************************************/
void CANSPI_init(void)
{
// ******************************	
// 1.Set CS to H 	
// ******************************
    CANSPI_CS_H() ;
   
// ******************************  
// 2.Reset MCP2515T with SPI reset command .
// ****************************** 
    G_SPI_data_num = 0;
    CANSPI_data((unsigned char )PI_CANSPI_CMD_RESET );
    TMR0_M_wait(1)    ; 
 
    
}


/***********************************************************************************************************************
* Function Name: CANSPI_CAN_exec
* Description  : This function starts CAN communication .
* Arguments    : 
* Return Value : None
***********************************************************************************************************************/
void CANSPI_CAN_exec(void)
{
// *******************************************************	
// 1.Switch to Normal Mode to start CAN communication
//   (1)CANCTRL register : Default value 0b11100111
//      CANCTRL[7-5] REQOP: Request Operation Mode bits <2:0>
//         000 = Set Normal Operation mode
//         001 = Set Sleep mode
//         010 = Set Loopback mode
//         011 = Set Listen-only mode
//         100 = Set Configuration mode
//         All other values for REQOP bits are invalid and should not be used On power-up, REQOP = b�f111�f
//      CANCTRL[4] ABAT: Abort All Pending Transmissions bit
//         1 = Request abort of all pending transmit buffers
//         0 = Terminate request to abort all transmissions
//      CANCTRL[3] OSM: One Shot Mode bit
//         1 = Enabled. Message will only attempt to transmit one time
//         0 = Disabled. Messages will reattempt transmission, if required
//      CANCTRL[2] CLKEN: CLKOUT Pin Enable bit
//         1 = CLKOUT pin enabled
//         0 = CLKOUT pin disabled (Pin is in high-impedance state)
//      CANCTRL[1-0] CLKPRE: CLKOUT Pin Prescaler bits <1:0>
//        00 = FCLKOUT = System Clock/1
//        01 = FCLKOUT = System Clock/2
//        10 = FCLKOUT = System Clock/4
//        11 = FCLKOUT = System Clock/8
// *******************************************************
//  CANSPI_io((unsigned char)PI_CANSPI_CMD_WRITE, (unsigned char)PI_CANSPI_REGADDR_CANCTRL,  (unsigned char)0b00000000 ); 
    CANSPI_io((unsigned char)PI_CANSPI_CMD_WRITE, (unsigned char)PI_CANSPI_REGADDR_CANCTRL,  (unsigned char)0b00001000 ); 
    TMR0_M_wait(1);	
	
}	



/***********************************************************************************************************************
* Function Name: CANSPI_CAN_setdatfld
* Description  : This function writes transmit data to the register of MCP2515 .
* Arguments    : 
* Return Value : None
***********************************************************************************************************************/
void CANSPI_CAN_setdatfld(void)
{
    unsigned char tmp_register;
    unsigned char lp;

// ************************************************
//  1.Set Identifier
// ************************************************
    tmp_register = G_CANSPI_DATA_ID1; 
    CANSPI_io((unsigned char)PI_CANSPI_CMD_WRITE, (unsigned char)PI_CANSPI_REGADDR_TXB0SIDH,  (unsigned char)tmp_register ); 

    tmp_register = G_CANSPI_DATA_ID2; 
    CANSPI_io((unsigned char)PI_CANSPI_CMD_WRITE, (unsigned char)PI_CANSPI_REGADDR_TXB0SIDL,  (unsigned char)tmp_register ); 
  
// ************************************************
//  2.Set Data length code
// ************************************************    
    tmp_register = G_CANSPI_DATA_DATA_num;   
    CANSPI_io((unsigned char)PI_CANSPI_CMD_WRITE, (unsigned char)PI_CANSPI_REGADDR_TXB0DLC,  (unsigned char)tmp_register );   
   
// ************************************************
//  3.Set Data 
// ************************************************     
    G_SPI_data[0] = PI_CANSPI_REGADDR_TXB0D0 ;
    
    for(lp=0;lp<G_CANSPI_DATA_DATA_num;lp++) {       
        G_SPI_data[lp+1] = G_CANSPI_DATA_DATA[lp]; 
    }	
    G_SPI_data_num = G_CANSPI_DATA_DATA_num + 1;     
  
    CANSPI_data((unsigned char )PI_CANSPI_CMD_WRITE );	
    
}

/***********************************************************************************************************************
* Function Name: CANSPI_data
* Description  : This function transmits data collectively to the MCP2515 
* Arguments    : 
* Return Value : None
* Caution !!!  : 1.The SSR03 register must be dummy read !!!!!
*                  Therefore, if you omit the deb_reg variable, the program operation may become unstable !!!!!!
*                2.To change the variable returned from the function to the argument of the function, 
*                  please carefully read the memory area of this MPU and rewrite the program.
*                  Memory Aria handling is special, so you can not change it easily !!!!!
***********************************************************************************************************************/
void CANSPI_data(unsigned char in_inst )
{

    uint8_t  tx_buf ;
    uint16_t tx_num=1;
    uint8_t  rx_buf;  
    uint16_t deb_reg;
    unsigned char lp;    
//  uint16_t deb_reg[4];
//  uint8_t  lp        ;
//  uint16_t sdr02_data;
    
// ****************************** 
//  1.Output CS sinnal
// ****************************** 
    CANSPI_CS_L();
    TMR0_wait((unsigned int)PI_TIM_CAN_CS_0);
 
// ******************************    
//  2.Output Instruction
// ******************************  
    tx_buf =(uint8_t)in_inst; 
    deb_reg = SSR03;
    R_CSI11_Send_Receive(&tx_buf, tx_num, &rx_buf);    
    SPI_CHK_SSR03(PI_MODE_EXECL);    
    
// ******************************    
//  3.Output Instruction
// ******************************  	
    for(lp=0;lp<G_SPI_data_num;lp++){  
        tx_buf =(uint8_t)G_SPI_data[lp]; 
        deb_reg = SSR03;
        R_CSI11_Send_Receive(&tx_buf, tx_num, &rx_buf);    
        SPI_CHK_SSR03(PI_MODE_EXECL);      
    }	    

// ****************************** 
//  4.Output CS signal
// ******************************
    TMR0_wait((unsigned int)PI_TIM_CAN_CS_W1);
    CANSPI_CS_H();
    TMR0_wait((unsigned int)PI_TIM_CAN_CS_W1);
//  TMR0_wait((unsigned int)10);	
	
	
}

/***********************************************************************************************************************
* Function Name: CANSPI_rts
* Description  : REQUEST-TO-SEND (RTS) INSTRUCTION
* Arguments    : 
* Return Value : None
* Caution !!!  : 1.The SSR03 register must be dummy read !!!!!
*                  Therefore, if you omit the deb_reg variable, the program operation may become unstable !!!!!!
*                2.To change the variable returned from the function to the argument of the function, 
*                  please carefully read the memory area of this MPU and rewrite the program.
*                  Memory Aria handling is special, so you can not change it easily !!!!!
***********************************************************************************************************************/
void CANSPI_rts(unsigned char in_inst )
{
    uint8_t  tx_buf ;
    uint16_t tx_num=1;
    uint8_t  rx_buf;  
    uint16_t deb_reg;
    
// ****************************** 
//  1.Output CS sinnal
// ****************************** 
    CANSPI_CS_L();
    TMR0_wait((unsigned int)PI_TIM_CAN_CS_0);
 
// ******************************    
//  2.Output Instruction
// ******************************  
    tx_buf =(uint8_t)in_inst; 
    deb_reg = SSR03;
    R_CSI11_Send_Receive(&tx_buf, tx_num, &rx_buf);    
    SPI_CHK_SSR03(PI_MODE_EXECL);    
    
// ****************************** 
//  3.Output CS signal
// ******************************
    TMR0_wait((unsigned int)PI_TIM_CAN_CS_W1);
    CANSPI_CS_H();
    TMR0_wait((unsigned int)PI_TIM_CAN_CS_W1);
//  TMR0_wait((unsigned int)10);
    
    	
}

/***********************************************************************************************************************
* Function Name: CANSPI_mod
* Description  : This function modifies the register of MCP2515 by bit specification .
*                This is the version that specifies the mask of the register to be changed .
* Arguments    : 
* Return Value : None
* Caution !!!  : 1.The SSR03 register must be dummy read !!!!!
*                  Therefore, if you omit the deb_reg variable, the program operation may become unstable !!!!!!
*                2.To change the variable returned from the function to the argument of the function, 
*                  please carefully read the memory area of this MPU and rewrite the program.
*                  Memory Aria handling is special, so you can not change it easily !!!!!
***********************************************************************************************************************/
void CANSPI_mod(unsigned char in_inst, unsigned char in_addr,  unsigned char in_mask , unsigned char in_data )
{
    uint8_t  tx_buf ;
    uint16_t tx_num=1;
    uint8_t  rx_buf;  
    uint16_t deb_reg;
    
// ****************************** 
//  1.Output CS sinnal
// ****************************** 
    CANSPI_CS_L();
    TMR0_wait((unsigned int)PI_TIM_CAN_CS_0);
 
// ******************************    
//  2.Output Instruction
// ******************************  
    tx_buf =(uint8_t)in_inst; 
    deb_reg = SSR03;
    R_CSI11_Send_Receive(&tx_buf, tx_num, &rx_buf);    
    SPI_CHK_SSR03(PI_MODE_EXECL);    
//  sdr02_data =  rx_buf ;
    
// ****************************** 
//  3.Output 8-Bit Adress
// ****************************** 
    tx_buf =  (uint8_t)in_addr;
    deb_reg = SSR03;
    R_CSI11_Send_Receive(&tx_buf, tx_num, &rx_buf);
    SPI_CHK_SSR03(PI_MODE_EXECL);  
  
// ****************************** 
//  4.Output 8-Bit mask
// ****************************** 
    tx_buf =  (uint8_t)in_mask;
    deb_reg = SSR03;
    R_CSI11_Send_Receive(&tx_buf, tx_num, &rx_buf);
    SPI_CHK_SSR03(PI_MODE_EXECL);  
        
// ****************************** 
//  5.Output 8-Bit data
// ****************************** 
    tx_buf = (uint8_t)in_data;
    deb_reg = SSR03;
    R_CSI11_Send_Receive(&tx_buf, tx_num, &rx_buf);
    SPI_CHK_SSR03(PI_MODE_EXECL);
    deb_reg = SSR03;   
//  uart0_dump_b((unsigned char)rx_buf);
    G_arv_char = (unsigned char)rx_buf;
    
// ****************************** 
//  6.Output CS signal
// ******************************
    TMR0_wait((unsigned int)PI_TIM_CAN_CS_W1);
    CANSPI_CS_H();
    TMR0_wait((unsigned int)PI_TIM_CAN_CS_W1);
//  TMR0_wait((unsigned int)10);

}

/***********************************************************************************************************************
* Function Name: CANSPI_io
* Description  : This function read from MCP2515 and writes to MCP2515 with the SPI interface .
* Arguments    : 
* Return Value : None
* Caution !!!  : 1.The SSR03 register must be dummy read !!!!!
*                  Therefore, if you omit the deb_reg variable, the program operation may become unstable !!!!!!
*                2.To change the variable returned from the function to the argument of the function, 
*                  please carefully read the memory area of this MPU and rewrite the program.
*                  Memory Aria handling is special, so you can not change it easily !!!!!
***********************************************************************************************************************/
void CANSPI_io(unsigned char in_inst, unsigned char in_addr, unsigned char in_data )
{
    uint8_t  tx_buf ;
    uint16_t tx_num=1;
    uint8_t  rx_buf;  
    uint16_t deb_reg;
    
// ****************************** 
//  1.Output CS sinnal
// ****************************** 
    CANSPI_CS_L();
    TMR0_wait((unsigned int)PI_TIM_CAN_CS_0);
 
// ******************************    
//  2.Output Instruction
// ******************************  
    tx_buf =(uint8_t)in_inst; 
    deb_reg = SSR03;
    R_CSI11_Send_Receive(&tx_buf, tx_num, &rx_buf);    
    SPI_CHK_SSR03(PI_MODE_EXECL);    
//  sdr02_data =  rx_buf ;
    
// ****************************** 
//  3.Output 8-Bit Adress
// ****************************** 
    tx_buf =  (uint8_t)in_addr;
    deb_reg = SSR03;
    R_CSI11_Send_Receive(&tx_buf, tx_num, &rx_buf);
    SPI_CHK_SSR03(PI_MODE_EXECL);  
     
// ****************************** 
//  4.Output 8-Bit data
// ****************************** 
    tx_buf = (uint8_t)in_data;
    deb_reg = SSR03;
    R_CSI11_Send_Receive(&tx_buf, tx_num, &rx_buf);
    SPI_CHK_SSR03(PI_MODE_EXECL);
    deb_reg = SSR03;   
//  uart0_dump_b((unsigned char)rx_buf);
    G_arv_char = (unsigned char)rx_buf;
    
// ****************************** 
//  5.Output CS signal
// ******************************
    TMR0_wait((unsigned int)PI_TIM_CAN_CS_W1);
    CANSPI_CS_H();
    TMR0_wait((unsigned int)PI_TIM_CAN_CS_W1);
//  TMR0_wait((unsigned int)10);
     	
}


/***********************************************************************************************************************
* Function Name: SPI_CHK_SSR03
* Description  : 
* Arguments    : 
* Return Value : 
* important subjects :
*  1.Dummy read of SDR03 register can not be omitted !!!!!!!!
*    This dummy read clears the data accumulated in the SDR03 register and prevents overrun !!!!!!
*    It affects OVF02 of SSR03 register !!!!!!
***********************************************************************************************************************/
void SPI_CHK_SSR03(char in_mode)
{
    uint16_t  ssr03_data;
    uint16_t  sdr03_data;    // Do not omit this dummy variable  !!!!!!!

    if(in_mode ==  PI_MODE_NOEXECL ){	    
        sdr03_data =  SDR03;
        return;
    }

    while(1){
        if(((unsigned char)SSR03 & (unsigned char)0b01000000) == 0 ){
            sdr03_data =  SDR03;      // Do not skip this dummy read !!!!!!!!
            return;
        }		
    }	    
}

/***********************************************************************************************************************
* Function Name: uart0_POSE_KEY
* Description  : This function uses the UART0 pause function .
* Arguments    : 
* Return Value : None
***********************************************************************************************************************/
void uart0_POSE_KEY(void)
{
    uint8_t rtx_buf = 0x00;
    while((SSR01 & 0x0040)== 0){        //Check TSF01 (Recive) SSRmn(m:unit number[0,1]/n:channel number[0,1,2,3])
        R_UART0_Receive(&rtx_buf,(uint16_t)1); 
    }
}

/***********************************************************************************************************************
* Function Name: uart0_dump
* Description  : This function converts the character in hex code and outputs it to UART0
* Arguments    : Input char
* Return Value : None
***********************************************************************************************************************/
void uart0_dump(unsigned char in_c)
{
    int  in_i;
    char out_line[10];

    in_i = (int)in_c;
//  sprintf(out_line,"[%x(%c)]",in_i,in_i);
    sprintf(out_line,"[%2.2x]",in_i);
    uart0_message((uint8_t  *)out_line);
}

/***********************************************************************************************************************
* Function Name: uart0_dump_b
* Description  : This function converts the character in binary code and outputs it to UART0
* Arguments    : Input char
* Return Value : None
***********************************************************************************************************************/
void uart0_dump_b(unsigned char in_c)
{
    unsigned char i;
    unsigned char b[9];
    char out_line[2];
    unsigned char lp;      

    for (i = 0; in_c > 0; i++) {
        b[i] = in_c % 2;
        in_c = in_c / 2;    
    }   
    uart0_message((uint8_t  *)"(");

    for (lp = 0; lp < ( 8 - i ) ; lp++) {
        uart0_message((uint8_t  *)"0");
    }	   

    while (i > 0){
        sprintf(out_line,"%1.1d",  b[--i]);   
        uart0_message((uint8_t  *)out_line);
    }
    uart0_message((uint8_t  *)")");

}

/***********************************************************************************************************************
* Function Name: uart0_message
* Description  : This function is a sample program that outputs a message to UART0.

* Arguments    : None
* Return Value : None
***********************************************************************************************************************/
void uart0_message(uint8_t  *message)
{	
    while(*message != 0x00){        
        while((SSR00 & 0x0040)!= 0);         //Check TSF02 (Send)  SSRmn(m:unit number[0,1]/n:channel number[0,1,2,3])
        R_UART0_Send((uint8_t  *)message,(uint16_t)1);
        message++;
    }			 
}

/***********************************************************************************************************************
* Function Name: TMR0_M_wait
* Description  : This function waits for the specified time using the TIMER0 function .
* Arguments    : Input in_loop ( n *[uS])
* Return Value : None
***********************************************************************************************************************/
void TMR0_M_wait(unsigned int in_lp)
{
    for ( ; in_lp > 0  ; in_lp-- )
    {
        TMR0_wait((unsigned int)1000);
    } 
}

/***********************************************************************************************************************
* Function Name: TMR0_wait
* Description  : This function waits for the specified time using the TIMER0 function .
* Arguments    : Input in_loop ( n *[uS])
* Return Value : None
***********************************************************************************************************************/
void TMR0_wait(unsigned int in_lp)
{   
    R_TAU0_Channel0_Start();  

    for ( ; in_lp > 0  ; in_lp-- )
    {
        while ( TMIF00 == 0 )  
        {
            NOP();
        }
        TMIF00 = 0;    
    }

    R_TAU0_Channel0_Stop();   
}
  



/***********************************************************************************************************************
* Function Name: CANSPI_CS_H
* Description  : This function set CS signal (P4[1]) connected to SPI_CAN to H
* Arguments    : 
* Return Value : None
***********************************************************************************************************************/
void CANSPI_CS_H(void)
{
    P4  |= 0b00000010;	
}

/***********************************************************************************************************************
* Function Name: CANSPI_CS_L
* Description  : This function set CS signal (P4[1]) connected to SPI_CAN to L
* Arguments    : 
* Return Value : None
***********************************************************************************************************************/
void CANSPI_CS_L(void)
{
    P4  &= 0b11111101;	
}
 
/***********************************************************************************************************************
* Function Name: CANSPI_CHK_INT
* Description  : This function checks the Interrupt line (P4[6]) of the MCP2515T and returns the status
* Arguments    : 
* Return Value : None
* Caution      : 
***********************************************************************************************************************/
char CANSPI_CHK_INT(void)
{
    if((P4 & 0b01000000) != 0 ) 
        return(PI_RETURN_H);
    else 
        return(PI_RETURN_L);    
}

/* End user code. Do not edit comment generated here */