/*********************************************************************************************************************** * 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.05 [30 May 2018] * Device(s) : R5F104PJ * Tool-Chain : CCRL * Description : This file implements main function. * Creation Date: 2019/01/06 ***********************************************************************************************************************/ /*********************************************************************************************************************** Includes ***********************************************************************************************************************/ #include "r_cg_macrodriver.h" #include "r_cg_cgc.h" #include "r_cg_port.h" #include "r_cg_intc.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 #include #include #include /* 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 */ void put_message0(uint8_t *); void uart0_dump(unsigned char); void uart0_dump_b(unsigned char); void UART_POSE_KEY(void); void TMR0_wait(unsigned int); void TMR0_M_wait(unsigned int); void Program_main(void); void SPI_CAN_sample(void); void SPI_CAN_io(unsigned char, unsigned char, unsigned char ); void SPI_CAN_mod(unsigned char, unsigned char, unsigned char , unsigned char ); void SPI_CAN_rts(unsigned char ); void SPI_CAN_wrtdata(void); void CAN_CS_H(void); void CAN_CS_L(void); void SPI_CHK_SSR03(char); void SPI_CAN_init(void); void SPI_CAN_init_BK(void); void SPI_CAN_data(unsigned char ); #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_TIM_CAN_CS_0 100 #define PI_TIM_CAN_CS_1 100 #define PI_TIM_CAN_CS_W1 100 #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_CANSPI_DATMAX 20 unsigned char G_arv_char ; unsigned char G_arv_char2 ; volatile uint16_t G_buffer16 ; volatile unsigned char G_CAN_data[PI_CANSPI_DATMAX]; volatile unsigned char G_CAN_num; /* 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_PORT_Create(); R_SAU0_Create(); R_CSI11_Create(); CAN_CS_H(); 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) { SPI_CAN_sample(); while(1); } /*********************************************************************************************************************** * Function Name: SPI_CAN_sample * Description : This function is a sample program that sends and receives data by CAN communication . * Arguments : * Return Value : None ***********************************************************************************************************************/ void SPI_CAN_sample(void) { // **************************************************** // 1.This function initializes MCP2515. // **************************************************** SPI_CAN_init(); } /*********************************************************************************************************************** * Function Name: SPI_CAN_init * Description : This function initializes MCP2515. * Arguments : * Return Value : None ***********************************************************************************************************************/ void SPI_CAN_init(void) { unsigned char tmp_reg; // ***************************** // 1.Reset the MCP 2515 // ***************************** G_CAN_num = 0; SPI_CAN_data((unsigned char )PI_CANSPI_CMD_RESET ); TMR0_M_wait(100); // ***************************** // 2.Set the value in MCP2515 register // ***************************** // (1)Switch to Configration mode to make special register setting SPI_CAN_io((unsigned char)PI_CANSPI_CMD_WRITE, (unsigned char)PI_CANSPI_REGADDR_CANCTRL, (unsigned char)0b10000000 ); TMR0_M_wait(10); // (2)Clock output and normal mode setting G_CAN_data[0] =0b00001111 ; G_CAN_data[1] =0b00000000 ; G_CAN_data[1] =0b00000111 ; G_CAN_num = 2; SPI_CAN_data((unsigned char) 0b00000010 ); } /*********************************************************************************************************************** * Function Name: SPI_CAN_data * Description : * 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 SPI_CAN_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; // ****************************** // 1.Output CS sinnal // ****************************** CAN_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 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: 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); put_message0((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; } put_message0((uint8_t *)"("); for (lp = 0; lp < ( 8 - i ) ; lp++) { put_message0((uint8_t *)"0"); } while (i > 0){ sprintf(out_line,"%1.1d", b[--i]); put_message0((uint8_t *)out_line); } put_message0((uint8_t *)")"); } /*********************************************************************************************************************** * Function Name: test_uart0 * Description : This function is a sample program that echo back to UART0. * Arguments : None * Return Value : None ***********************************************************************************************************************/ void test_uart0(void) { uint8_t rtx_buf = 0x00; // ******************* // 1.Start UART0 // ******************* R_UART0_Start(); put_message0((uint8_t *)"RL78/G14 (Tx0) Connected OK >"); // ******************* // 2.Main Process // ******************* while (1U) { 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); } while((SSR01 & 0x0040)!= 0); //Check TSF01 (Recive) SSRmn(m:unit number[0,1]/n:channel number[0,1,2,3]) while((SSR00 & 0x0040)!= 0); //Check TSF00 (Send) SSRmn(m:unit number[0,1]/n:channel number[0,1,2,3]) R_UART0_Send(&rtx_buf,(uint16_t)1); } } /*********************************************************************************************************************** * Function Name: put_message0 * Description : This function is a sample program that outputs a message to UART0. * Arguments : None * Return Value : None ***********************************************************************************************************************/ void put_message0(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: CAN_CS_H * Description : This function set CS signal (P4[1]) connected to SPI_CAN to H * Arguments : * Return Value : None ***********************************************************************************************************************/ void CAN_CS_H(void) { P4 |= 0b00000010; } /*********************************************************************************************************************** * Function Name: CAN_CS_L * Description : This function set CS signal (P4[1]) connected to SPI_CAN to L * Arguments : * Return Value : None ***********************************************************************************************************************/ void CAN_CS_L(void) { P4 &= 0b11111101; } /* End user code. Do not edit comment generated here */