无锁FIFO用于前后台数据交互

wanglehui_12 · 发表于 2021-12-16 16:55:43

近日在移植代码的过程中，发现MicroCHIP的ASF3库里带的FIFO数据结构代码比较有意思

是个简单有效的无锁FIFO实现。用于前后台程序之间数据搬运处理，通过约束读写操作，实现不需要的加临界区资源保护的处理。

源码分享给大伙，有兴趣可以看看。

fifo.c (3.21 KB, 下载次数: 70)

fifo.h (2.28 KB, 下载次数: 76)

eric2013 · 发表于 2021-12-16 17:23:29

这代码做的真简洁，值得看看

/**
* \file fifo.c
*
* \brief FIFO definitions
*
* Copyright (c) 2018 Microchip Technology Inc. and its subsidiaries.
*
* \asf_license_start
*
* \page License
*
* Subject to your compliance with these terms, you may use Microchip
* software and any derivatives exclusively with Microchip products.
* It is your responsibility to comply with third party license terms applicable
* to your use of third party software (including open source software) that
* may accompany Microchip software.
*
* THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES,
* WHETHER EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE,
* INCLUDING ANY IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY,
* AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT WILL MICROCHIP BE
* LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE, INCIDENTAL OR CONSEQUENTIAL
* LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND WHATSOEVER RELATED TO THE
* SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP HAS BEEN ADVISED OF THE
* POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO THE FULLEST EXTENT
* ALLOWED BY LAW, MICROCHIP'S TOTAL LIABILITY ON ALL CLAIMS IN ANY WAY
* RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT OF FEES, IF ANY,
* THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS SOFTWARE.
*
* \asf_license_stop
*/
/*
* Support and FAQ: visit <a href="https://www.microchip.com/support/">Microchip Support</a>
*/
/*
lock-free FIFO, used to receive data in ISR context,
and process it in Main context
for optimization size MUST be power of 2, ie 2, 4, 8, 16, 32, ...
*/
#include "fifo.h"
#include <stddef.h>
uint8_t fifo_init(fifo_t *const fifo, uint8_t *const buffer, const uint32_t size)
{
/* check buffer pointer, and buffer size
buffer size MUST be 2 to the power n
*/
if (NULL != fifo && size > 0 && (size & (size - 1)) == 0)
{
fifo->buffer = buffer;
fifo->size = size;
/* valid indexes can be used to access array of size n is from 0 to n-1
mask used to get the valid index to access fifo buffer from wr_idx and rd_idx
for example size = 128 (dec) = 00000080 (hex) = 00000000000000000000000010000000 (bin)
mask = 127 (dec) = 0000007F (hex) = 00000000000000000000000001111111 (bin)
*/
fifo->mask = size - 1;
fifo->wr_idx = 0;
fifo->rd_idx = 0;
return 1;
}
return 0;
}
uint8_t fifo_empty(fifo_t *const fifo)
{
return (fifo->wr_idx == fifo->rd_idx);
}
uint8_t fifo_full(fifo_t *const fifo)
{
return ((fifo->wr_idx - fifo->rd_idx) == fifo->size);
}
uint8_t fifo_get(fifo_t *const fifo, uint8_t *const byte)
{
if (!fifo_empty(fifo))
{
/* get the valid index from rd_idx by masking current rd_idx with pre calculated mask
it will convert all bit to zeros except bits inside valid range of bits
*/
*byte = fifo->buffer[fifo->mask & fifo->rd_idx++];
return 1;
}
return 0;
}
uint8_t fifo_put(fifo_t *const fifo, const uint8_t byte)
{
if (!fifo_full(fifo))
{
/* get the valid index from rd_idx by masking current wr_idx with pre calculated mask
it will convert all bit to zeros except bits inside valid range of bits
*/
fifo->buffer[fifo->mask & fifo->wr_idx++] = byte;
return 1;
}
return 0;
}

复制代码

