环形队列FIFO

最新推荐文章于 2024-06-08 12:31:38 发布
最新推荐文章于 2024-06-08 12:31:38 发布
阅读量1.5k 收藏 3
点赞数
分类专栏： 内存 文章标签： 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huan447882949/article/details/73556669
版权

建立自己的缓存区，可以有序的发送接收数据，不担心数据丢失，可以有序地处理。

// -----------------------------------------------------------------------------
// File Name    : fifo.h
// Title        : General FIFO template
// Author       : Seeseawe - Copyright (C) 2008
// Created      : 2008-4-2
// Version      : 0.3
// Target MCU   : Any
// Editor Tabs  : 4
// Editor Line  : 80 chars/line
// -----------------------------------------------------------------------------
// Overview:
/*
    This template provides a convenient way to create a FIFO circular buffer.
*/
// Version History:
/*
    >>>2008-4-6: V0.3 is released.
        C: Changed data type of FIFO position pointer.
    >>>2008-4-3: V0.2 is released.
        +: FIFO_DUMP_DATA(FifoName, Num);
        +: FIFO_PUT_STR(FifoName, ptrData, Num);
        +: FIFO_GET_STR(FifoName, ptrData, Num);
        +: FIFO_PUTS(FifoName, "TxtString");
        +: FIFO_##__NAME##_PutOneInt(Data);
        +: FIFO_##__NAME##_GetOneInt(ptrData);
        -: None
        C: Changed FIFO_PEEK_ONE(ptrData) to FIFO_PEEK_ONE(ptrData, index).

    >>>2008-4-2: V0.1 is released.
*/

#ifndef __FIFO_H__
#define __FIFO_H__

/* **********************************************************
*   模板库说明：环形队列模板                               *
*   版本：      v1.00beta                                  *
*   作者：      王卓然(OurAVR 傻孩子)                       *
*   创建日期：  2008年1月19日                              *
* -------------------------------------------------------- *
*  [使用说明]                                              *
假设我想建立一个UART接收缓冲区，我们需要首先在UART模块的C文件里创建
一个环形队列，名叫UART_RxFifo,大小为128个字节：
    NEW_FIFO(UART_RxFifo, 128, uint8, uint8);

然后，在UART模块的头文件里导出该FIFO的API：
    EXPORT_FIFO_API(UART_RxFifo, 128, uint8, uint8);

接下来，我们可以通过以下两种方法访问这个队列
    // 加一个数据Data到UART_RxFifo
    1. FIFO_PUT_ONE(UART_RxFifo, Data);
    2. FIFO_UART_RxFifo_PutOne(Data);

    // 从ptrData处取出Num个数据，放入UART_RxFifo：
    1. FIFO_PUT_STR(UART_RxFifo, ptrData, Num);
    2. FIFO_UART_RxFifo_PutStr(ptrData, Num);

    // 从UART_RxFifo取出一个数据放到ptrData
    1. FIFO_GET_ONE(UART_RxFifo, ptrData);
    2. FIFO_UART_RxFifo_GetOne(ptrData);

    // 从UART_RxFifo取出Num个数据放到ptrData
    1. FIFO_GET_STR(UART_RxFifo, ptrData, Num);
    2. FIFO_UART_RxFifo_GetStr(ptrData, Num);

    // 偷看一眼UART_RxFifo里面index处的数据，将结果保存到ptrData
    1. FIFO_PEEK_ONE(UART_RxFifo, ptrData, index);
    2. FIFO_UART_RxFifo_PeekOne(ptrData);

    // 倒掉一些(Num个)不用的数据
    1. FIFO_DUMP_DATA(UART_RxFifo, Num);
    2. FIFO_UART_RxFifo_DumpData(Num);

    // 获取UART_RxFifo的当前数据量
    1. FIFO_GET_COUNT(UART_RxFifo);
    2. FIFO_UART_RxFifo_GetCount();

    // 检测UART_RxFifo是否为空
    1. FIFO_IS_EMPTY(UART_RxFifo);
    2. FIFO_UART_RxFifo_IsEmpty();

    // 将一个以'\0'结尾的字符串添加到UART_RxFifo
    1. FIFO_PUTS(UART_RxFifo, "Hello World!");

如果是在中断函数里面访问FIFO，应使用如下专门函数：
    FIFO_UART_RxFifo_PutOneInt(Data);
    FIFO_UART_RxFifo_GetOneInt(ptrData);

NOTES:
    头文件包含策略：推荐将本文件(fifo.h)包含在模块的头文件中，
    这样，其他模块需要访问该fifo时，只需包含该模块的头文件即可。
    如上例中：
    A. #include "fifo.h"    // 在uart.h里面包含fifo.h
    B. #include "uart.h"    // 在需要访问UART_RxFifo的模块中包含uart.h

********************************************************** */
        //\
        //Bool FIFO_##__NAME##_PeekOne(__TYPE *pData, __SIZE_t Index)\
        //{\
        //  if (Index < FIFO_##__NAME##_GetCount())\
        //  {\
        //      if ((FIFO_##__NAME##Tail + Index) >= (FIFO_##__NAME##Buffer + __SIZE))\
        //          *pData = *(FIFO_##__NAME##Tail + Index - __SIZE);\
        //      else \
        //          *pData = *(FIFO_##__NAME##Tail + Index);\
        //      return TRUE;\
        //  }\
        //  return FALSE;\
        //}\

        /* Dump some data of FIFO */\
        //void FIFO_##__NAME##_DumpData(__SIZE_t Num)\
        //{\
        //  _DI();\
        //  if (Num < FIFO_##__NAME##_GetCount())\
        //  {\
        //      FIFO_##__NAME##Tail += Num;\
        //      if (FIFO_##__NAME##Tail >= FIFO_##__NAME##Buffer + __SIZE) {\
        //          FIFO_##__NAME##Tail -= __SIZE;\
        //      }\
        //  }\
        //  else \
        //  {\
        //      FIFO_##__NAME##Head = FIFO_##__NAME##Buffer;\
        //      FIFO_##__NAME##Tail = FIFO_##__NAME##Buffer;\
        //  }\
        //  _EI();\
        //}\


