基于Linux的kfifo移植到STM32（支持os的互斥訪問）
關于kfifo
kfifo是內核里面的一個First In First Out資料結構，它采用環形回圈佇列的資料結構來實作；它提供一個無邊界的位元組流服務，最重要的一點是，它使用并行無鎖編程技術，即當它用于只有一個入隊執行緒和一個出隊執行緒的場情時，兩個執行緒可以并發操作，而不需要任何加鎖行為，就可以保證kfifo的執行緒安全，
具體什么是環形緩沖區，請看我以前的文章
說明
關于kfifo的相關概念我不會介紹，有興趣可以看他的相關檔案，我只將其實作程序移植重寫，移植到適用stm32開發板上，并且按照我個人習慣重新命名，RingBuff->意為環形緩沖區
RingBuff_t
環形緩沖區的結構體成員變數，具體含義看注釋，
buffer: 用于存放資料的快取
size: buffer空間的大小
in, out: 和buffer一起構成一個回圈佇列， in指向buffer中隊頭，而且out指向buffer中的隊尾
typedef struct ringbuff
{
uint8_t *buffer; /* 資料區域 */
uint32_t size; /* 環形緩沖區大小 */
uint32_t in; /* 資料入隊指標 (in % size) */
uint32_t out; /* 資料出隊指標 (out % size) */
#if USE_MUTEX
MUTEX_T *mutex; /* 支持rtos的互斥 */
#endif
}RingBuff_t ;
Create_RingBuff
創建一個環形緩沖區，為了適應后續對緩沖區入隊出隊的高效操作，環形緩沖區的大小應為2^n位元組，
如果不是這個大小，則系統默認裁剪以對應緩沖區位元組，
當然還可以優化，不過我目前并未做，思路如下：如果系統支持動態分配記憶體，則向上對齊，避免浪費記憶體空間，否則就按照我默認的向下對齊，當記憶體越大，對齊導致記憶體泄漏則會越多，對齊采用的函式是roundup_pow_of_two，如果系統支持互斥量，那么還將創建一個互斥量用來做互斥訪問，防止多執行緒同時使用導致資料丟失，
/************************************************************
* @brief Create_RingBuff
* @param rb：環形緩沖區句柄
* buffer：環形緩沖區的資料區域
* size：環形緩沖區的大小，緩沖區大小要為2^n
* @return err_t：ERR_OK表示創建成功，其他表示失敗
* @author jiejie
* @github https://github.com/jiejieTop
* @date 2018-xx-xx
* @version v1.0
* @note 用于創建一個環形緩沖區
***********************************************************/
err_t Create_RingBuff(RingBuff_t* rb,
uint8_t *buffer,
uint32_t size
)
{
if((rb == NULL)||(buffer == NULL)||(size == 0))
{
PRINT_ERR("data is null!");
return ERR_NULL;
}
PRINT_DEBUG("ringbuff size is %d!",size);
/* 緩沖區大小必須為2^n位元組,系統會強制轉換,
否則可能會導致指標訪問非法地址，
空間大小越大,強轉時丟失記憶體越多 */
if(size&(size - 1))
{
size = roundup_pow_of_two(size);
PRINT_DEBUG("change ringbuff size is %d!",size);
}
rb->buffer = buffer;
rb->size = size;
rb->in = rb->out = 0;
#if USE_MUTEX
/* 創建信號量不成功 */
if(!create_mutex(rb->mutex))
{
PRINT_ERR("create mutex fail!");
ASSERT(ASSERT_ERR);
return ERR_NOK;
}
#endif
PRINT_DEBUG("create ringBuff ok!");
return ERR_OK;
}
roundup_pow_of_two
/************************************************************
* @brief roundup_pow_of_two
* @param size：傳遞進來的資料長度
* @return size：回傳處理之后的資料長度
* @author jiejie
* @github https://github.com/jiejieTop
* @date 2018-xx-xx
* @version v1.0
* @note 用于處理資料，使資料長度必須為 2^n
* 如果不是，則轉換，丟棄多余部分，如
* roundup_pow_of_two(66) -> 回傳 64
***********************************************************/
static unsigned long roundup_pow_of_two(unsigned long x)
{
return (1 << (fls(x-1)-1)); //向下對齊
//return (1UL << fls(x - 1)); //向上對齊，用動態記憶體可用使用
}
Delete_RingBuff
洗掉一個環形緩沖區，洗掉之后，緩沖區真正存盤地址是不會被改變的（目前我是使用自定義陣列做緩沖區的），但是洗掉之后，就無法對緩沖區進行讀寫操作，并且如果支持os的話，創建的互斥量會被洗掉，
/************************************************************
* @brief Delete_RingBuff
* @param rb：環形緩沖區句柄
* @return err_t：ERR_OK表示成功，其他表示失敗
* @author jiejie
* @github https://github.com/jiejieTop
* @date 2018-xx-xx
* @version v1.0
* @note 洗掉一個環形緩沖區
***********************************************************/
err_t Delete_RingBuff(RingBuff_t *rb)
{
if(rb == NULL)
{
PRINT_ERR("ringbuff is null!");
return ERR_NULL;
}
rb->buffer = NULL;
rb->size = 0;
rb->in = rb->out = 0;
#if USE_MUTEX
if(!deleta_mutex(rb->mutex))
{
PRINT_DEBUG("deleta mutex is fail!");
return ERR_NOK;
}
#endif
return ERR_OK;
}
Write_RingBuff
向環形緩沖區寫入指定資料，支持執行緒互斥訪問，用戶想要寫入緩沖區的資料長度不一定是真正入隊的長度，在完成的時候還要看看回傳值是否與用戶需要的長度一致~
這個函式很有意思，也是比較高效的入隊操作，將指定區域的資料拷貝到指定的緩沖區中，程序看注釋即可
/************************************************************
* @brief Write_RingBuff
* @param rb:環形緩沖區句柄
* @param wbuff:寫入的資料起始地址
* @param len:寫入資料的長度(位元組)
* @return len:實際寫入資料的長度(位元組)
* @author jiejie
* @github https://github.com/jiejieTop
* @date 2018-xx-xx
* @version v1.0
* @note 這個函式會從buff空間拷貝len位元組長度的資料到
rb環形緩沖區中的空閑空間，
***********************************************************/
uint32_t Write_RingBuff(RingBuff_t *rb,
uint8_t *wbuff,
uint32_t len)
{
uint32_t l;
#if USE_MUTEX
/* 請求互斥量，成功才能進行ringbuff的訪問 */
if(!request_mutex(rb->mutex))
{
PRINT_DEBUG("request mutex fail!");
return 0;
}
else /* 獲取互斥量成功 */
{
#endif
len = min(len, rb->size - rb->in + rb->out);
/* 第一部分的拷貝:從環形緩沖區寫入資料直至緩沖區最后一個地址 */
l = min(len, rb->size - (rb->in & (rb->size - 1)));
memcpy(rb->buffer + (rb->in & (rb->size - 1)), wbuff, l);
/* 如果溢位則在緩沖區頭寫入剩余的部分
如果沒溢位這句代碼相當于無效 */
memcpy(rb->buffer, wbuff + l, len - l);
rb->in += len;
PRINT_DEBUG("write ringBuff len is %d!",len);
#if USE_MUTEX
}
/* 釋放互斥量 */
release_mutex(rb->mutex);
#endif
return len;
}
Read_RingBuff
讀取緩沖區資料到指定區域，用戶指定讀取長度，用戶想要讀取的長度不一定是真正讀取的長度，在讀取完成的時候還要看看回傳值是否與用戶需要的長度一致~也支持多執行緒互斥訪問，
也是緩沖區出隊的高效操作，程序看代碼注釋即可
/************************************************************
* @brief Read_RingBuff
* @param rb:環形緩沖區句柄
* @param wbuff:讀取資料保存的起始地址
* @param len:想要讀取資料的長度(位元組)
* @return len:實際讀取資料的長度(位元組)
* @author jiejie
* @github https://github.com/jiejieTop
* @date 2018-xx-xx
* @version v1.0
* @note 這個函式會從rb環形緩沖區中的資料區域拷貝len位元組
長度的資料到rbuff空間，
***********************************************************/
uint32_t Read_RingBuff(RingBuff_t *rb,
uint8_t *rbuff,
uint32_t len)
{
uint32_t l;
#if USE_MUTEX
/* 請求互斥量，成功才能進行ringbuff的訪問 */
if(!request_mutex(rb->mutex))
{
PRINT_DEBUG("request mutex fail!");
return 0;
}
else
{
#endif
len = min(len, rb->in - rb->out);
/* 第一部分的拷貝:從環形緩沖區讀取資料直至緩沖區最后一個 */
l = min(len, rb->size - (rb->out & (rb->size - 1)));
memcpy(rbuff, rb->buffer + (rb->out & (rb->size - 1)), l);
/* 如果溢位則在緩沖區頭讀取剩余的部分
如果沒溢位這句代碼相當于無效 */
memcpy(rbuff + l, rb->buffer, len - l);
rb->out += len;
PRINT_DEBUG("read ringBuff len is %d!",len);
#if USE_MUTEX
}
/* 釋放互斥量 */
release_mutex(rb->mutex);
#endif
return len;
}
獲取緩沖區資訊
這些就比較簡單了，看看緩沖區可讀可寫的資料有多少
/************************************************************
* @brief CanRead_RingBuff
* @param rb:環形緩沖區句柄
* @return uint32:可讀資料長度 0 / len
* @author jiejie
* @github https://github.com/jiejieTop
* @date 2018-xx-xx
* @version v1.0
* @note 可讀資料長度
***********************************************************/
uint32_t CanRead_RingBuff(RingBuff_t *rb)
{
if(NULL == rb)
{
PRINT_ERR("ringbuff is null!");
return 0;
}
if(rb->in == rb->out)
return 0;
if(rb->in > rb->out)
return (rb->in - rb->out);
return (rb->size - (rb->out - rb->in));
}
/************************************************************
* @brief CanRead_RingBuff
* @param rb:環形緩沖區句柄
* @return uint32:可寫資料長度 0 / len
* @author jiejie
* @github https://github.com/jiejieTop
* @date 2018-xx-xx
* @version v1.0
* @note 可寫資料長度
***********************************************************/
uint32_t CanWrite_RingBuff(RingBuff_t *rb)
{
if(NULL == rb)
{
PRINT_ERR("ringbuff is null!");
return 0;
}
return (rb->size - CanRead_RingBuff(rb));
}
附帶
這里的代碼我是用于測驗的，隨便寫的
RingBuff_t ringbuff_handle;
uint8_t rb[64];
uint8_t res[64];
Create_RingBuff(&ringbuff_handle,
rb,
sizeof(rb));
Write_RingBuff(&ringbuff_handle,
res,
datapack.data_length);
PRINT_DEBUG("CanRead_RingBuff = %d!",CanRead_RingBuff(&ringbuff_handle));
PRINT_DEBUG("CanWrite_RingBuff = %d!",CanWrite_RingBuff(&ringbuff_handle));
Read_RingBuff(&ringbuff_handle,
res,
datapack.data_length);
支持多個os的互斥量操作
此處模仿了檔案系統的互斥操作
#if USE_MUTEX
#define MUTEX_TIMEOUT 1000 /* 超時時間 */
#define MUTEX_T mutex_t /* 互斥量控制塊 */
#endif
/*********************************** mutex **************************************************/
#if USE_MUTEX
/************************************************************
* @brief create_mutex
* @param mutex:創建信號量句柄
* @return 創建成功為1，0為不成功，
* @author jiejie
* @github https://github.com/jiejieTop
* @date 2018-xx-xx
* @version v1.0
* @note 創建一個互斥量,用戶在os中互斥使用ringbuff，
* 支持的os有rtt、win32、ucos、FreeRTOS、LiteOS
***********************************************************/
static err_t create_mutex(MUTEX_T *mutex)
{
err_t ret = 0;
// *mutex = rt_mutex_create("test_mux",RT_IPC_FLAG_PRIO); /* rtt */
// ret = (err_t)(*mutex != RT_NULL);
// *mutex = CreateMutex(NULL, FALSE, NULL); /* Win32 */
// ret = (err_t)(*mutex != INVALID_HANDLE_VALUE);
// *mutex = OSMutexCreate(0, &err); /* uC/OS-II */
// ret = (err_t)(err == OS_NO_ERR);
// *mutex = xSemaphoreCreateMutex(); /* FreeRTOS */
// ret = (err_t)(*mutex != NULL);
// ret = LOS_MuxCreate(&mutex); /* LiteOS */
// ret = (err_t)(ret != LOS_OK);
return ret;
}
/************************************************************
* @brief deleta_mutex
* @param mutex:互斥量句柄
* @return NULL
* @author jiejie
* @github https://github.com/jiejieTop
* @date 2018-xx-xx
* @version v1.0
* @note 洗掉一個互斥量，支持的os有rtt、win32、ucos、FreeRTOS、LiteOS
***********************************************************/
static err_t deleta_mutex(MUTEX_T *mutex)
{
err_t ret;
// ret = rt_mutex_delete(mutex); /* rtt */
// ret = CloseHandle(mutex); /* Win32 */
// OSMutexDel(mutex, OS_DEL_ALWAYS, &err); /* uC/OS-II */
// ret = (err_t)(err == OS_NO_ERR);
// vSemaphoreDelete(mutex); /* FreeRTOS */
// ret = 1;
// ret = LOS_MuxDelete(&mutex); /* LiteOS */
// ret = (err_t)(ret != LOS_OK);
return ret;
}
/************************************************************
* @brief request_mutex
* @param mutex:互斥量句柄
* @return NULL
* @author jiejie
* @github https://github.com/jiejieTop
* @date 2018-xx-xx
* @version v1.0
* @note 請求一個互斥量，得到互斥量的執行緒才允許進行訪問緩沖區
* 支持的os有rtt、win32、ucos、FreeRTOS、LiteOS
***********************************************************/
static err_t request_mutex(MUTEX_T *mutex)
{
err_t ret;
// ret = (err_t)(rt_mutex_take(mutex, MUTEX_TIMEOUT) == RT_EOK);/* rtt */
// ret = (err_t)(WaitForSingleObject(mutex, MUTEX_TIMEOUT) == WAIT_OBJECT_0); /* Win32 */
// OSMutexPend(mutex, MUTEX_TIMEOUT, &err)); /* uC/OS-II */
// ret = (err_t)(err == OS_NO_ERR);
// ret = (err_t)(xSemaphoreTake(mutex, MUTEX_TIMEOUT) == pdTRUE); /* FreeRTOS */
// ret = (err_t)(LOS_MuxPend(mutex,MUTEX_TIMEOUT) == LOS_OK); /* LiteOS */
return ret;
}
/************************************************************
* @brief release_mutex
* @param mutex:互斥量句柄
* @return NULL
* @author jiejie
* @github https://github.com/jiejieTop
* @date 2018-xx-xx
* @version v1.0
* @note 釋放互斥量，當執行緒使用完資源必須釋放互斥量
* 支持的os有rtt、win32、ucos、FreeRTOS、LiteOS
***********************************************************/
static void release_mutex(MUTEX_T *mutex)
{
// rt_mutex_release(mutex);/* rtt */
// ReleaseMutex(mutex); /* Win32 */
// OSMutexPost(mutex); /* uC/OS-II */
// xSemaphoreGive(mutex); /* FreeRTOS */
// LOS_MuxPost(mutex); /* LiteOS */
}
#endif
/*********************************** mutex **************************************************/
debug.h
最后送一份debug的簡便操作原始碼，因為前文很多時候會呼叫
PRINT_ERR
PRINT_DEBUG
#ifndef _DEBUG_H
#define _DEBUG_H
/************************************************************
* @brief debug.h
* @author jiejie
* @github https://github.com/jiejieTop
* @date 2018-xx-xx
* @version v1.0
* @note 此檔案用于列印日志資訊
***********************************************************/
/**
* @name Debug print
* @{
*/
#define PRINT_DEBUG_ENABLE 1 /* 列印除錯資訊 */
#define PRINT_ERR_ENABLE 1 /* 列印錯誤資訊 */
#define PRINT_INFO_ENABLE 0 /* 列印個人資訊 */
#if PRINT_DEBUG_ENABLE
#define PRINT_DEBUG(fmt, args...) do{(printf("\n[DEBUG] >> "), printf(fmt, ##args));}while(0)
#else
#define PRINT_DEBUG(fmt, args...)
#endif
#if PRINT_ERR_ENABLE
#define PRINT_ERR(fmt, args...) do{(printf("\n[ERR] >> "), printf(fmt, ##args));}while(0)
#else
#define PRINT_ERR(fmt, args...)
#endif
#if PRINT_INFO_ENABLE
#define PRINT_INFO(fmt, args...) do{(printf("\n[INFO] >> "), printf(fmt, ##args));}while(0)
#else
#define PRINT_INFO(fmt, args...)
#endif
/**@} */
//針對不同的編譯器呼叫不同的stdint.h檔案
#if defined(__ICCARM__) || defined(__CC_ARM) || defined(__GNUC__)
#include <stdint.h>
#endif
/* 斷言 Assert */
#define AssertCalled(char,int) printf("\nError:%s,%d\r\n",char,int)
#define ASSERT(x) if((x)==0) AssertCalled(__FILE__,__LINE__)
typedef enum
{
ASSERT_ERR = 0, /* 錯誤 */
ASSERT_SUCCESS = !ASSERT_ERR /* 正確 */
} Assert_ErrorStatus;
typedef enum
{
FALSE = 0, /* 假 */
TRUE = !FALSE /* 真 */
}ResultStatus;
#endif /* __DEBUG_H */
喜歡就關注我吧！
相關代碼可以在公眾號后臺獲取，
更多資料歡迎關注“物聯網IoT開發”公眾號！
轉載請註明出處，本文鏈接：https://www.uj5u.com/caozuo/33432.html
標籤：嵌入式