/**
* \file fifo.h
*
* \brief FIFO declarations
*
* Copyright (c) 2018 Microchip Technology Inc. and its subsidiaries.
*
* \asf_license_start
*
* \page License
*
* Subject to your compliance with these terms, you may use Microchip
* software and any derivatives exclusively with Microchip products.
* It is your responsibility to comply with third party license terms applicable
* to your use of third party software (including open source software) that
* may accompany Microchip software.
*
* THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES,
* WHETHER EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE,
* INCLUDING ANY IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY,
* AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT WILL MICROCHIP BE
* LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE, INCIDENTAL OR CONSEQUENTIAL
* LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND WHATSOEVER RELATED TO THE
* SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP HAS BEEN ADVISED OF THE
* POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO THE FULLEST EXTENT
* ALLOWED BY LAW, MICROCHIP'S TOTAL LIABILITY ON ALL CLAIMS IN ANY WAY
* RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT OF FEES, IF ANY,
* THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS SOFTWARE.
*
* \asf_license_stop
*/
/*
* Support and FAQ: visit <a href="https://www.microchip.com/support/">Microchip Support</a>
*/
/*
lock-free FIFO, used to receive data in ISR context,
and process it in Main context
for optimization size MUST be power of 2, ie 2, 4, 8, 16, 32, ...
*/
#ifndef __FIFO_H__
#define __FIFO_H__
#include <stdint.h>
#include <stdbool.h>
typedef struct fifo_handle_tag
{
volatile uint32_t wr_idx; /* counter for FIFO input, inc in ISR only */
volatile uint32_t rd_idx; /* counter for FIFO output, inc in MAIN only */
uint32_t size; /* FIFO buffer size */
uint32_t mask; /* Mask to extract buffer index from counters */
uint8_t *buffer; /* FIFO buffer */
} fifo_t;
uint8_t fifo_init(fifo_t *const fifo, uint8_t *const buffer, const uint32_t size);
uint8_t fifo_empty(fifo_t *const fifo);
uint8_t fifo_full(fifo_t *const fifo);
uint8_t fifo_get(fifo_t *const fifo, uint8_t *const byte);
uint8_t fifo_put(fifo_t *const fifo, const uint8_t byte);
#endif //__FIFO_H__

复制代码

----- · 发表于 2021-12-16 19:00:25

赞一个！
我之前用的是Linux Kernel中抽取的FIFO，也是要求Buffer长度必须为2的幂次。

xiaomeng · 发表于 2021-12-18 00:03:10

mark

wdliming · 发表于 2021-12-18 10:58:28

mark

WSTON · 发表于 2021-12-18 11:06:56

很好，看着想把buffer改写成结构体，封装一层数据

落叶凋零 · 发表于 2021-12-19 12:44:30

感谢分享，这里的idx如果溢出了会不会出问题？

roguebear · 发表于 2021-12-19 13:38:55

可以用linux的fifo，我自己一直用。这个应该就是魔改的linux的fifo。

平哥 · 发表于 2021-12-20 10:53:43

这是最新版的，fifo.c里只有初始化，剩余的操作都放到fifo.h,使用内联函数实现，实现的思想和语法很有参考意义。
,

