一、 新建工程
- 选择芯片型号
- 选择中间件，勾选RTX
选择完毕后，ok解锁。 - main文件内容如下，由于我对RTX函数，再封装了一层，是为了方便切换其他OS。
/********************************************************************************
* @file main.c
* @author jianqiang.xue
* @Version V1.0.0
* @Date 2021-04-03
* @brief 无
********************************************************************************/
/* Includes ------------------------------------------------------------------*/
#include <stdio.h>
#include <string.h>
#include "cx32l003_hal.h"
#include "os_api.h"
/* Private includes ----------------------------------------------------------*/
#include "business_function.h"
/* External variables --------------------------------------------------------*/
extern uint8_t app_main_init(void);
/* Private function prototypes -----------------------------------------------*/
/**
* @brief Initialize the peripherals and hardware
*/
void hardware_init(void)
{
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* Configure the system clock to HIRC 24MHz*/
bsp_system_clock_config();
}
/**
* @brief initialize and start the system
*/
int main(void)
{
// 硬件外设初始化(不允许包含os部分代码,因为os未启动会导致程序异常死机)
hardware_init();
// os系统初始化
os_kernel_initialize();
// app功能初始化
app_main_init();
// 系统启动
os_kernel_start();
}
/********************************************************************************
* @file os_api.c
* @author jianqiang.xue
* @Version V1.0.0
* @Date 2021-04-03
* @brief 大部分RTX系统函数在：**\Keil_v5\Arm\Packs\ARM\CMSIS\5.6.0\CMSIS\RTOS\RTX\SRC
********************************************************************************/
#include <stdio.h>
#include <string.h>
#include "cmsis_os.h"
#include "os_api.h"
/************************************OS_KERNEL************************************/
os_status os_kernel_initialize(void)
{
return (os_status)osKernelInitialize();
}
os_status os_kernel_start(void)
{
return (os_status)osKernelStart();
}
os_status os_delay(uint32_t ms)
{
return (os_status)osDelay(ms);
}
extern void rt_tsk_lock(void);
os_status os_kernel_lock(void)
{
rt_tsk_lock();
return (os_status)0;
}
extern void rt_tsk_unlock(void);
os_status os_kernel_unlock(void)
{
rt_tsk_unlock();
return (os_status)0;
}
/************************************OS_THREAD************************************/
os_thread_id os_thread_create(const os_thread_def_t *thread_def, void *arg)
{
return (os_thread_id)osThreadCreate((const osThreadDef_t *)thread_def, NULL);
}
/************************************OS_TIMER************************************/
os_timer_id os_timer_create(const os_timer_def_t *timer_def, os_timer_t type, void *arg)
{
return osTimerCreate((const osTimerDef_t *)timer_def, (os_timer_type)type, arg);
}
os_status os_timer_start(os_timer_id timer_id, uint32_t millisec)
{
return (os_status)osTimerStart(timer_id, millisec);
}
os_status os_timer_stop(osTimerId timer_id)
{
return (os_status)osTimerStop(timer_id);
}
/************************************OS_MAIL************************************/
os_mail_qid os_mail_create(const os_mailq_def_t *queue_def, os_thread_id thread_id)
{
return (os_mail_qid)osMailCreate((const osMailQDef_t *)queue_def, thread_id);
}
void *os_mail_alloc(os_mail_qid queue_id, uint32_t millisec)
{
return osMailAlloc((osMailQId)queue_id, millisec);
}
void *os_mail_clean_and_alloc(os_mail_qid queue_id, uint32_t millisec)
{
return osMailCAlloc((osMailQId)queue_id, millisec);
}
os_status os_mail_put(os_mail_qid queue_id, void *mail)
{
return (os_status)osMailPut((osMailQId)queue_id, mail);
}
os_event os_mail_get(os_mail_qid queue_id, uint32_t millisec, void *arg)
{
osEvent event;
os_event event_t;
event = osMailGet((osMailQId)queue_id, millisec);
memcpy(&event_t, &event, sizeof(osEvent));
return event_t;
}
os_status os_mail_free(os_mail_qid queue_id, void *mail)
{
return (os_status)osMailFree((osMailQId)queue_id, mail);
}
/************************************OS_POOL************************************/
os_pool_id os_pool_create(const os_pool_def_t *pool_def)
{
return (os_pool_id)osPoolCreate((const osPoolDef_t *)pool_def);
}
void *os_pool_alloc(os_pool_id pool_id)
{
return osPoolAlloc((osPoolId)pool_id);
}
void *os_pool_calloc(os_pool_id pool_id)
{
return osPoolCAlloc((osPoolId)pool_id);
}
os_status os_pool_free(os_pool_id pool_id, void *block)
{
return (os_status)osPoolFree((osPoolId)pool_id, block);
}
/************************************OS_MSG_QUEUE************************************/
os_message_qid os_message_create(const os_messageq_def_t *queue_def, os_thread_id thread_id)
{
return (os_message_qid)osMessageCreate((const osMessageQDef_t *)queue_def, thread_id);
}
os_status os_message_put(os_message_qid queue_id, uint32_t info, uint32_t millisec)
{
return (os_status)osMessagePut((osMessageQId)queue_id, info, millisec); // Send Message
}
os_event os_message_get(os_message_qid queue_id, uint32_t millisec)
{
osEvent event;
os_event event_t;
event = osMessageGet((osMessageQId)queue_id, millisec);
memcpy(&event_t, &event, sizeof(osEvent));
return event_t;
}
/************************************OS_SIGNAL************************************/
extern int32_t isrSignalSet(osThreadId thread_id, int32_t signals);
int32_t isr_signal_set(os_thread_id thread_id, int32_t signals)
{
return isrSignalSet(thread_id, signals);
}
int32_t os_signal_set(os_thread_id thread_id, int32_t signals)
{
return osSignalSet(thread_id, signals);
}
int32_t os_signal_clear(os_thread_id thread_id, int32_t signals)
{
return osSignalClear(thread_id, signals);
}
// signals = 0,则等待任意信号.
os_event os_signal_wait(int32_t signals, uint32_t millisec)
{
osEvent event;
os_event event_t;
event = osSignalWait(signals, millisec);
memcpy(&event_t, &event, sizeof(osEvent));
return event_t;
}
/********************************************************************************
* @file os_api.h
* @author jianqiang.xue
* @Version V1.0.0
* @Date 2021-04-03
* @brief
********************************************************************************/
#include <stdint.h>
#include "cmsis_os.h"
/// Timeout value.
#define OS_WAIT_FOREVER 0xFFFFFFFFU ///< wait forever timeout value
/************************************OS_KERNEL************************************/
typedef enum {
OS_OK = 0, ///< function completed; no error or event occurred.
OS_EVENT_SIGNAL = 0x08, ///< function completed; signal event occurred.
OS_EVENT_MESSAGE = 0x10, ///< function completed; message event occurred.
OS_EVENT_MAIL = 0x20, ///< function completed; mail event occurred.
OS_EVENT_TIMEOUT = 0x40, ///< function completed; timeout occurred.
OS_ERROR_PARAMETER = 0x80, ///< parameter error: a mandatory parameter was missing or specified an incorrect object.
OS_ERROR_RESOURCE = 0x81, ///< resource not available: a specified resource was not available.
OS_ERROR_TIMEOUTRESOURCE = 0xC1, ///< resource not available within given time: a specified resource was not available within the timeout period.
OS_ERROR_ISR = 0x82, ///< not allowed in ISR context: the function cannot be called from interrupt service routines.
OS_ERROR_ISRRECURSIVE = 0x83, ///< function called multiple times from ISR with same object.
OS_ERROR_PRIORITY = 0x84, ///< system cannot determine priority or thread has illegal priority.
OS_ERROR_NOMEMORY = 0x85, ///< system is out of memory: it was impossible to allocate or reserve memory for the operation.
OS_ERROR_VALUE = 0x86, ///< value of a parameter is out of range.
OS_ERROR_OS = 0xFF, ///< unspecified RTOS error: run-time error but no other error message fits.
OS_STATUS_RESERVED = 0x7FFFFFFF ///< prevent from enum down-size compiler optimization.
} os_status;
os_status os_kernel_initialize (void);
os_status os_kernel_start(void);
os_status os_kernel_lock(void);
os_status os_kernel_unlock(void);
os_status os_delay(uint32_t ms);
uint32_t os_get_tick(void);
/************************************OS_EVENT************************************/
typedef struct os_mailq_cb *os_mail_qid;
typedef struct os_messageq_cb *os_message_qid;
typedef struct {
os_status status; ///< status code: event or error information
union {
uint32_t v; ///< message as 32-bit value
void *p; ///< message or mail as void pointer
int32_t signals; ///< signal flags
} value; ///< event value
union {
os_mail_qid mail_id; ///< mail id obtained by \ref osMailCreate
os_message_qid message_id; ///< message id obtained by \ref osMessageCreate
} def; ///< event definition
} os_event;
/************************************OS_THREAD************************************/
typedef enum {
OS_PRIORITY_IDLE = -3, ///< priority: idle (lowest)
OS_PRIORITY_LOW = -2, ///< priority: low
OS_PRIORITY_BELOWNORMAL = -1, ///< priority: below normal
OS_PRIORITY_NORMAL = 0, ///< priority: normal (default)
OS_PRIORITY_ABOVENORMAL = +1, ///< priority: above normal
OS_PRIORITY_HIGH = +2, ///< priority: high
OS_PRIORITY_REALTIME = +3, ///< priority: realtime (highest)
OS_PRIORITY_ERROR = 0x84 ///< system cannot determine priority or thread has illegal priority
} os_priority_t;
typedef struct os_thread_cb *os_thread_id;
typedef void (*os_pthread) (void const *argument);
typedef struct {
os_pthread pthread; ///< start address of thread function
os_priority_t tpriority; ///< initial thread priority
uint32_t instances; ///< maximum number of instances of that thread function
uint32_t stacksize; ///< stack size requirements in bytes; 0 is default stack size
} os_thread_def_t;
#define os_thread(name) &os_thread_def_##name
#define os_thread_def(name, priority, instances, stacksz) \
const os_thread_def_t os_thread_def_##name = {(name), (priority), (instances), (stacksz)}
os_thread_id os_thread_create(const os_thread_def_t *thread_def, void *arg);
/************************************OS_TIMER************************************/
typedef struct os_timer_cb *os_timer_id;
typedef void (*os_ptimer) (void const *argument);
typedef struct
{
os_ptimer ptimer; ///< start address of a timer function
void *timer; ///< pointer to internal data
} os_timer_def_t;
typedef enum
{
OS_TIMER_ONCE = 0, ///< one-shot timer
OS_TIMER_PERIODIC = 1 ///< repeating timer
} os_timer_t;
#define os_timer(name) &os_timer_def_##name
#define os_timer_def(name, function) \
uint32_t os_timer_cb_##name[10]; \
const os_timer_def_t os_timer_def_##name = {(function), (os_timer_cb_##name)}
os_timer_id os_timer_create(const os_timer_def_t *timer_def, os_timer_t type, void *arg);
os_status os_timer_start(os_timer_id timer_id, uint32_t millisec);
os_status os_timer_stop(os_timer_id timer_id);
/************************************OS_MAIL************************************/
typedef struct os_mailq_cb *os_mail_qid;
#define os_mail_qdef(name, queue_sz, type) \
uint32_t os_mailq_q_##name[4 + (queue_sz)] = {0}; \
uint32_t os_mailq_m_##name[3 + ((sizeof(type) + 3) / 4) * (queue_sz)]; \
void *os_mailq_p_##name[2] = {(os_mailq_q_##name), os_mailq_m_##name}; \
const os_mailq_def_t os_mailq_def_##name = \
{(queue_sz), sizeof(type), (os_mailq_p_##name)}
typedef struct os_mailq_def
{
uint32_t queue_sz; ///< number of elements in the queue
uint32_t item_sz; ///< size of an item
void *pool; ///< memory array for mail
} os_mailq_def_t;
#define os_mailq(name) &os_mailq_def_##name
os_mail_qid os_mail_create(const os_mailq_def_t *queue_def, os_thread_id thread_id);
void *os_mail_alloc(os_mail_qid queue_id, uint32_t millisec);
void *os_mail_clean_and_alloc(os_mail_qid queue_id, uint32_t millisec);
os_status os_mail_put(os_mail_qid queue_id, void *mail);
os_event os_mail_get(os_mail_qid queue_id, uint32_t millisec, void *arg);
os_status os_mail_free(os_mail_qid queue_id, void *mail);
/************************************OS_MSG_QUEUE************************************/
/// Message ID identifies the message queue (pointer to a message queue control block).
typedef struct os_messageq_cb *os_message_qid;
typedef struct os_messageq_def
{
uint32_t queue_sz; ///< number of elements in the queue
#if (osCMSIS < 0x20000U)
void *pool; ///< memory array for messages
#else
osMessageQueueAttr_t attr; ///< message queue attributes
#endif
} os_messageq_def_t;
#if (osCMSIS < 0x20000U)
#define os_message_qdef(name, queue_sz, type) \
uint32_t os_messageq_q_##name[4 + (queue_sz)] = {0}; \
const os_messageq_def_t os_messageq_def_##name = {(queue_sz), (os_messageq_q_##name)}
#else
#define os_message_qdef(name, queue_sz, type) \
uint32_t os_messageq_q_##name[4 + (queue_sz)] = {0}; \
const os_messageq_def_t os_messageq_def_##name = {(queue_sz), { NULL, 0U, NULL, 0U, NULL, 0U }}
#endif
/// \brief Access a Message Queue Definition.
/// \param name name of the queue
#define os_messageq(name) &os_messageq_def_##name
os_message_qid os_message_create(const os_messageq_def_t *queue_def, os_thread_id thread_id);
os_status os_message_put(os_message_qid queue_id, uint32_t info, uint32_t millisec);
os_event os_message_get(os_message_qid queue_id, uint32_t millisec);
/************************************OS_POOL************************************/
/// Pool ID identifies the memory pool (pointer to a memory pool control block).
typedef struct os_pool_cb *os_pool_id;
typedef struct os_pool_deft
{
uint32_t pool_sz; ///< number of items (elements) in the pool
uint32_t item_sz; ///< size of an item
void *pool; ///< pointer to memory for pool
} os_pool_def_t;
#define os_pool_def(name, no, type) \
uint32_t os_pool_m_##name[3 + ((sizeof(type) + 3) / 4) * (no)]; \
const os_pool_def_t os_pool_def_##name = \
{(no), sizeof(type), (os_pool_m_##name)}
#define os_pool(name) &os_pool_def_##name
os_pool_id os_pool_create(const os_pool_def_t *pool_def);
void *os_pool_alloc(os_pool_id pool_id);
void *os_pool_calloc(os_pool_id pool_id);
os_status os_pool_free(os_pool_id pool_id, void *block);
/************************************OS_SIGNAL************************************/
int32_t isr_signal_set(os_thread_id thread_id, int32_t signals);
int32_t os_signal_set(os_thread_id thread_id, int32_t signals);
int32_t os_signal_clear(os_thread_id thread_id, int32_t signals);
os_event os_signal_wait(int32_t signals, uint32_t millisec);