【RA4M2设计挑战赛】基于CAN的固件升级引导程序设计

程序的主要目的是作为一个Bootloader的验证性试验，程序的主要框架如下：

程序主体使用FreeRTOS，使用MDK编译，需要注意的一点是瑞萨提供的MDK的DFP需要配合不同版本的mdk使用，最新的4.2.0版本需要使用MDK 5.31以上，而不能使用5.14版本。
使用RASC Configuration配置外设和任务很方便，在选择了FreeRTOS，MDK之后，在Stacks界面分别配置四个主任务，blinky_thread、can0_thread、uart9_thread、flash0_thread：

配置任务过程中，主要是设置任务堆栈大小和任务名称，需要注意任务Symbol条目对应生成对应的任务入口函数：

之后就是配置各个外设，由于开发板的外部时钟是12MHz，所以需要先把时钟源的频率从24改为12MHz，如果未更改的话，会导致CAN和Uart的频率异常，比如，CAN设置的500kbps可能就变成250kbps

随后设置CAN的寄存器配置，CAN有两种模式，Normal和FIFO模式，两种模式的差别在邮箱配置上面，作为数据传输相对频率的引导刷写程序来讲，应当设置为FIFO模式，但是目前对于这个模式的理解还不够深入，所以当前就仅仅使用了一个接受邮箱和一个发送邮箱的Normal模式。

配置Uart9需要注意的是，需要把Debug模式配置为swd，然后将P109和P110引脚分配给uart

参考论坛的文章，重写fputc和fgetc函数，即可实现fprintf和fscanf，参考的代码如下：

#include "uart9_thread.h"
#include "stdio.h"
/* Uart0 Thread entry function */
/* pvParameters contains TaskHandle_t */
volatile bool     uart_send_complete_flag  = false;
volatile bool     uart_recv_complete_flag  = false;
volatile uint32_t uart_recv_char = '\0';


void uart9_thread_entry(void * pvParameters)
{
		FSP_PARAMETER_NOT_USED(pvParameters);

		/* TODO: add your own code here */
		fsp_err_t err = FSP_SUCCESS;
		
		err = R_SCI_UART_Open(&g_uart9_ctrl, &g_uart9_cfg);
		assert(FSP_SUCCESS == err);
		
		printf("printf and scanf test!!\n");
		while(1)
		{
				char recv_char[10] = "Hello";
			
				scanf("%s",recv_char);
			
				if(strcmp(recv_char, "open") == 0)
				{
					printf("Hello!! WangDip");
				}
				
				vTaskDelay(10);
		}
}


//callback function for uart9
void uart9_notification(uart_callback_args_t * p_args)
{
	if(p_args->event == UART_EVENT_TX_COMPLETE)
	{
		uart_send_complete_flag = true;
	}
	else if(p_args->event == UART_EVENT_RX_CHAR)
	{
		uart_recv_char = p_args->data;
		uart_recv_complete_flag = true;
	}
}


//fputs for printf or other print function instandard

int fputc(int ch, FILE *f)
{
	fsp_err_t err = FSP_SUCCESS;
	
	(void)f;
	
	err = R_SCI_UART_Write(&g_uart9_ctrl, (uint8_t *)&ch, 1);
	if(FSP_SUCCESS != err)
		__BKPT();
	
	//Waiting until transmit finished 
	while(uart_send_complete_flag == false)
	{}
		
	uart_send_complete_flag = false;
		
	return ch;
}



//fgets for scanf or other input function in standard


int fgetc(FILE *f)
{
	(void)f;
	
	while(uart_recv_complete_flag == false)
	{}
		
	uart_recv_complete_flag = false;
	
	return (int)uart_recv_char;
}

最后就是配置，flash，由于需要操作code flash，所以后台刷写和中断都需要关闭，

flash代码参考RASC的例程，主要是配置应用程序的起始地址，写块的大小，同时参考了usb固件代码中的程序跳转的初始化代码，代码如下：

#include "flash0_thread.h"
#include "can0_thread.h"
/* Flash0 Thread entry function */
/* pvParameters contains TaskHandle_t */

#define FLASH_CF_BLOCK_8               0x00010000
#define FLASH_CF_BLOCK_22               0x00010000
#define FLASH_DATA_BLOCK_SIZE          (64)
#define CODE_FLASH_WRITE_SIZE    			 128

#define APP_START_ADDR                  0x80000

typedef int (*main_fnptr)(void);