/**
* \file
*
* \brief This file controls the software FIFO management.
*
* These functions manages FIFOs thanks to simple a API. The FIFO can
* be 100% full thanks to a double-index range implementation. For example,
* a FIFO of 4 elements can be implemented: the FIFO can really hold up to 4
* elements.
* This is particularly well suited for any kind of application needing a lot of
* small FIFO.
*
* Copyright (c) 2010-2018 Microchip Technology Inc. and its subsidiaries.
*
* \asf_license_start
*
* \page License
*
* Subject to your compliance with these terms, you may use Microchip
* software and any derivatives exclusively with Microchip products.
* It is your responsibility to comply with third party license terms applicable
* to your use of third party software (including open source software) that
* may accompany Microchip software.
*
* THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES,
* WHETHER EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE,
* INCLUDING ANY IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY,
* AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT WILL MICROCHIP BE
* LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE, INCIDENTAL OR CONSEQUENTIAL
* LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND WHATSOEVER RELATED TO THE
* SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP HAS BEEN ADVISED OF THE
* POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO THE FULLEST EXTENT
* ALLOWED BY LAW, MICROCHIP'S TOTAL LIABILITY ON ALL CLAIMS IN ANY WAY
* RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT OF FEES, IF ANY,
* THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS SOFTWARE.
*
* \asf_license_stop
*
*/
/*
* Support and FAQ: visit <a href="https://www.microchip.com/support/">Microchip Support</a>
*/
#ifndef _FIFO_H_
#define _FIFO_H_
#include "compiler.h"
/**
* \defgroup fifo_group First-In-First-Out Buffer (FIFO)
*
* See \ref fifo_quickstart.
*
* These functions manages FIFOs thanks to simple a API. The FIFO can
* be 100% full thanks to a double-index range implementation. For example,
* a FIFO of 4 elements can be implemented: the FIFO can really hold up to 4
* elements. This is particularly well suited for any kind of application
* needing a lot of small FIFO. The maximum fifo size is 128 items (uint8,
* uint16 or uint32). Note that the driver, thanks to its conception, does
* not use interrupt protection.
*
* @{
*/
//! Error codes used by FIFO driver.
enum {
FIFO_OK = 0, //!< Normal operation.
FIFO_ERROR_OVERFLOW, //!< Attempt to push something in a FIFO that is full.
FIFO_ERROR_UNDERFLOW, //!< Attempt to pull something from a FIFO that is empty
FIFO_ERROR, //!< Error condition during FIFO initialization
};
//! FIFO descriptor used by FIFO driver.
struct fifo_desc {
union
{
uint32_t *u32ptr; //!< Pointer to unsigned-32 bits location
uint16_t *u16ptr; //!< Pointer to unsigned-16 bits location
uint8_t *u8ptr; //!< Pointer to unsigned-8 bits location
} buffer;
volatile uint8_t read_index; //!< Read index
volatile uint8_t write_index; //!< Write index
uint8_t size; //!< Size of the FIFO (unit is in number of 'element')
uint8_t mask; //!< Mask used to speed up FIFO operation (wrapping)
};
typedef struct fifo_desc fifo_desc_t;
/**
* \brief Initializes a new software FIFO for a certain 'size'.
*
* \pre Both fifo descriptor and buffer must be allocated by the caller before.
*
* \param fifo_desc Pointer on the FIFO descriptor.
* \param buffer Pointer on the FIFO buffer.
* \param size Size of the buffer (unit is in number of 'elements').
* It must be a 2-power and <= to 128.
*
* \return Status
* \retval FIFO_OK when no error occurred.
* \retval FIFO_ERROR when the size is not a 2-power.
*/
int fifo_init(fifo_desc_t *fifo_desc, void *buffer, uint8_t size);
/**
* \brief Returns the number of elements in the FIFO.
*
* \param fifo_desc The FIFO descriptor.
*
* \return The number of used elements.
*/
static inline uint8_t fifo_get_used_size(fifo_desc_t *fifo_desc)
{
return ((fifo_desc->write_index - fifo_desc->read_index) & fifo_desc->mask);
}
/**
* \brief Returns the remaining free spaces of the FIFO (in number of elements).
*
* \param fifo_desc The FIFO descriptor.
*
* \return The number of free elements.
*/
static inline uint8_t fifo_get_free_size(fifo_desc_t *fifo_desc)
{
return fifo_desc->size - fifo_get_used_size(fifo_desc);
}
/**
* \brief Tests if a FIFO is empty.
*
* \param fifo_desc The FIFO descriptor.
*
* \return Status
* \retval true when the FIFO is empty.
* \retval false when the FIFO is not empty.
*/
static inline bool fifo_is_empty(fifo_desc_t *fifo_desc)
{
return (fifo_desc->write_index == fifo_desc->read_index);
}
/**
* \brief Tests if a FIFO is full.
*
* \param fifo_desc The FIFO descriptor.
*
* \return Status
* \retval true when the FIFO is full.
* \retval false when the FIFO is not full.
*/
static inline bool fifo_is_full(fifo_desc_t *fifo_desc)
{
return (fifo_get_used_size(fifo_desc) == fifo_desc->size);
}
/**
* \brief Puts a new 8-bits element into the FIFO.
*
* \param fifo_desc The FIFO descriptor.
* \param item extracted element.
*/
static inline void fifo_push_uint8_nocheck(fifo_desc_t *fifo_desc, uint32_t item)
{
uint8_t write_index;
write_index = fifo_desc->write_index;
fifo_desc->buffer.u8ptr[write_index & (fifo_desc->mask >> 1)] = item;
write_index = (write_index + 1) & fifo_desc->mask;
// Must be the last thing to do.
barrier();
fifo_desc->write_index = write_index;
}
/**
* \brief Puts a new 8-bits element into the FIFO and
* checks for a possible overflow.
*
* \param fifo_desc The FIFO descriptor.
* \param item extracted element.
*
* \return Status
* \retval FIFO_OK when no error occurred.
* \retval FIFO_ERROR_UNDERFLOW when the FIFO was empty.
*/
static inline int fifo_push_uint8(fifo_desc_t *fifo_desc, uint32_t item)
{
uint8_t write_index;
if (fifo_is_full(fifo_desc)) {
return FIFO_ERROR_OVERFLOW;
}
write_index = fifo_desc->write_index;
fifo_desc->buffer.u8ptr[write_index & (fifo_desc->mask >> 1)] = item;
write_index = (write_index + 1) & fifo_desc->mask;
// Must be the last thing to do.
barrier();
fifo_desc->write_index = write_index;
return FIFO_OK;
}
/**
* \brief Puts a new 16-bits element into the FIFO.
*
* \param fifo_desc The FIFO descriptor.
* \param item extracted element.
*/
static inline void fifo_push_uint16_nocheck(fifo_desc_t *fifo_desc, uint32_t item)
{
uint8_t write_index;
write_index = fifo_desc->write_index;
fifo_desc->buffer.u16ptr[write_index & (fifo_desc->mask >> 1)] = item;
write_index = (write_index + 1) & fifo_desc->mask;
// Must be the last thing to do.
barrier();
fifo_desc->write_index = write_index;
}
/**
* \brief Puts a new 16-bits element into the FIFO and
* checks for a possible overflow.
*
* \param fifo_desc The FIFO descriptor.
* \param item extracted element.
*
* \return Status
* \retval FIFO_OK when no error occurred.
* \retval FIFO_ERROR_UNDERFLOW when the FIFO was empty.
*/
static inline int fifo_push_uint16(fifo_desc_t *fifo_desc, uint32_t item)
{
uint8_t write_index;
if (fifo_is_full(fifo_desc)) {
return FIFO_ERROR_OVERFLOW;
}
write_index = fifo_desc->write_index;
fifo_desc->buffer.u16ptr[write_index & (fifo_desc->mask >> 1)] = item;
write_index = (write_index + 1) & fifo_desc->mask;
// Must be the last thing to do.
barrier();
fifo_desc->write_index = write_index;
return FIFO_OK;
}
/**
* \brief Puts a new 32-bits element into the FIFO.
*
* \param fifo_desc The FIFO descriptor.
* \param item extracted element.
*/
static inline void fifo_push_uint32_nocheck(fifo_desc_t *fifo_desc, uint32_t item)
{
uint8_t write_index;
write_index = fifo_desc->write_index;
fifo_desc->buffer.u32ptr[write_index & (fifo_desc->mask >> 1)] = item;
write_index = (write_index + 1) & fifo_desc->mask;
// Must be the last thing to do.
barrier();
fifo_desc->write_index = write_index;
}
/**
* \brief Puts a new 32-bits element into the FIFO and
* checks for a possible overflow.
*
* \param fifo_desc The FIFO descriptor.
* \param item extracted element.
*
* \return Status
* \retval FIFO_OK when no error occurred.
* \retval FIFO_ERROR_UNDERFLOW when the FIFO was empty.
*/
static inline int fifo_push_uint32(fifo_desc_t *fifo_desc, uint32_t item)
{
uint8_t write_index;
if (fifo_is_full(fifo_desc)) {
return FIFO_ERROR_OVERFLOW;
}
write_index = fifo_desc->write_index;
fifo_desc->buffer.u32ptr[write_index & (fifo_desc->mask >> 1)] = item;
write_index = (write_index + 1) & fifo_desc->mask;
// Must be the last thing to do.
barrier();
fifo_desc->write_index = write_index;
return FIFO_OK;
}
/**
* \brief Gets a 8-bits element from the FIFO.
*
* \param fifo_desc The FIFO descriptor.
*
* \return extracted element.
*/
static inline uint8_t fifo_pull_uint8_nocheck(fifo_desc_t *fifo_desc)
{
uint8_t read_index;
uint8_t item;
read_index = fifo_desc->read_index;
item = fifo_desc->buffer.u8ptr[read_index & (fifo_desc->mask >> 1)];
read_index = (read_index + 1) & fifo_desc->mask;
// Must be the last thing to do.
barrier();
fifo_desc->read_index = read_index;
return item;
}
/**
* \brief Gets a 8-bits element from the FIFO and
* checks for a possible underflow.
*
* \param fifo_desc The FIFO descriptor.
* \param item extracted element.
*
* \return Status
* \retval FIFO_OK when no error occurred.
* \retval FIFO_ERROR_UNDERFLOW when the FIFO was empty.
*/
static inline int fifo_pull_uint8(fifo_desc_t *fifo_desc, uint8_t *item)
{
uint8_t read_index;
if (fifo_is_empty(fifo_desc)) {
return FIFO_ERROR_UNDERFLOW;
}
read_index = fifo_desc->read_index;
*item = fifo_desc->buffer.u8ptr[read_index & (fifo_desc->mask >> 1)];
read_index = (read_index + 1) & fifo_desc->mask;
// Must be the last thing to do.
barrier();
fifo_desc->read_index = read_index;
return FIFO_OK;
}
/**
* \brief Gets a 16-bits element from the FIFO.
*
* \param fifo_desc The FIFO descriptor.
*
* \return extracted element.
*/
static inline uint16_t fifo_pull_uint16_nocheck(fifo_desc_t *fifo_desc)
{
uint8_t read_index;
uint16_t item;
read_index = fifo_desc->read_index;
item = fifo_desc->buffer.u16ptr[read_index & (fifo_desc->mask >> 1)];
read_index = (read_index + 1) & fifo_desc->mask;
// Must be the last thing to do.
barrier();
fifo_desc->read_index = read_index;
return item;
}
/**
* \brief Gets a 16-bits element from the FIFO and
* checks for a possible underflow.
*
* \param fifo_desc The FIFO descriptor.
* \param item extracted element.
*
* \return Status
* \retval FIFO_OK when no error occurred.
* \retval FIFO_ERROR_UNDERFLOW when the FIFO was empty.
*/
static inline int fifo_pull_uint16(fifo_desc_t *fifo_desc, uint16_t *item)
{
uint8_t read_index;
if (fifo_is_empty(fifo_desc)) {
return FIFO_ERROR_UNDERFLOW;
}
read_index = fifo_desc->read_index;
*item = fifo_desc->buffer.u16ptr[read_index & (fifo_desc->mask >> 1)];
read_index = (read_index + 1) & fifo_desc->mask;
// Must be the last thing to do.
barrier();
fifo_desc->read_index = read_index;
return FIFO_OK;
}
/**
* \brief Gets a 32-bits element from the FIFO
*
* \param fifo_desc The FIFO descriptor.
*
* \return extracted element.
*/
static inline uint32_t fifo_pull_uint32_nocheck(fifo_desc_t *fifo_desc)
{
uint8_t read_index;
uint32_t item;
read_index = fifo_desc->read_index;
item = fifo_desc->buffer.u32ptr[read_index & (fifo_desc->mask >> 1)];
read_index = (read_index + 1) & fifo_desc->mask;
// Must be the last thing to do.
barrier();
fifo_desc->read_index = read_index;
return item;
}
/**
* \brief Gets a 32-bits element from the FIFO and
* checks for a possible underflow.
*
* \param fifo_desc The FIFO descriptor.
* \param item extracted element.
*
* \return Status
* \retval FIFO_OK when no error occurred.
* \retval FIFO_ERROR_UNDERFLOW when the FIFO was empty.
*/
static inline int fifo_pull_uint32(fifo_desc_t *fifo_desc, uint32_t *item)
{
uint8_t read_index;
if (fifo_is_empty(fifo_desc)) {
return FIFO_ERROR_UNDERFLOW;
}
read_index = fifo_desc->read_index;
*item = fifo_desc->buffer.u32ptr[read_index & (fifo_desc->mask >> 1)];
read_index = (read_index + 1) & fifo_desc->mask;
// Must be the last thing to do.
barrier();
fifo_desc->read_index = read_index;
return FIFO_OK;
}
/**
* \brief Gets a 32-bits element from the FIFO but does
* not remove it from the FIFO.
*
* \param fifo_desc The FIFO descriptor.
*
* \retval item extracted element.
*/
static inline uint32_t fifo_peek_uint32(fifo_desc_t *fifo_desc)
{
return fifo_desc->buffer.u32ptr[fifo_desc->read_index & (fifo_desc->mask >> 1)];
}
/**
* \brief Gets a 16-bits element from the FIFO but does
* not remove it from the FIFO.
*
* \param fifo_desc The FIFO descriptor.
*
* \retval item extracted element.
*/
static inline uint16_t fifo_peek_uint16(fifo_desc_t *fifo_desc)
{
return fifo_desc->buffer.u16ptr[fifo_desc->read_index & (fifo_desc->mask >> 1)];
}
/**
* \brief Gets a 8-bits element from the FIFO but does
* not remove it from the FIFO.
*
* \param fifo_desc The FIFO descriptor.
*
* \retval item extracted element.
*/
static inline uint8_t fifo_peek_uint8(fifo_desc_t *fifo_desc)
{
return fifo_desc->buffer.u8ptr[fifo_desc->read_index & (fifo_desc->mask >> 1)];
}
/**
* \brief Flushes a software FIFO.
*
* \param fifo_desc The FIFO descriptor.
*/
static inline void fifo_flush(fifo_desc_t *fifo_desc)
{
// Fifo starts empty.
fifo_desc->read_index = fifo_desc->write_index = 0;
}
/**
* @}
*/
/**
* \page fifo_quickstart Quick start guide for First-In-First-Out Buffer (FIFO)
*
* This is the quick start guide for the \ref fifo_group, with
* step-by-step instructions on how to configure and use the driver in a
* selection of use cases.
*
* The use cases contain several code fragments. The code fragments in the
* steps for setup can be copied into a custom initialization function, while
* the steps for usage can be copied into, e.g., the main application function.
*
* \section fifo_use_cases FIFO use cases
* - \ref fifo_basic_use_case
* - \subpage fifo_use_case_1
*
* \section fifo_basic_use_case Basic use case - Push and pull
* In this use case, an element will be pushed to the FIFO, and the same
* element will be pulled from it.
*
* \section fifo_basic_use_case_setup Setup steps
*
* \subsection fifo_basic_use_case_setup_code Example code
* The following must be added to the project:
* \code
#define FIFO_BUFFER_LENGTH 4
#define PUSH_VALUE 0x12345678
union buffer_element {
uint8_t byte;
uint16_t halfword;
uint32_t word;
};
\endcode
*
* Add to application initialization:
* \code
union buffer_element fifo_buffer[FIFO_BUFFER_LENGTH];
fifo_desc_t fifo_desc;
fifo_init(&fifo_desc, fifo_buffer, FIFO_BUFFER_LENGTH);
\endcode
*
* \subsection fifo_basic_use_case_setup_flow Workflow
* -# Create a FIFO buffer of FIFO_BUFFER_LENGTH elements, capable
* of holding a byte, halfword or word:
* - \code union buffer_element fifo_buffer[FIFO_BUFFER_LENGTH]; \endcode
* -# Create a FIFO buffer descriptor that contains information about the
* location of the FIFO buffer, its size and where to read from or write to
* upon the next buffer pull or push:
* - \code fifo_desc_t fifo_desc; \endcode
* -# Initialize the FIFO:
* - \code fifo_init(&fifo_desc, fifo_buffer, FIFO_BUFFER_LENGTH); \endcode
*
* \section fifo_basic_use_case_usage Usage steps
*
* \subsection fifo_basic_use_case_usage_code Example code
* Add to application C-file:
* \code
uint8_t status;
uint8_t pull_value;
status = fifo_push_uint8(&fifo_desc, PUSH_VALUE & 0xff);
status = fifo_pull_uint8(&fifo_desc, &pull_value);
\endcode
*
* \subsection fifo_basic_use_case_usage_flow Workflow
* -# Create a variable to hold the return status from the FIFO:
* - \code uint8_t status; \endcode
* -# Create a variable to hold the pulled value from the FIFO:
* - \code uint8_t pull_value; \endcode
* -# Put a new 8-bit element into the FIFO:
* - \code status = fifo_push_uint8(&fifo_desc, PUSH_VALUE & 0xff); \endcode
* \note The status variable will contain \ref FIFO_OK if no error occurred.
* -# Get the 8-bit element from the FIFO:
* - \code status = fifo_pull_uint8(&fifo_desc, &pull_value); \endcode
* \note The status variable will contain \ref FIFO_OK if no error occurred.
*/
/**
* \page fifo_use_case_1 Push and flush
*
* In this use case, two elements will be pushed to the FIFO, and the FIFO
* will be flushed.
*
* \section fifo_use_case_1_setup Setup steps
*
* \subsection fifo_use_case_1_setup_code Example code
* The following must be added to the project:
* \code
#define FIFO_BUFFER_LENGTH 4
#define PUSH_VALUE 0x12345678
union buffer_element {
uint8_t byte;
uint16_t halfword;
uint32_t word;
};
\endcode
*
* Add to application initialization:
* \code
union buffer_element fifo_buffer[FIFO_BUFFER_LENGTH];
fifo_desc_t fifo_desc;
fifo_init(&fifo_desc, fifo_buffer, FIFO_BUFFER_LENGTH);
\endcode
*
* \subsection fifo_use_case_1_setup_flow Workflow
* -# Create a FIFO buffer of FIFO_BUFFER_LENGTH elements, capable
* of holding a byte, halfword or word:
* - \code union buffer_element fifo_buffer[FIFO_BUFFER_LENGTH]; \endcode
* -# Create a FIFO buffer descriptor that containing information about the
* location of the FIFO buffer, its size and where to read from or write to
* upon the next buffer pull or push:
* - \code fifo_desc_t fifo_desc; \endcode
* -# Initialize the FIFO:
* - \code fifo_init(&fifo_desc, fifo_buffer, FIFO_BUFFER_LENGTH); \endcode
* \section fifo_use_case_1_usage Usage steps
*
* \subsection fifo_use_case_1_usage_code Example code
* Add to application C-file:
* \code
uint8_t status;
bool fifo_empty;
status = fifo_push_uint16(&fifo_desc, PUSH_VALUE & 0xffff);
status = fifo_push_uint16(&fifo_desc, PUSH_VALUE & 0xffff);
fifo_flush(&fifo_desc);
fifo_empty = fifo_is_empty(&fifo_desc);
\endcode
*
* \subsection fifo_use_case_1_usage_flow Workflow
* -# Create a variable to hold the return status from the FIFO:
* - \code uint8_t status; \endcode
* -# Create a variable to hold the pulled value from the FIFO:
* - \code uint16_t pull_value; \endcode
* -# Put two new 16-bit element into the FIFO:
* - \code status = fifo_push_uint16(&fifo_desc, PUSH_VALUE & 0xffff); \endcode
* - \code status = fifo_push_uint16(&fifo_desc, PUSH_VALUE & 0xffff); \endcode
* \note The status variable will contain \ref FIFO_OK if no error occurred.
* -# Flush the FIFO:
* - \code fifo_flush(&fifo_desc); \endcode
* -# Check that the FIFO is empty after flushing:
* - \code fifo_empty = fifo_is_empty(&fifo_desc); \endcode
* \note The fifo_empty variable will be true if the FIFO is empty.
*/
#endif // _FIFO_H_

