续前【RA4L1-SENSOR】第一个程序增加 FreeRTOS显示量程0-3300 mV和量程0-15000mV
rasc部分
配置keil项目
可以进入片配置也可以关闭在keil项目项目中.
产生目录: 
打开lu.uvprojx
打开该文件配置的RA Smart Configurator
按照之前配置
【RA4L1-SENSOR】第一个程序增加 FreeRTOS显示量程0-3300 mV和量程0-15000mV
在Threads下方有一个Object区域，点击New Object-- Queue
增加一个队列，修改symbol为uart_queue，由于字节类型大小是1字节，Item Size填1，队列长度写100，内存分配选Dynamic。
增加一个二值信号量，symbol为semphrS_keyChanged，内存分配选Dynamic
添加RTC模块，并设置相应的模块参数。
完成后点击生成代码即可
rasc部分配置完。
编写keil部分代码
保存配置文件，生成项目代码。
在Key_Switch_Task.c中
#include "Key_Switch_Task.h"
extern TaskHandle_t ADC_Task;
static bool adc_task_active = true;
volatile bool rtc_adc_flag = false;
volatile bool rtc_ymd_time_flag= false;
extern volatile bool scan_0_3V3_flag;
uint8_t key_driver(void)
{
static uint8_t key_last=0, key_time=2;
uint8_t key_input,key_press,key_return=0;
R_IOPORT_PinRead (&g_ioport_ctrl, KEY1, &key_input);
if(key_input) key_press=0; else key_press=1;
if(key_press!=key_last) {key_last=key_press; key_time=0;}
if(key_time==1) key_return=(key_press==1)?11:1;
if(key_time==50 && key_press==1) key_return=3;
if(++key_time>60) key_time=55;
return key_return;
}
unsigned char key_read(void)
{
static unsigned char key_last =0, key_time_1 = 0;
unsigned char key_return =0,key_temp;
key_temp = key_driver();
if(key_time_1==0)
{
if(key_temp==1&&key_last==11) key_time_1++;
}
else if(++key_time_1<12)
{
if(key_temp==11) {key_return=2; key_temp=key_time_1=0;}
}
else
{
key_return=1;
key_time_1=0;
}
if(key_temp==3&&key_last==11) key_return=3;
if(key_temp) key_last=key_temp;
return key_return;
}
void Key_Switch_Task_entry(void *pvParameters)
{
FSP_PARAMETER_NOT_USED(pvParameters);
uint8_t key_state;
while (1)
{
key_state=key_read();
switch (key_state)
{
case 0:
break;
case 1:
printf("S_key 1 \r\n");
xSemaphoreGive(semphrS_keyChanged);
break;
case 2:
rtc_ymd_time_flag=!rtc_ymd_time_flag;
break;
case 3: printf("l_key 3 \r\n");
xSemaphoreGive(semphr_taskChanged);
break;
}
vTaskDelay (30);
}
}
在LCD_Display_Task_entry.c中
#include "LCD_Display_Task.h"
#include "lcd/lcd.h"
#include "rtc\usr_rtc.h"
extern volatile bool scan_0_3V3_flag;
extern volatile bool rtc_adc_flag ;
extern volatile bool rtc_ymd_time_flag;
#include "uart\uart.h"
extern rtc_time_t g_lcd_present_time;
extern fsp_err_t set_medium_error( uint8_t value, uint8_t position );
volatile uint32_t g_periodic_irq_flag = RESET_FLAG;
static uint8_t colon = 0;
uint8_t seg_value;
uint32_t digit_ret(uint8_t keb)
{ uint32_t digit_idx = 0;
uint8_t temp;
uint8_t ilen=0 ,iflag=0;
while (1)
{
if (xQueueReceive (uart_queue, &temp, 0) == pdTRUE )
{
if (temp>47 & temp<58)
{ digit_idx=digit_idx*10+temp-48;
ilen++ ;
printf("ilen %d.year：%d\n\r",ilen,digit_idx);
}
else
{if (temp==10){iflag=1;
printf("temp==10 :ilen %d.year：%d\n\r",ilen,digit_idx);
}
if (temp==13){
printf("temp==13 :ilen %d.year：%d\n\r",ilen,digit_idx);
if(ilen<(keb+1))break; }
ilen=0;
iflag=0;
digit_idx = 0;
printf("error\n\r re in\n\r");
}
}
}
return digit_idx;
}
void config_rtc_time(void)
{
fsp_err_t err = FSP_SUCCESS;
uint32_t time_value_hr = 0;
err = get_rtc_calendar_time ();
rtc_deinit();
set_medium_error( 8, 5 );
printf("in year:\n\r");
set_medium_error( 9, 4 );
time_value_hr = (uint32_t) (g_lcd_present_time.tm_year);
printf("time_value_hr year：%d\n\r",time_value_hr);
LCD_ShowNumber ((uint32_t) (time_value_hr), 4);
uint32_t digit_idx= digit_ret(4);
printf("year：%d\n\r",digit_idx);
g_lcd_present_time.tm_year= digit_idx-1900 ;
set_medium_error( 8, 5 );
set_medium_error( 5, 4 );
set_medium_error( 9, 3 );
printf("in months:\n\r");
set_medium_error( 5, 2 );
time_value_hr = (uint32_t) (g_lcd_present_time.tm_mon);
printf("months：%d\n\r",time_value_hr);
LCD_ShowNumber ((uint32_t) (time_value_hr), 2);
digit_idx= digit_ret(2);
printf("months：%d\n\r",digit_idx);
g_lcd_present_time.tm_mon= digit_idx-1 ;
set_medium_error( 8, 5 );
set_medium_error( 5, 4 );
set_medium_error( 5, 3 );
printf("in day:\n\r");
set_medium_error( 10, 2 );
time_value_hr = (uint32_t) (g_lcd_present_time.tm_mday);
printf("tm_mday：%d\n\r",time_value_hr);
LCD_ShowNumber ((uint32_t) (time_value_hr), 2);
digit_idx= digit_ret(2);
printf("tm_mday：%d\n\r",digit_idx);
g_lcd_present_time.tm_mday= digit_idx ;
set_medium_error( 8, 5 );
set_medium_error( 11, 4 );
set_medium_error( 5, 3 );
printf("in tm_hour:\n\r");
set_medium_error( 5, 2 );
time_value_hr = (uint32_t) (g_lcd_present_time.tm_hour);
printf("tm_hour：%d\n\r",time_value_hr);
LCD_ShowNumber ((uint32_t) (time_value_hr), 2);
digit_idx= digit_ret(2);
printf("tm_hour：%d\n\r",digit_idx);
g_lcd_present_time.tm_hour= digit_idx ;
set_medium_error( 8, 5 );
set_medium_error( 5, 4 );
set_medium_error( 8, 3 );
printf("in tm_min:\n\r");
set_medium_error( 5, 2 );
time_value_hr = (uint32_t) (g_lcd_present_time.tm_min);
printf("tm_min：%d\n\r",time_value_hr);
LCD_ShowNumber ((uint32_t) (time_value_hr), 2);
digit_idx= digit_ret(2);
printf("tm_min：%d\n\r",digit_idx);
g_lcd_present_time.tm_min= digit_idx ;
set_medium_error( 8, 5 );
set_medium_error( 5, 4 );
set_medium_error( 5, 3 );
printf("in tm_sec:\n\r");
set_medium_error( 8, 2 );
time_value_hr = (uint32_t) (g_lcd_present_time.tm_sec);
printf("tm_sec：%d\n\r",time_value_hr);
LCD_ShowNumber ((uint32_t) (time_value_hr), 2);
digit_idx= digit_ret(2);
printf("tm_sec：%d\n\r",digit_idx);
g_lcd_present_time.tm_sec= digit_idx ;
rtc_init ();
R_RTC_CalendarTimeSet(&g_rtc_ctrl, &g_lcd_present_time);
}
fsp_err_t update_rtc_time_info_to_lcd(void)
{
fsp_err_t err = FSP_SUCCESS;
uint32_t time_value_hr = 0;
uint32_t time_value_mn = 0;
uint32_t time_value_s = 0;
err = get_rtc_calendar_time ();
if (FSP_SUCCESS != err)
{
APP_ERR_PRINT("\r\n ** RTC READ FAILED ** \r\n");
APP_ERR_TRAP(err);
}
time_value_s = (uint32_t) (g_lcd_present_time.tm_sec);
if ((time_value_s%5))
{ time_value_hr = (uint32_t) (g_lcd_present_time.tm_hour);
time_value_mn = (uint32_t) (g_lcd_present_time.tm_min);
time_value_hr = (time_value_hr * 10000) + (uint32_t) (time_value_mn*100)+time_value_s;
err = set_segments_medium_digits (time_value_hr, 1);
err = set_segments_medium_digits (time_value_hr, 0);
}
else
{
time_value_hr = ((uint32_t) (g_lcd_present_time.tm_year)-2000 )* 10000 + ((uint32_t) (g_lcd_present_time.tm_mon)) *100+(uint32_t) (g_lcd_present_time.tm_mday);
err = set_segments_medium_digits (time_value_hr, 3);
}
return(err);
}
void LCD_Display_Task_entry(void *pvParameters)
{
FSP_PARAMETER_NOT_USED(pvParameters);
uint32_t num = 0;
double adcValue = 0.0;
static bool adc_task_active = true;
bool display_flag;
uart_initialize();
LCD_Init ();
if (xSemaphoreTake(semphr_taskChanged, 0000) == pdTRUE)
{
LCD_Clear ();
rtc_adc_flag=!rtc_adc_flag;
}
rtc_init ();
set_rtc_calendar_time_with_user_configured_time ();
int i=0;
while(true)
{
if (xSemaphoreTake(semphr_taskChanged, 0) == pdTRUE)
{
LCD_Clear ();
rtc_adc_flag=!rtc_adc_flag;
}
display_flag=rtc_adc_flag;
if (display_flag)
{
if(g_periodic_irq_flag)
{
update_rtc_time_info_to_lcd();
g_periodic_irq_flag = 0;
}
if (xSemaphoreTake(semphrS_keyChanged, 0000) == pdTRUE)
{
config_rtc_time();
}
}
if (!display_flag)
{
if (xSemaphoreTake(semphrS_keyChanged, 0000) == pdTRUE)
{
scan_0_3V3_flag=!scan_0_3V3_flag;
}
if (xQueueReceive (queue_adcValue, &adcValue, 0) == pdTRUE )
{
LCD_Clear ();
LCD_setDot (0);
if (scan_0_3V3_flag)
{
set_medium_error( 7, 5 );
R_SLCDC_Modify(&g_slcdc0_ctrl,0x10,0x0 , (uint8_t)~(uint8_t)MED_DIGIT_MASK_4_2_1);
R_SLCDC_Modify( &g_slcdc0_ctrl,0x0f ,0x0 , (uint8_t)~(uint8_t)MED_DIGIT_MASK_8_4_2_1);
LCD_ShowNumber ((uint32_t) (adcValue * 1000), 4);
}
else
{
set_medium_error( 6, 5 );
LCD_ShowNumber ((uint32_t) (adcValue * 1000), 5);
}
}
}
i++;
vTaskDelay(10);
if(i==100){
if (!display_flag)printf("Hello World!\r\n");
i=0;
}
if (xQueueReceive (queue_numData, &num, 0) == pdTRUE )
{
if (!display_flag)printf("ADC:%d\r\n", num);
}
}
}
uart.c 中
/***********************************************************************************************************************
* File Name : uart.c
* Description : Contains UART functions definition.
**********************************************************************************************************************/
/***********************************************************************************************************************
* Copyright (c) 2020 - 2024 Renesas Electronics Corporation and/or its affiliates
*
* SPDX-License-Identifier: BSD-3-Clause
***********************************************************************************************************************/
#include "common_utils.h"
#include "uart.h"
//void uart_queue_init(void);
volatile bool TBE = false;
uint8_t receive;
//uart_circle_queue_t uart_queue;
/*******************************************************************************************************************//**
* @addtogroup r_sci_uart_ep
* @{
**********************************************************************************************************************/
/*
* Private function declarations
*/
/*
* Private global variables
*/
/* Temporary buffer to save data from receive buffer for further processing */
static uint8_t g_temp_buffer[DATA_LENGTH] = {RESET_VALUE};
/* Counter to update g_temp_buffer index */
static volatile uint8_t g_counter_var = RESET_VALUE;
/* Flag to check whether data is received or not */
static volatile uint8_t g_data_received_flag = false;
/* Flag for user callback */
static volatile uint8_t g_uart_event = RESET_VALUE;
//uart tx empty
static volatile bool uart_send_complete_flag = false;
/*****************************************************************************************************************
* [url=home.php?mod=space&uid=2666770]@Brief[/url] UART Example project to demonstrate the functionality
* @param[in] None
* @retval FSP_SUCCESS Upon success
* @retval Any Other Error code apart from FSP_SUCCESS
****************************************************************************************************************/
fsp_err_t uart_ep_demo(void)
{
fsp_err_t err = FSP_SUCCESS;
volatile bool b_valid_data = true;
while (true)
{
if(g_data_received_flag)
{
g_data_received_flag = false;
uint8_t input_length = RESET_VALUE;
volatile uint32_t intensity = RESET_VALUE;
/* Calculate g_temp_buffer length */
input_length = ((uint8_t)(strlen((char *) &g_temp_buffer)));
/* Check if input data length is in limit */
if (DATA_LENGTH > (uint8_t)input_length)
{
/* This loop validates input data byte by byte to filter out decimals. (floating point input)
* Any such data will be considered as invalid. */
for(int buf_index = RESET_VALUE; buf_index < input_length; buf_index++)
{
if(ZERO_ASCII <= g_temp_buffer[buf_index] && NINE_ASCII >= g_temp_buffer[buf_index])
{
/* Set b_valid_data Flag as data is valid */
b_valid_data = true;
}
else
{
/* Clear data_valid flag as data is not valid, Clear the buffer and break the loop */
memset(g_temp_buffer, RESET_VALUE, DATA_LENGTH);
b_valid_data = false;
break;
}
}
/* All bytes in data are integers, convert input to integer value to set intensity. */
intensity = ((uint32_t)(atoi((char *) &g_temp_buffer)));
}
else
{
/* Clear data_valid flag as data is not valid, Clear the g_temp_buffer */
memset(g_temp_buffer, RESET_VALUE, DATA_LENGTH);
b_valid_data = false;
err = uart_print_user_msg((uint8_t *)"\r\nInvalid input. Input range is from 1 - 100\r\n");
if (FSP_SUCCESS != err)
{
APP_ERR_PRINT ("\r\n ** UART WRITE FAILED ** \r\n");
return err;
}
}
}
}
}
/*******************************************************************************************************************//**
* @brief Initialize UART.
* @param[in] None
* @retval FSP_SUCCESS Upon successful open and start of timer
* @retval Any Other Error code apart from FSP_SUCCESS Unsuccessful open
***********************************************************************************************************************/
fsp_err_t uart_initialize(void)
{
fsp_err_t err = FSP_SUCCESS;
/* Initialize UART channel with baud rate 115200 */
#if (BSP_FEATURE_SCI_VERSION == 2U)
err = R_SCI_B_UART_Open (&g_uart9_ctrl, &g_uart9_cfg);
#else
err = R_SCI_UART_Open (&g_uart9_ctrl, &g_uart9_cfg);
#endif
if (FSP_SUCCESS != err)
{
APP_ERR_PRINT ("\r\n** R_"UART_TYPE"_Open API failed **\r\n");
}
return err;
}
/*****************************************************************************************************************
* @brief print user message to terminal
* @param[in] p_msg
* @retval FSP_SUCCESS Upon success
* @retval FSP_ERR_TRANSFER_ABORTED Upon event failure
* @retval Any Other Error code apart from FSP_SUCCESS, Unsuccessful write operation
****************************************************************************************************************/
fsp_err_t uart_print_user_msg(uint8_t *p_msg)
{
fsp_err_t err = FSP_SUCCESS;
uint8_t msg_len = RESET_VALUE;
uint32_t local_timeout = (DATA_LENGTH * UINT16_MAX);
uint8_t *p_temp_ptr = (uint8_t *)p_msg;
/* Calculate length of message received */
msg_len = ((uint8_t)(strlen((char *)p_temp_ptr)));
/* Reset callback capture variable */
g_uart_event = RESET_VALUE;
/* Writing to terminal */
#if (BSP_FEATURE_SCI_VERSION == 2U)
err = R_SCI_B_UART_Write (&g_uart_ctrl, p_msg, msg_len);
#else
err = R_SCI_UART_Write (&g_uart9_ctrl, p_msg, msg_len);
#endif
if (FSP_SUCCESS != err)
{
APP_ERR_PRINT ("\r\n** R_"UART_TYPE"_Write API Failed **\r\n");
return err;
}
/* Check for event transfer complete */
while ((UART_EVENT_TX_COMPLETE != g_uart_event) && (--local_timeout))
{
/* Check if any error event occurred */
if (UART_ERROR_EVENTS == g_uart_event)
{
APP_ERR_PRINT ("\r\n** UART Error Event Received **\r\n");
return FSP_ERR_TRANSFER_ABORTED;
}
}
if(RESET_VALUE == local_timeout)
{
err = FSP_ERR_TIMEOUT;
}
return err;
}
/*******************************************************************************************************************//**
* @brief Deinitialize SCI UART module
* @param[in] None
* @retval None
**********************************************************************************************************************/
void deinit_uart(void)
{
fsp_err_t err = FSP_SUCCESS;
/* Close module */
#if (BSP_FEATURE_SCI_VERSION == 2U)
err = R_SCI_B_UART_Close (&g_uart9_ctrl);
#else
err = R_SCI_UART_Close (&g_uart9_ctrl);
#endif
if (FSP_SUCCESS != err)
{
APP_ERR_PRINT ("\r\n** R_"UART_TYPE"_Close API failed ** \r\n");
}
}
int fputc(int ch, FILE *f)
{
(void)f;
R_SCI_UART_Write(&g_uart9_ctrl, (uint8_t *)&ch, 1);
while(TBE == false);
TBE = false;
return ch;
}
void user_uart9_callback(uart_callback_args_t * p_args)
{
switch(p_args->event)
{
case UART_EVENT_TX_COMPLETE:
{
TBE = true;
break;
}
case UART_EVENT_RX_CHAR:
{
xQueueSend(uart_queue, &p_args->data, 0);
break;
}
}
}
增加usr_rtc.c
#include <rtc\usr_rtc.h>
#include "common_utils.h"
rtc_time_t g_set_time =
{
.tm_sec = USER_DATA_SECONDS,
.tm_min = USER_DATA_MINUTES,
.tm_hour = USER_DATA_HOUR,
.tm_mday = USER_DATA_DAY_OF_THE_MONTH,
.tm_mon = USER_DATA_MONTH_OF_THE_YEAR,
.tm_year = USER_DATA_YEAR,
};
static rtc_time_t g_present_time ;
rtc_time_t g_lcd_present_time ;
static uint32_t set_time_flag = RESET_FLAG;
extern volatile uint32_t g_periodic_irq_flag;
fsp_err_t rtc_init(void)
{
fsp_err_t err = FSP_SUCCESS;
err = R_RTC_Open(&g_rtc_ctrl, &g_rtc_cfg);
if (FSP_SUCCESS != err)
{
APP_ERR_PRINT ("\r\nRTC module open failed.\r\nRestart the Application\r\n");
}
err = R_RTC_PeriodicIrqRateSet (&g_rtc_ctrl, RTC_PERIODIC_IRQ_SELECT_1_SECOND);
if (FSP_SUCCESS != err)
{
APP_ERR_PRINT ("\r\nRTC Periodic Irq set failed.\r\nRestart the Application\r\n");
}
return err;
}
fsp_err_t set_rtc_calendar_time_with_user_configured_time(void)
{
fsp_err_t err = FSP_SUCCESS;
APP_PRINT ("\r\nSetting RTC Date and Time \r\n");
err = R_RTC_CalendarTimeSet(&g_rtc_ctrl, &g_set_time);
if (FSP_SUCCESS != err)
{
APP_ERR_PRINT("\r\nCalendarTime Set failed.\r\n");
return err;
}
err = R_RTC_CalendarTimeGet(&g_rtc_ctrl, &g_present_time);
if (FSP_SUCCESS != err)
{
APP_ERR_PRINT("\r\nCalendarTime Get failed.\r\n");
return err;
}
rtc_date_readability_update(&g_present_time);
g_lcd_present_time = g_present_time;
APP_PRINT("\r\n RTC calendar set to Date : %2d/%2d/%4d \n Time : %2d : %2d : %2d \r\n\n", g_present_time.tm_mday,
g_present_time.tm_mon, g_present_time.tm_year, g_present_time.tm_hour,
g_present_time.tm_min, g_present_time.tm_sec);
set_time_flag = SET_FLAG;
return err;
}
fsp_err_t get_rtc_calendar_time(void)
{
fsp_err_t err = FSP_SUCCESS;
err = R_RTC_CalendarTimeGet(&g_rtc_ctrl, &g_present_time);
if (FSP_SUCCESS != err)
{
APP_ERR_PRINT("\r\nGetting RTC Calendar time failed.\r\n");
return err;
}
rtc_date_readability_update(&g_present_time);
g_lcd_present_time = g_present_time;
APP_PRINT("\r\n RTC Date : %d/%d/%d Time : %d : %d : %d ", g_present_time.tm_mday,
g_present_time.tm_mon , g_present_time.tm_year, g_present_time.tm_hour,
g_present_time.tm_min, g_present_time.tm_sec);
return err;
}
void rtc_date_readability_update(rtc_time_t * time)
{
time->tm_mon += MON_ADJUST_VALUE;
time->tm_year += YEAR_ADJUST_VALUE;
}
void rtc_callback(rtc_callback_args_t *p_args)
{
if(RTC_EVENT_PERIODIC_IRQ == p_args->event)
{
g_periodic_irq_flag = SET_FLAG;
}
else
{
g_periodic_irq_flag = RESET_FLAG;
}
}
void rtc_deinit(void)
{
fsp_err_t err = FSP_SUCCESS;
err = R_RTC_Close(&g_rtc_ctrl);
if (FSP_SUCCESS != err)
{
APP_ERR_PRINT("** RTC module Close failed ** \r\n");
}
}
这次编译没有出错：
compiling vector_data.c...
linking...
Program Size: Code=19712 RO-data=1684 RW-data=80 ZI-data=42868
FromELF: creating hex file...
".\\Objects\\RAL1_UART_LED.axf" - 0 Error(s), 96 Warning(s).
Build Time Elapsed: 00:00:24
烧Load ：
Erase Done.
Programming Done.
Verify OK.
Application running ...
Flash Load finished at 08:15:50
com:
▒ilen 1.year：2
ilen 2.year：20
ilen 3.year：202
ilen 4.year：2025
temp==13 :ilen 4.year：2025
year：2025
in months:
months：7
ilen 1.year：7
temp==13 :ilen 1.year：7
months：7
in day:
tm_mday：4
ilen 1.year：2
ilen 2.year：21
temp==13 :ilen 2.year：21
tm_mday：21
in tm_hour:
tm_hour：11
ilen 1.year：6
temp==13 :ilen 1.year：6
tm_hour：6
in tm_min:
tm_min：59
ilen 1.year：3
ilen 2.year：32
temp==13 :ilen 2.year：32
tm_min：32
in tm_sec:
tm_sec：8
ilen 1.year：0
temp==13 :ilen 1.year：0
tm_sec：0
RTC Date : 21/7/2025 Time : 6 : 32 : 1
RTC Date : 21/7/2025 Time : 6 : 32 : 2
RTC Date : 21/7/2025 Time : 6 : 32 : 3
达到预期状态。
0
/9 
工商网监
湘ICP备2023018690号
1066
淘帖