uint8_t        g_dest[128];
uint8_t        g_src[128];
uint32_t addr;
extern bool isFull;
extern bool flsRqst;

static void execute_user_code(uint32_t address);

void flash0_thread_entry(void * pvParameters)
{
		FSP_PARAMETER_NOT_USED(pvParameters);

		/* TODO: add your own code here */
		fsp_err_t err = R_FLASH_HP_Open(&g_flash0_ctrl, &g_flash0_cfg);
		
		assert(FSP_SUCCESS == err);
		
		addr = FLASH_CF_BLOCK_8;
		
		uint32_t cnt_time = 0;
	
	
		while(1)
		{
			if(flsRqst)
			{
				 __disable_irq();
				
				if(isFull&&(addr<0x7FF7F))
				{
					
						if(addr%0x8000)
						{
							err = R_FLASH_HP_Erase(&g_flash0_ctrl, addr, 1);
							assert(FSP_SUCCESS == err);
							vTaskDelay(5);
						}
						
						err = R_FLASH_HP_Write(&g_flash0_ctrl, (uint32_t) g_src, addr, CODE_FLASH_WRITE_SIZE);
						assert(FSP_SUCCESS == err);
						
						isFull = false;
						__enable_irq();
						
						vTaskDelay(1);
						
						assert(0 == memcmp(g_src, (uint8_t *) FLASH_CF_BLOCK_8, CODE_FLASH_WRITE_SIZE));
						
						addr += 128;
				}
			}
			else
			{
				vTaskDelay(1);
				cnt_time++;
				if(cnt_time>500)
					execute_user_code(APP_START_ADDR);
			}
		}	
}

static void execute_user_code(uint32_t address)
{
    main_fnptr *p_jump_to_app; // Function pointer main that will be used to jump to application

    __disable_irq();

#if 0       //Commented out 2022.06.24 WangJin
    /* Disable the stack monitor */
    R_MPU_SPMON->SP[0].PT = 0xA500U;                /* Enable access to Main Stack Pointer Monitor Access Control Register */
    R_MPU_SPMON->SP[1].PT = 0xA500U;                /* Enable access to Process Stack Pointer Monitor Access Control Register */
    R_MPU_SPMON->SP[0].CTL = 0U;                    /* disable the Main stack monitor */
    R_MPU_SPMON->SP[1].CTL = 0U;                    /* disable the Process stack monitor */
#else
    __set_MSPLIM(0);
#endif
    SysTick->CTRL  = 0;                             /* Disable the systick timer */
    NVIC_DisableIRQ ( SysTick_IRQn );               /* Disable the systick timer IRQ */
    NVIC_ClearPendingIRQ( SysTick_IRQn );           /* Clear any pending systick timer IRQ */

    R_USB_FS0->SYSCFG = 0;                            /* Disable USB FS */
    R_USB_FS0->DVSTCTR0 = 0;
    R_USB_FS0->INTENB0 = 0;
    R_USB_FS0->INTENB1 = 0;
    R_USB_FS0->INTSTS0 = 0;
    R_USB_FS0->INTSTS1 = 0;
    R_USB_FS0->BRDYENB = 0;
    R_USB_FS0->NRDYENB = 0;
    R_USB_FS0->BEMPENB =0;
    R_USB_FS0->USBADDR = 0;

    // Clear all interrupts!
    // ICU Event Link Setting Register i (IELSRi) (RA6M3: i = 0 to 95)
    for (uint32_t i = 0; i<96; i++)
    {
        R_ICU->IELSR[i] = 0;
    }

    for (uint32_t i = 0; i<8; i++)
    {
        NVIC->ICER[i] = 0xFFFFFFFF;
        NVIC->ICPR[i] = 0xFFFFFFFF;
    }

    // IRQ Control Register i (IRQCRi) (RA6M3: i = 0 to 15)
    for  (uint32_t i = 0; i<16; i++)
    {
        R_ICU->IRQCR[i] = 0;
    }

    p_jump_to_app = (main_fnptr*)(address+4);

    SCB->VTOR = (address & 0x1FFFFF80);

    /* Complete all explicit memory accesses */
    __DSB();
    /* Flush the pipeline in the processor */
    __ISB();

    // Flush the ROM cache, or we won't see the changed data
    R_FCACHE->FCACHEE_b.FCACHEEN = 0;           //Disable Flash Memory Cache
    R_FCACHE->FCACHEIV_b.FCACHEIV = 1;          //Invalidate Flash Cache
    while (0 != R_FCACHE->FCACHEIV_b.FCACHEIV);
    R_FCACHE->FCACHEE_b.FCACHEEN = 1;           // Re-Enable ROM cache

    /* Set bits 20-23 to enable CP10 and CP11 coprocessor */
    SCB->CPACR = 0;

     /** Set stack here. */
    __set_MSP(*((uint32_t*)(address)));

    /* Ensure that when we jump we're using the Main Stack Pointer */
    __set_CONTROL(0);

    /* Clear lazy stacking for FPU operations */
    FPU->FPCCR &= 0xC0000000;

    /** Jump to image*/
     (*p_jump_to_app)();
     __NOP();
}