复制代码

平哥 · 发表于 2021-12-20 10:54:20

fifo.c:

/**
* \file
*
* \brief This file controls the software FIFO management.
*
* These functions manages FIFOs thanks to simple a API. The FIFO can
* be 100% full thanks to a double-index range implementation. For example,
* a FIFO of 4 elements can be implemented: the FIFO can really hold up to 4
* elements.
* This is particularly well suited for any kind of application needing a lot of
* small FIFO.
*
*
* \asf_license_start
*
* \page License
*
* Subject to your compliance with these terms, you may use Microchip
* software and any derivatives exclusively with Microchip products.
* It is your responsibility to comply with third party license terms applicable
* to your use of third party software (including open source software) that
* may accompany Microchip software.
*
* THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES,
* WHETHER EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE,
* INCLUDING ANY IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY,
* AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT WILL MICROCHIP BE
* LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE, INCIDENTAL OR CONSEQUENTIAL
* LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND WHATSOEVER RELATED TO THE
* SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP HAS BEEN ADVISED OF THE
* POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO THE FULLEST EXTENT
* ALLOWED BY LAW, MICROCHIP'S TOTAL LIABILITY ON ALL CLAIMS IN ANY WAY
* RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT OF FEES, IF ANY,
* THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS SOFTWARE.
*
* \asf_license_stop
*
*/
/*
* Support and FAQ: visit <a href="https://www.microchip.com/support/">Microchip Support</a>
*/
#include "fifo.h"
int fifo_init(fifo_desc_t *fifo_desc, void *buffer, uint8_t size)
{
// Check the size parameter. It must be not null...
Assert (size);
// ... must be a 2-power ...
Assert (!(size & (size - 1)));
// ... and must fit in a uint8_t. Since the read and write indexes are using a
// double-index range implementation, the max FIFO size is thus 128 items.
Assert (size <= 128);
// Fifo starts empty.
fifo_desc->read_index = 0;
fifo_desc->write_index = 0;
// Save the size parameter.
fifo_desc->size = size;
// Create a mask to speed up the FIFO management (index swapping).
fifo_desc->mask = (2 * (uint16_t)size) - 1;
// Save the buffer pointer.
fifo_desc->buffer.u8ptr = buffer;
return FIFO_OK;
}

复制代码

morning_enr6U · 发表于 2021-12-20 13:14:33

平哥发表于 2021-12-20 10:54
fifo.c:

这个fifo模块，可以用在RTOS的多线程吗？有什么禁忌事项吗？谢谢！

平哥 · 发表于 2021-12-20 13:27:43

morning_enr6U 发表于 2021-12-20 13:14
这个fifo模块，可以用在RTOS的多线程吗？有什么禁忌事项吗？谢谢！

我觉得可以用，而且不需要开关中断，item的数量是限制在uint8_t的范围之内的。

wanglehui_12 · 发表于 2021-12-20 13:45:26

我的理解是这样的：

ISR函数和非ISR函数对读写索引的操作可认为是自动有临界区保护了

在线程函数中使用，这个前提不一定存在，所以慎用，或者还是得加锁

从Linux内核中抽出来的kfifo代码，本意也是在内核和用户态之间共享数据，也是有这个自动有锁效果的假设

		自动登录	找回密码
密码			立即注册

[其它] 无锁FIFO用于前后台数据交互