/* -----------------------------------------------------------------------------
   NAME: NEW_FIFO
   FUNCTION: Create a new FIFO
   INPUTS:
        __NAME: FIFO Name;
        __SIZE: FIFO Size;
        __TYPE: The data type of FIFO data member;
        __SIZE_t: The data type of FIFO size.
   OUTPUT:
        Methods for FIFO_PUT_ONE, FIFO_GET_ONE, FIFO_PEEK_ONE, FIFO_DUMP_DATA,
        FIFO_PUT_STR, FIFO_GET_STR, FIFO_PUTS, FIFO_GET_COUNT and FIFO_IS_EMPTY.
----------------------------------------------------------------------------- */
//#define NULL  0


#define NEW_FIFO(__NAME,__SIZE,__TYPE,__SIZE_t) \
        __TYPE   FIFO_##__NAME##Buffer[(__SIZE)];\
        __TYPE  *FIFO_##__NAME##Tail = FIFO_##__NAME##Buffer;\
        __TYPE  *FIFO_##__NAME##Head = FIFO_##__NAME##Buffer;\
        \
        /* Get the current data count of FIFO outside ISR. */\
        __SIZE_t FIFO_##__NAME##_GetCount(void)\
        {\
            __SIZE_t temp;\
            _DI();\
            if (FIFO_##__NAME##Head >= FIFO_##__NAME##Tail)\
                temp = FIFO_##__NAME##Head - FIFO_##__NAME##Tail;\
            else \
                temp = FIFO_##__NAME##Head + __SIZE - FIFO_##__NAME##Tail;\
            _EI();\
            return temp;\
        }\
        \
        /* Get the current Idel room count of FIFO outside ISR. */\
        __SIZE_t FIFO_##__NAME##_GetIdelCount(void)\
        {\
            __SIZE_t temp;\
            _DI();\
            if (FIFO_##__NAME##Head >= FIFO_##__NAME##Tail)\
                temp = ((__SIZE - 1) -(FIFO_##__NAME##Head - FIFO_##__NAME##Tail));\
            else \
                temp = (FIFO_##__NAME##Tail - 1 - FIFO_##__NAME##Head);\
            _EI();\
            return temp;\
        }\
        \
        /* Put one data in FIFO outside ISR. */\
        BOOL FIFO_##__NAME##_PutOne(__TYPE Data)\
        {\
            __SIZE_t DataCount;\
            _DI();\
            if (FIFO_##__NAME##Head >= FIFO_##__NAME##Tail)\
                DataCount = FIFO_##__NAME##Head - FIFO_##__NAME##Tail;\
            else \
                DataCount =__SIZE  +  FIFO_##__NAME##Head - FIFO_##__NAME##Tail;\
            _EI();\
            if (DataCount < (__SIZE - 1))\
            {\
                _DI();\
                *FIFO_##__NAME##Head = Data;\
                /* "*FIFO_##__NAME##Head = Data;"需要在关中断下进行,字符型的操作可能引起错误 */\
                if (FIFO_##__NAME##Head == FIFO_##__NAME##Buffer + (__SIZE - 1))\
                    FIFO_##__NAME##Head = FIFO_##__NAME##Buffer;\
                else \
                    FIFO_##__NAME##Head++;\
                _EI();\
                return TRUE;\
            }\
            return FALSE;\
        }\
        \
        /* Get one data from FIFO outside ISR. */\
        BOOL FIFO_##__NAME##_GetOne(__TYPE *pData)\
        {\
            _DI();\
            if (FIFO_##__NAME##Tail != FIFO_##__NAME##Head)\
            {\
                *pData = *FIFO_##__NAME##Tail;\
                if (FIFO_##__NAME##Tail == FIFO_##__NAME##Buffer + (__SIZE - 1))\
                    FIFO_##__NAME##Tail = FIFO_##__NAME##Buffer;\
                else \
                    FIFO_##__NAME##Tail++;\
                _EI();\
                return TRUE;\
            }\
            _EI();\
            return FALSE;\
        }\
        /* take a look the data with Index*/\
        BOOL FIFO_##__NAME##_PeekOne(__TYPE *pData, __SIZE_t Index)\
        {\
            if (Index < FIFO_##__NAME##_GetCount())\
            {\
                if ((FIFO_##__NAME##Tail + Index) >= (FIFO_##__NAME##Buffer + __SIZE))\
                    *pData = *(FIFO_##__NAME##Tail + Index - __SIZE);\
                else \
                    *pData = *(FIFO_##__NAME##Tail + Index);\
                return TRUE;\
            }\
            return FALSE;\
        }\
        /* Dump some data of FIFO */\
        void FIFO_##__NAME##_DumpData(__SIZE_t Num)\
        {\
            _DI();\
            if (Num < FIFO_##__NAME##_GetCount())\
            {\
                FIFO_##__NAME##Tail += Num;\
                if (FIFO_##__NAME##Tail >= FIFO_##__NAME##Buffer + __SIZE) {\
                    FIFO_##__NAME##Tail -= __SIZE;\
                }\
            }\
            else \
            {\
                FIFO_##__NAME##Head = FIFO_##__NAME##Buffer;\
                FIFO_##__NAME##Tail = FIFO_##__NAME##Buffer;\
            }\
            _EI();\
        }\
        /* Put a string of data in FIFO */\
        BOOL FIFO_##__NAME##_PutStr(__TYPE *pData, __SIZE_t Num)\
        {\
            if ((Num > FIFO_##__NAME##_GetIdelCount()) || (pData == NULL))\
                return FALSE;\
            while(Num--)\
            {\
                _DI();\
                *FIFO_##__NAME##Head = *pData;\
                if (FIFO_##__NAME##Head == FIFO_##__NAME##Buffer + (__SIZE - 1))\
                    FIFO_##__NAME##Head = FIFO_##__NAME##Buffer;\
                else \
                    FIFO_##__NAME##Head++;\
                pData++;\
                _EI();\
            }\
            return TRUE;\
        }\
        BOOL FIFO_##__NAME##_GetStr(__TYPE *pData, __SIZE_t Num)\
        {\
            if ((Num > FIFO_##__NAME##_GetCount()) || (pData == NULL))\
                return FALSE;\
            while(Num--)\
            {\
                *pData = *FIFO_##__NAME##Tail;\
                _DI();\
                if (FIFO_##__NAME##Tail == FIFO_##__NAME##Buffer + (__SIZE - 1))\
                    FIFO_##__NAME##Tail = FIFO_##__NAME##Buffer;\
                else \
                    FIFO_##__NAME##Tail++;\
                pData++;\
                _EI();\
            }\
            return TRUE;\
        }\
        BOOL FIFO_##__NAME##_IsEmpty(void)\
        {\
            if (FIFO_##__NAME##Tail == FIFO_##__NAME##Head) return TRUE;\
            else return FALSE;\
        } \
        extern /*__inline*/ void FIFO_##__NAME##_PutOneInt(__TYPE Data)\
        {\
            if ((FIFO_##__NAME##Head+1) !=  FIFO_##__NAME##Tail) {\
                if (((FIFO_##__NAME##Head+1)- __SIZE) !=  FIFO_##__NAME##Tail) {\
                    *FIFO_##__NAME##Head = Data;\
                    if (FIFO_##__NAME##Head == FIFO_##__NAME##Buffer + (__SIZE - 1))\
                        FIFO_##__NAME##Head = FIFO_##__NAME##Buffer;\
                    else \
                        FIFO_##__NAME##Head++;\
                }\
            }\
        }\
        extern /*__inline*/ BOOL FIFO_##__NAME##_GetOneInt(__TYPE *pData)\
        {\
            if (FIFO_##__NAME##Tail == FIFO_##__NAME##Head) return FALSE;\
            *pData = *FIFO_##__NAME##Tail; \
            if (FIFO_##__NAME##Tail == FIFO_##__NAME##Buffer + (__SIZE - 1)) {\
                FIFO_##__NAME##Tail = FIFO_##__NAME##Buffer;\
            }\
            else {\
                FIFO_##__NAME##Tail++;\
            }\
            return TRUE;\
        }\



#define EXPORT_FIFO_API(__NAME,__SIZE,__TYPE,__SIZE_t)  \
        extern __TYPE   FIFO_##__NAME##Buffer[(__SIZE)];\
        extern __TYPE  *FIFO_##__NAME##Tail;\
        extern __TYPE  *FIFO_##__NAME##Head;\
        extern BOOL FIFO_##__NAME##_PutOne(__TYPE Data);\
        extern BOOL FIFO_##__NAME##_GetOne(__TYPE *pData);\
        extern BOOL FIFO_##__NAME##_PeekOne(__TYPE *pData, __SIZE_t Index);\
        extern void FIFO_##__NAME##_DumpData(__SIZE_t Num);\
        extern BOOL FIFO_##__NAME##_PutStr(__TYPE *pData, __SIZE_t Num);\
        extern BOOL FIFO_##__NAME##_GetStr(__TYPE *pData, __SIZE_t Num);\
        extern BOOL FIFO_##__NAME##_IsEmpty(void);\
        extern __SIZE_t FIFO_##__NAME##_GetCount(void);\
        extern __SIZE_t FIFO_##__NAME##_GetIdelCount(void);\
        extern /*__inline */void FIFO_##__NAME##_PutOneInt(__TYPE Data);\
        /*{\
            if ((FIFO_##__NAME##Head+1) !=  FIFO_##__NAME##Tail) {\
                if (((FIFO_##__NAME##Head+1)- __SIZE) !=  FIFO_##__NAME##Tail) {\
                    *FIFO_##__NAME##Head = Data;\
                    if (FIFO_##__NAME##Head == FIFO_##__NAME##Buffer + (__SIZE - 1))\
                        FIFO_##__NAME##Head = FIFO_##__NAME##Buffer;\
                    else \
                        FIFO_##__NAME##Head++;\
                }\
            }\
        }*/\
        extern /*__inline*/ BOOL FIFO_##__NAME##_GetOneInt(__TYPE *pData);\
        /*{\
            if (FIFO_##__NAME##Tail == FIFO_##__NAME##Head) return FALSE;\
            *pData = *FIFO_##__NAME##Tail; \
            if (FIFO_##__NAME##Tail == FIFO_##__NAME##Buffer + (__SIZE - 1)) {\
                FIFO_##__NAME##Tail = FIFO_##__NAME##Buffer;\
            }\
            else {\
                FIFO_##__NAME##Tail++;\
            }\
            return TRUE;\
        }*/\


#define FIFO_INIT(__NAME)    _DI();FIFO_##__NAME##Tail = FIFO_##__NAME##Buffer;\
                             FIFO_##__NAME##Head = FIFO_##__NAME##Buffer;_EI();

#define FIFO_PUT_ONE_INT(__NAME,__DATA)      FIFO_##__NAME##_PutOneInt(__DATA)
#define FIFO_GET_ONE_INT(__NAME,__ADDR)      FIFO_##__NAME##_GetOneInt(__ADDR)
#define FIFO_PUT_ONE(__NAME,__DATA)          FIFO_##__NAME##_PutOne(__DATA)
#define FIFO_GET_ONE(__NAME,__ADDR)          FIFO_##__NAME##_GetOne(__ADDR)
#define FIFO_PEEK_ONE(__NAME,__ADDR,__IDX)   FIFO_##__NAME##_PeekOne(__ADDR,__IDX)
#define FIFO_DUMP_DATA(__NAME,__NUM)         FIFO_##__NAME##_DumpData(__NUM)
#define FIFO_GET_COUNT(__NAME)               FIFO_##__NAME##_GetCount()
#define FIFO_GET_IDEL_COUNT(__NAME)          FIFO_##__NAME##_GetIdelCount()
#define FIFO_IS_EMPTY(__NAME)                FIFO_##__NAME##_IsEmpty()
#define FIFO_PUT_STR(__NAME,__ADDR,__NUM)    FIFO_##__NAME##_PutStr(__ADDR,__NUM)
#define FIFO_GET_STR(__NAME,__ADDR,__NUM)    FIFO_##__NAME##_GetStr(__ADDR,__NUM)
#define FIFO_PUTS(__NAME,__ADDR)             FIFO_##__NAME##_PutStr(__ADDR,sizeof(__ADDR))

#endif

在h文件中添加添加输出EXPORT_FIFO_API（）：
EXPORT_FIFO_API(printf_can1_fifo, CAN_RX_FIFO_SIZE,CanRxMsg , u8);
EXPORT_FIFO_API(printf_can2_fifo, CAN_RX_FIFO_SIZE,CanRxMsg , u8);
在C文件中创建FIFO，NEW_FIFO（）：
NEW_FIFO(printf_can1_fifo, CAN_RX_FIFO_SIZE,CanRxMsg , u8);
NEW_FIFO(printf_can2_fifo, CAN_RX_FIFO_SIZE,CanRxMsg , u8);
通过FIFO_PUT_ONE（）把消息RxMessage放入缓冲printf_can1_fifo：
FIFO_PUT_ONE(printf_can1_fifo, RxMessage);
FIFO_PUT_ONE(printf_can2_fifo, RxMessage);

通过FIFO_GET_ONE（）从缓存区printf_can1_fifo把数据放入Get_CanRxMsg变量：
CanRxMsg Get_CanRxMsg;
FIFO_GET_ONE(printf_can1_fifo, &Get_CanRxMsg)
FIFO_GET_ONE(printf_can2_fifo, &Get_CanRxMsg)

从缓存区拿出can数据并打印处理：
void Printf_Can_RxMessage()
    {
    CanRxMsg Get_CanRxMsg;
    Byte nData=0;

    if(FIFO_GET_ONE(printf_can1_fifo, &Get_CanRxMsg))
    {
        //printf("\r\nIDE: 0X%02x",Get_CanRxMsg.IDE);
        if(!Get_CanRxMsg.IDE)
        printf("\r\nCAN1_STD:0X%04X",Get_CanRxMsg.StdId);
        else
        printf("\r\nCAN1_EXT:0X%08X",Get_CanRxMsg.ExtId);

        printf("  DLC:%02X  Data:" ,Get_CanRxMsg.DLC);

        nData=0;
        while(nData<Get_CanRxMsg.DLC)
            {
            printf(" 0X%02X",Get_CanRxMsg.Data[nData]);
            nData++;
            }   
        printf("\r\n");

    }

    if(FIFO_GET_ONE(printf_can2_fifo, &Get_CanRxMsg))
        {
            //printf("\r\nIDE: 0X%02x",Get_CanRxMsg.IDE);
            if(!Get_CanRxMsg.IDE)
            printf("\r\nCAN2_STD:0X%04X",Get_CanRxMsg.StdId);
            else
            printf("\r\nCAN2_EXT:0X%08X",Get_CanRxMsg.ExtId);

            printf("  DLC:%02X  Data:" ,Get_CanRxMsg.DLC);
            nData=0;
            while(nData<Get_CanRxMsg.DLC)
                {
                printf(" 0X%02X",Get_CanRxMsg.Data[nData]);
                nData++;
                }   
        printf("\r\n");

        }


   }

CAN发送的数据打印处理：

void Printf_Can_TxMessage(CanTxMsg CanTxMessage,CAN_TypeDef * CAN)
{
    CanTxMsg Get_CanTxMSG=CanTxMessage;
    Byte nData=0;
    CAN_TypeDef * CAN_Stype=CAN;
    if(CAN_Stype==CAN1){
    if(!Get_CanTxMSG.IDE)
    printf("\r\nCAN1Send_STD:0X%04X",Get_CanTxMSG.StdId);
    else
    printf("\r\nCAN1Send_EXT:0X%08X",Get_CanTxMSG.ExtId);

    printf("  DLC:%02X  Data:" ,Get_CanTxMSG.DLC);
    nData=0;
    while(nData<Get_CanTxMSG.DLC)
        {
        printf(" 0X%02X",Get_CanTxMSG.Data[nData]);
        nData++;
        }   
    printf("\r\n");
        }
    if(CAN_Stype==CAN2){
    if(!Get_CanTxMSG.IDE)
    printf("\r\nCAN2Send_STD:0X%04X",Get_CanTxMSG.StdId);
    else
    printf("\r\nCAN2Send_EXT:0X%08X",Get_CanTxMSG.ExtId);

    printf("  DLC:%02X  Data:" ,Get_CanTxMSG.DLC);
    nData=0;
    while(nData<Get_CanTxMSG.DLC)
        {
        printf(" 0X%02X",Get_CanTxMSG.Data[nData]);
        nData++;
        }   
    printf("\r\n");
        }

}
Leo-Lian
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现FIFO环形存储器
01-06
前言 在CSDN社区看了很多FIFO的C语言实现，发现大多写的很复杂，看不懂。FIFO机制在嵌入式开发中串口数据收发处理相当方便，因此决定分享一下C语言的实现方法。代码很简单，就两个函数:fifo_put和fifo_get,可以结合串口直接进行调用，在项目中使用过。 FIFO环形存储器读写说明 为了解释方便，定义几个变量fifo.in：写入地址指针，fifo.out：读取地址指针，fifo.count已经存储数量，fifo.size：存储器总容量，fifo.buffer：存储器存储内容空间。以下以10个字节大小的空间说明对环形存储器的读写机制。 1.初始化时存储器状态如下： 2.写入5个字节
FIFO环形队列.rar
10-14
具体到这个"FIFO环形队列.rar"压缩包，它可能包含以下内容：关于FIFO环形队列的理论介绍、STM32串口配置示例、环形队列的C语言实现代码、以及可能的测试用例和说明文档。通过学习这些内容，开发者可以了解如何在实际...
STM32上使用的环形FIFO队列，用于缓存待发送数据
热门推荐
与其用泪水悔恨昨天，不如用汗水拼搏今天
04-04 1万+
C语言实现的环形FIFO队列，用于线程异步通信，数据发送非常方便，比如GPRS发送数据，一个线程将数据写入到FIFO，发送线程不停的从FIFO中读取数据，然后发送，又比如上位机中，数据接收线程不停的接收数据，写入到FIFO，另一个异步的处理线程不停的读取数据，进行处理。/****************************************************************...
S32K144/142CAN通信配置（接收和发送）
最新发布
weixin_42996583的博客
06-08 516
Process_receiving_logic：函数如下//收到什么数据发送什么数据，官方S32KDS中的FlexCAN组件,发送CAN消息和接收过滤后的CAN信息。6.回调函数编写 //当MCU收到发来的数据后会自动进入回调函数。开发环境：S32 Design Studio for。，请参照如下链接 （另一位大神写的很详细）4. 在代码中加入CAN初始化的代码即可。1.添加flexcan组件。2.配置CAN相关参数。也可以根据自己需求更改。如对过滤部分不是很了解。3.配置好后点击生成。
环形队列FIFO实现方法
DanielLee_ustb的专栏
01-06 7577
有的单片机串口没有FIFO，或者可分配的FIFO大小是非常有限的，如果在程序中需要向外设发送一个很大的数据包，需要很长的时间，为了解决应用程序与外设硬件读写同步的问题，很有必要自己实现环形FIFO。 #include "stdafx.h" #include #include using namespace std; #define  ERROR_FULL_W  -1 #define
九九乘法表
qq_40406144的博客
09-27 231
package zhang; public class ke{ public static void main(String[] args) { // TODO 自动生成的方法存根 int a,b; //定义数据类型 for(a=1;a<=9;a++){ //
FIFO队列二（静态环形队列实现）
hewenhu1989的博客
05-05 581
系列文章目录 FIFO队列一（原理） FIFO队列二（静态环形队列实现） 文章目录前言一、初始化队列二、队列是否为空三、队列 入队四、队列 出队五、队列是否为满六、测试 前言 硬件：百问网100ASK_STM32F103_MINI开发板（STM32F103C8T6） IDE：KEIL 5 按键GPIO口为：PA0 串口为：PA10（USART1_RX）、PA9（USART1_TX） 原理图如下： 提示：以下是本篇文章正文内容，下面案例可供参考 一、初始化队列 初始化就是Read = Write =0
windows环形队列.zip
01-18
环形队列是一种数据结构，它在内存中表现为一个固定大小的数组，具有首尾相接的特点，类似于一个圆环。在Windows环境下，环形队列可以被广泛应用于多线程编程，例如作为消息传递机制或者缓冲区。下面将详细阐述环形...
C#环形队列的实现方法详解
09-01
1. 先进先出（FIFO）原则：如同所有队列一样，环形队列也遵循这一基本原则，确保最早放入队列的元素最早被取出。 2. 空间复用：由于环形队列的循环特性，一旦元素出队，其占用的空间可以立即被新元素复用，减少了...
基于stm32f407的串口环形队列及DMA收发中断数据处理
03-27
在本文中，我们将深入探讨如何在STM32F407微控制器上实现串口通信的环形队列和DMA（直接存储器访问）收发中断数据处理。STM32F407是一款基于ARM Cortex-M4内核的高性能单片机，广泛应用于嵌入式硬件设计。 首先，...
STM32串口环形队列,stm32串口程序,C,C++
09-10
总的来说，STM32串口的环形队列结合FIFO和DMA技术，能有效地处理高频率、大数据量的串口通信，提高系统的实时性和可靠性。开发者可以通过阅读提供的PDF文档和相关资料，深入了解STM32串口队列的实现细节，并在实践中...
STM32进阶之串口环形缓冲区实现 FIFO
01-26
STM32进阶之串口环形缓冲区实现 FIFO，代码精简，易实现。
软件环形FIFO数据存储
06-20
通过软件方式实现环形fifo数据存储机构，可通过链表修改存储空间大小，避免数组存储方式，效率比较高，也可以通过数组存储，需要稍作修改。多年的实践应用，稳定可靠。
FIFO环形存储器C实现.rar
04-16
C语言实现FIFO功能，代码里面有FIFO读取和写入函数，可以在不同的开发平台下方便的移植，函数简单有效，已经用于实际开发项目中，针对串口收发使用非常方便。
stm32环形队列
06-17
stm32环形队列
FIFO实现任意大小队列FIFO
02-22
采用C程序实现任意大小的FIFO
DPDK（二）：准备知识4 --- 无锁FIFO环形队列
weixin_30274627的博客
03-16 748
原文：https://www.linuxidc.com/Linux/2016-12/137936.htm一、简介1、环形队列是一种特殊的队列结构，保证了元素也是先进先出的，但与一般队列的区别是，他们是环形的，即队列头部的上个元素是队列尾部，通常是容纳元素数固定的一个闭环。采用环形缓冲区的好处为，当一个数据元素被用掉后，其余数据元素不需要移动其存储位置，从而减少拷贝提高效率2、优点：保证元...
精简通用环形fifo
nianhene的专栏
10-17 848
精简通用环形fifo http://www.amobbs.com/thread-5515836-1-1.html
循环队列FIFO
退5不落5
07-04 567
1.概念 为充分利用向量空间，克服顺序存储结构的"假溢出"现象的方法是：将向量空间想象为一个首尾相接的圆环，并称这种向量为循环向量。存储在其中的队列称为循环队列（Circular Queue）。这种循环队列可以以单链表的方式来在实际编程应用中来实现。 循环队列中，由于入队时尾指针向前追赶头指针；出队时头指针向前追赶尾指针，造成队空和队满时头尾指针均相等。因此，无法通过条件front==rear来判别队列是"空"还是"满"。使用求余运算可以判断队列是否已满。 2.代码 //circular Queue 循环
c++ stl 环形队列 类库
07-18
C语言中提供了STL（标准模板库）的环形队列类库，称为"queue"。STL提供了一个通用的、可重用的环形队列实现，可以使用该类库来处理各种类型的数据。 该环形队列类库提供了以下功能： 1. 入队和出队操作：可以使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值