与上位机的交互主要在CAN模块中执行，主要代码如下：

#include "can0_thread.h"
#include "blinky_thread.h"


can_frame_t g_can_tx_frame;
can_frame_t g_can_rx_frame;
volatile bool     g_rx_flag  = false;
volatile bool     g_tx_flag  = false;
volatile bool     g_err_flag = false;
volatile uint32_t g_rx_id;

bool isFull = false;
bool flsRqst = false;
uint8_t g_data[128];
uint32_t len = 0;
bool vStart = false;

bsp_io_level_t pin_level_can = BSP_IO_LEVEL_LOW;


/* CAN0 Thread entry function */
/* pvParameters contains TaskHandle_t */ 
void can0_thread_entry(void * pvParameters)
{
		FSP_PARAMETER_NOT_USED(pvParameters);
		fsp_err_t err;
		uint32_t cnt = 0;
		uint8_t num = 0;
		
	

		/* TODO: add your own code here */
		/* Initialize the CAN module */
		err = R_CAN_Open(&g_can0_ctrl, &g_can0_cfg);
		while(1)
		{
				//vTaskDelay(10);
				num = g_can_rx_frame.data[0];
				if(g_can_rx_frame.data[0] == 0xA0 && g_can_rx_frame.data[1] == 0xB1 &&
				g_can_rx_frame.data[2] == 0xC2 && g_can_rx_frame.data[3] == 0xD3 && !vStart && g_rx_flag)
				{
					len = (uint32_t)(((g_can_rx_frame.data[4])<<24) + ((g_can_rx_frame.data[5])<<18) +
						((g_can_rx_frame.data[6])<<8) + g_can_rx_frame.data[7]);
					vStart = true;
					g_rx_flag = false;
					g_can_tx_frame.id = 0x777;
					g_can_tx_frame.data_length_code = 0x08;
					err = R_CAN_Write(&g_can0_ctrl, 0, &g_can_tx_frame);
				}
				
				if(vStart && g_rx_flag && num < len )
				{
					vStart = true;
					memcpy(g_data+cnt*7,(g_can_rx_frame.data + 1),7);
					cnt++;
					if(cnt == 8)
					{
						cnt = 0;
						isFull = true;
					}
					num ++;
				}
				
				if(num>=len && isFull == false)
					flsRqst = false;
				
				if(cnt < 150)
				{
					pin_level_can = BSP_IO_LEVEL_HIGH;
				}
				else
					pin_level_can = BSP_IO_LEVEL_LOW;
				
				cnt++;
				
				if(cnt == 310)
					cnt = 0;
				taskEXIT_CRITICAL();
				
				
				/* Since there is nothing else to do, block until Callback triggers*/
		}
}

void can_callback (can_callback_args_t * p_args)
{
    switch (p_args->event)
    {
        case CAN_EVENT_RX_COMPLETE:    /* Receive complete event. */
        {
            g_rx_flag = true;
            g_rx_id   = p_args->frame.id;
            /* Read received frame */
            g_can_rx_frame = p_args->frame;
            break;
        }
        case CAN_EVENT_TX_COMPLETE:    /* Transmit complete event. */
        {
            g_tx_flag = true;
            break;
        }
        case CAN_EVENT_ERR_BUS_OFF:          /* Bus error event. (bus off) */
        case CAN_EVENT_ERR_PASSIVE:          /* Bus error event. (error passive) */
        case CAN_EVENT_ERR_WARNING:          /* Bus error event. (error warning) */
        case CAN_EVENT_BUS_RECOVERY:         /* Bus error event. (bus recovery) */
        case CAN_EVENT_MAILBOX_MESSAGE_LOST: /* Overwrite/overrun error */
        {
            /* Set error flag */
            g_err_flag = true;
            break;
        }
        default:
        {
            break;
        }
    }
}