队列-数组队列实现-DTU缓冲区原型.c

最新推荐文章于 2020-08-17 22:00:44 发布
最新推荐文章于 2020-08-17 22:00:44 发布
阅读量3.4k 收藏
点赞数 1
分类专栏： ABC 文章标签： c 数据结构 数组队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zeroboundary/article/details/9295979
版权 
// 缓冲区-数组队列实现 可在VC6.0下编译通过

// 使用MTK平台做DTU产品的时候，需要将串口的数据缓存到内存，然后通过网络发送数据，
// 所以要记录下来本次存入数据长度和数据内容，以便下次发往网络时可将本次存入数据整段发送出去
// 另外，MTK中，动态分配内存效率较整体分配内存稳定性差，采用数组队列形式实现
// 功能，向缓冲区读写数据

// 对外接口 dtu_buffer_get_data / dtu_buffer_add_data
// 本程序实现记录本次存入数据多少，下次取出来时，会取出相同数量数据
// 最多容纳数据数量份数为MAX_L_SIZE，最多容纳数据总和为MAX_SIZE
#include <stdio.h>
#include <memory.h>

#include <stdlib.h>
#include <time.h>

#define MAX_SIZE 1024                       // 缓冲区最大容纳数据总和

struct arrQueue                             // 声明队列的头和尾节点，数据存储元素
{
    unsigned char       data[MAX_SIZE+1];   // 定义数组队列元素，能容纳MAX_SIZE字节
    unsigned int        front;              // 含有数据的第一个下标
    unsigned int        rear;               // 含有数据的最后一个元素下标，rear所在的元素不存数据
}queue;

void initQueue()
{
    memset(queue.data, '\0', sizeof(queue.data));
    queue.front = 0;
    queue.rear  = 0;
}


void enQueue(unsigned char *pElement, unsigned int *len)//向queue中存入长度为len字节数据，len返回长度实际存入的长度
{
    // 如果rear在front前面一位，则表明缓冲区已经满，无法存入数据
    // 当rear在最后一位，front在最前一位，也是没有空间
    if ((queue.rear+1)%(MAX_SIZE+1) == queue.front)
    {
        *len = 0;
        return;
    }

    // 如果rear在front前面一位以上，则rear与front之间就是空闲区域，长度为front-rear-1
    if (queue.rear+1<queue.front)
    {
        // 存入数据位len与剩余空间较小者
        *len = *len <= (queue.front-queue.rear-1) ? *len : queue.front-queue.rear-1;
        
        memcpy(&queue.data[queue.rear], pElement, *len);
        queue.rear += *len;
    }
    else    // 如果 rear在front后面，或者相等时，并且有空间
    {
        // 剩余空间大小为 MAX_SIZE-(rear-front), 可写入的数据位长度与剩余空间较小者
        *len = *len <= (MAX_SIZE-(queue.rear-queue.front)) ? *len : MAX_SIZE-(queue.rear-queue.front);
        // 如果front为0，则rear就在小于等于MAX_SIZE的位置，只需要队列尾部保存数据
        if (queue.front==0)
        {
            memcpy(&queue.data[queue.rear], pElement, *len);
            queue.rear += *len;
        }
        else // 如果front不为0，则 队列尾保存了数据，队列头部有可能需要保存数据
        {
            // 如果尾部可以保存数据，则直接保存数据
            if ((MAX_SIZE+1-queue.rear) >= *len)
            {
                memcpy(&queue.data[queue.rear], pElement, *len);
                queue.rear = (queue.rear + *len)%(MAX_SIZE+1);
            }
            else // 如果尾部保存不了数据，头部还需要保存数据，尾部保存的数据长度为：MAX_SIZE+1-queue.rear
            {
                memcpy(&queue.data[queue.rear], pElement, MAX_SIZE+1-queue.rear);
                queue.rear = *len-(MAX_SIZE+1-queue.rear);
                memcpy(&queue.data[0], pElement+(*len-queue.rear), queue.rear);
            }
        }
    }
}

void deQueue(unsigned char *pElement, unsigned int *len)//向queue中取出长度为len字节数据，len返回长度实际取出的长度
{
    // 如果为空数据
    if ((*len==0) || (queue.rear==queue.front))
    {
        *len = 0;
        return;
    }

    // 如果 rear在front后面，则直接取出数据
    if (queue.rear > queue.front)
    {
        *len = *len <= (queue.rear-queue.front) ? *len : (queue.rear-queue.front);
        memcpy(pElement, &queue.data[queue.front], *len);
        queue.front += *len;
    }
    else    // 如果rear在front前面
    {
        // 队列中数据长度为 rear+(MAX_SIZE+1-front)
        *len = *len <= queue.rear+(MAX_SIZE+1-queue.front) ? *len : queue.rear+(MAX_SIZE+1-queue.front);
        
        // 如果尾部可以取出*len的数据则直接取，尾部数据大小为MAX_SIZE+1-queue.front
        if (*len <= MAX_SIZE+1-queue.front)
        {
            memcpy(pElement, &queue.data[queue.front], *len);
            queue.front = (queue.front + *len) % (MAX_SIZE+1);
        }
        else    // 如果尾部取完，还需要取数据，则取头部数据
        {
            memcpy(pElement, &queue.data[queue.front], (MAX_SIZE+1-queue.front));
            queue.front = *len-(MAX_SIZE+1-queue.front);
            memcpy(&pElement[*len-queue.front], &queue.data[0], queue.front);
        }
    }
}

unsigned int lenQueue()     // 队列存了多少数据
{
    return (queue.rear+MAX_SIZE+1-queue.front)%(MAX_SIZE+1);
}


/长度数组队列///
#define MAX_L_SIZE      128   // 最多存入数据份数，一次存入数据位一份数据
struct LQueue
{
    unsigned int data[MAX_L_SIZE];
    unsigned int front;
    unsigned int rear;
}lqueue;

void initLQueue()
{
    memset(lqueue.data, '\0', sizeof(lqueue.data));
    lqueue.front = 0;
    lqueue.rear = 0;
}

void enLQueue(unsigned int *len)    // 插入长度len, len不能为0，插入正确len不改变，插入错误len为0
{
    if ((lqueue.rear+1)%MAX_L_SIZE == lqueue.front)     // 队列已满
    {
        *len = 0;
    }
    else
    {
        lqueue.data[lqueue.rear] = *len;
        lqueue.rear = (lqueue.rear+1)%MAX_L_SIZE;
    }

}

void deLQueue(unsigned int *len)    // 返回一个长度len数值，len为0则队列为空
{
    if (lqueue.rear == lqueue.front)    // 队列为空
    {
        *len = 0;
    }
    else
    {
        *len = lqueue.data[lqueue.front];
        lqueue.data[lqueue.front] = 0;  // 还原数据为0
        lqueue.front = (lqueue.front+1)%MAX_L_SIZE;
    }
}

unsigned int lenLQueue()            // 获取队列存入多少len数值
{
    return (lqueue.rear+MAX_L_SIZE-lqueue.front)%MAX_L_SIZE;
}
/长度队列///



// 缓冲区对外两个接口函数
//
// 写入数据到缓冲区，若缓冲区存不下需要放入的数据，则删除前面存入的数据
unsigned char dtu_buffer_add_data(const unsigned char *pbuf, unsigned int len)
{
    unsigned int len_t = 0;
    unsigned char pbuf_t[128] = {0x0, };
    if ((pbuf==NULL) || (len==0))
    {
        return 0;
    }
    
    while (MAX_SIZE-lenQueue() < len)   // 如果缓冲区满了，则删除以前的的数据
    {
        deLQueue(&len_t);
        deQueue((unsigned char*)pbuf_t, &len_t);
        printf("【%d-%s】\r\n", len_t, pbuf_t);
    }
    if (MAX_L_SIZE==lenLQueue()+1)      // 如果长度队列满了，则删除一个长度队列
    {
        deLQueue(&len_t);
        deQueue((unsigned char*)pbuf_t, &len_t);
        printf("【%d-%s】\r\n", len_t, pbuf_t);
    }

    enLQueue(&len);
    enQueue((unsigned char*)pbuf, &len);

    return 1;
}

// 从缓冲区获取内容
unsigned char dtu_buffer_get_data(unsigned char* pbuf, unsigned int* len)
{
    unsigned char result = 0;
    if (pbuf==NULL)
        return result;

    deLQueue((unsigned int*)len);
    deQueue((unsigned char*)pbuf, (unsigned int*)len);
    if (*len)
        result = 1;

    return result;
}

/

void main()
{
    int i = 0;
    int len = 1;
    char buf[32];
    initQueue();

    // 测试1，正常情况
    queue.front = 0;
    queue.rear  = 0;
    // 测试2，front在前，rear在后
    //queue.front   = 5;
    //queue.rear    = 7;
    // 测试3，front在后，rear在前
    //queue.front   = 26;
    //queue.rear    = 8;

    // 测试四个存入

    printf("begin==========\r\n");
    for (i=0, len=1; len; i++)
    {
        len = 4;
        buf[0] = 'A'+4*i;
        buf[1] = 'A'+4*i+1;
        buf[2] = 'A'+4*i+2;
        buf[3] = 'A'+4*i+3;
        printf("%d-", lenQueue());
        enQueue(buf, &len);
        printf("%d ", len);
    }
    printf("\r\n");
    for (i=0; i<MAX_SIZE+1; i++)
    {
        printf("%c ", queue.data[i]);
    }
    printf("\r\n");
    // 测试四个存入 end

    // 测试四个取出
    for (i=0, len=1; len; i++)
    {
        len = 4;
        printf("%d-", lenQueue());
        deQueue(buf, &len);
        buf[len] = '\0';
        printf("%d-%s\r\n", len, buf);
    }
    printf("end============\r\n");
    // 测试四个取出 end


    // 采用随机数测试//
{
    int value_f;
    int value_r;
    srand(time(0));
    value_f = rand() % (MAX_SIZE+1);
    value_r = rand() % (MAX_SIZE+1);
    initQueue();
    queue.front = value_f;
    queue.rear  = value_r;
    printf("\r\nbegin========== %d %d\r\n", value_f, value_r);

    for (i=0, len=1; len; i++)
    {
        len = 4;
        buf[0] = 'A'+4*i;
        buf[1] = 'A'+4*i+1;
        buf[2] = 'A'+4*i+2;
        buf[3] = 'A'+4*i+3;
        printf("%d-", lenQueue());
        enQueue(buf, &len);
        printf("%d ", len);
    }
    printf("\r\n");
    for (i=0; i<MAX_SIZE+1; i++)
    {
        printf("%c ", queue.data[i]);
    }
    printf("\r\n");

    for (i=0, len=1; len; i++)
    {
        len = 4;
        printf("%d-", lenQueue());
        deQueue(buf, &len);
        buf[len] = '\0';
        printf("%d-%s\r\n", len, buf);
    }
    printf("\r\nend============\r\n");
}
    // 采用随机数测试 end//


    测试lqueue
    initLQueue();
    lqueue.front    = 0;
    lqueue.rear     = 0;

    // 测试存入
    printf("\r\nlqueue begin==========\r\n");
    for (i=0, len=i+1; len; i++)
    {
        len = i+1;
        enLQueue(&len);
        printf("%d-%d ", lenLQueue(), len);

        if (!((i+1)%3))     // 测试取出一部分数据
        {
            deLQueue(&len);
            printf("de-%d ", len);
        }
    }
    printf("\r\n");
    for (i=0; i<MAX_L_SIZE; i++)
    {
        printf("%d ", lqueue.data[i]);
    }
    printf("\r\n");

    // 测试取出/
    for (len = 1; len; )
    {
        printf("%d-", lenLQueue());
        deLQueue(&len);
        printf("%d ", len);
    }
    printf("\r\n");
    for (i=0; i<MAX_L_SIZE; i++)
    {
        printf("%d ", lqueue.data[i]);
    }
    printf("\r\nlqueue end============\r\n");
    // 测试end
    测试lqueue

    // 测试 dtu_buffer_add_data / dtu_buffer_get_data
    测试 begin
    printf("add begin============\r\n");
    len = 4;
    i = 0;
    while (i!=10)
    {
        sprintf(buf, "abc%d", i);
        dtu_buffer_add_data(buf, len);
        i++;
    }
    printf("add end=============\r\n");
    printf("get begin============\r\n");
    while (dtu_buffer_get_data(buf, &len) )
    {
        printf("%d-%s\r\n", len, buf);
    }
    printf("get end=============\r\n");
    // 测试end
    测试 end//
}
zeroboundary
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构与算法之队列与嵌入式软件的应用
weixin_38289027的博客
08-30 448
数据结构之队列篇 1 队列之特点及在嵌入式软件中的应用 队列（queue）是一个简单线性表，它是一个允许在一端进行插入操作，而在另一端进行删除操作的线性表。队列（queue）遵循先进先出（FIFO, First-In-First-Out）的特征，和**栈（LIFO, Last In First Out）**刚好相反。 主要鉴于FIFO的结构特点，在嵌入式软件应用中主要应用于异步处理的buffer，例如，在CAN或者SPI等接口在中断接收到数据，存放在队列中（入队），而实际的处理解析（出队）将在其他线程或者任
嵌入式C语言入门——队列（顺序队列）
qq_35599308的博客
12-12 407
数据结构之队列顺序队列构造顺序队列顺序队列的初始化判断队列是否满判断队列是否为空顺序队列的入队顺序队列的出队顺序队列的读取 顺序队列 存放数据的队列数组当做收尾相接的表处理(对长度进行SIZE取余作为数组下标) 若定义队列数组长度为SIZE,能存放数据的只有SIZE-1个元素 队头,队尾指针从前进时从SIZE-1,直接进到0 队列满时,若rear向前进一步则会与front相遇 队头指针向前一...
嵌入式C语言那点事（二）栈与队列的实现
yuanlanjun
05-17 142
栈与队列的区别： 栈——先入后出，后入先出； 队列——先入先出，后入后出； 应用举例： 栈：函数调用时会将临时数据压栈；函数返回时再弹出来。 队列：一般，系统中的任务和消息经常使用队列。可以按任务或消息到来的先后顺序执行。 代码实现： 背景：使用C语言，在VS2008环境下，按栈与队列的原理，采用最简单易懂的方式，针对正整型（int）元素实现栈与队列。 原理：栈的存储空间使...
队列
u014694510的博客
05-29 166
队列跟栈一样，也是一种操作受限的线性表数据结构。它具有先进先出的特性，最基本的操作也是两个：入队 enqueue()，在队尾插入元素；出队 dequeue()，在队头删除元素。 顺序队列和链式队列 1、手写基于数组的实现方法：数组中的数据不连续问题如何解决。 // 用数组实现的队列 public class ArrayQueue { // 数组：items，数组大小：n pr...
Redis实现缓存队列
white211的博客
10-13 6422
原文来自：http://blog.csdn.net/zuoanyinxiang/article/details/50263945 1.用redis中的List可以实现队列，这样可以用来做消息处理和任务调度的队列 2.代码模拟代码结构 生产者模拟程序[java] view plain copy /**   *    */   package scheduleTest;      import ja
NB-IoT DTU 和3G/4G DTU功能主要区别
02-24
NB-IoT DTU 和 3G/4G DTU 功能主要区别 NB-IoT（ Narrowband Internet of Things，狭带物联网）是一种新兴的 IoT 技术，支持低功耗设备在广域网的蜂窝数据连接，也被称作低功耗广域网（LPWA）。NB-IoT 支持待机时间...
dgiot-dtu-master.zip
最新发布
12-17
DG-IoT DTU能够无缝对接OPC服务器和PLC（可编程逻辑控制器），使得生产过程中的实时数据得以快速、准确地传输到云端，实现远程监控和分析。 BacNet则是楼宇自动化系统的标准协议，它允许不同的建筑管理系统共享信息...
GPRS-DTU无线透明传输数据终端完整版资料.ppt
12-01
GPRS-DTU无线透明传输数据终端完整版资料 本文档介绍了GPRS-DTU无线透明传输数据终端的详细信息，该终端可以在移动专网和INTERNET公网上传输数据，支持GPRS和短消息双通道数据传输。该终端具有工业级设计、支持多种...
GPRS_DTU Benu-DTU BENU-YA 奔诺DTU 配置工具
11-13
【GPRS DTU Benu-DTU BENU-YA 奔诺DTU 配置工具】 GPRS DTU（General Packet Radio Service Data Terminal Unit），即通用分组无线服务数据终端单元，是一种基于GPRS网络的远程数据通信设备。在物联网（IoT）应用中...
MD-149 超小尺寸嵌入式 高速4G DTU.zip
10-12
MD-149 超小尺寸嵌入式 高速4G DTUzip,提供“MD-149 超小尺寸嵌入式 高速4G DTU”免费资料下载，主要包括产品介绍、设备配置、点到中心调试案例、驿云串口通调试案例、数据中心的搭建、DTU串口AT命等内容，可供选型...
串口缓冲区 循环队列
09-12
从项目中剥离，通信类接收数据时采用循环队列的方式。此工程在STM32F103ZET6上运行。开发环境为Keil for ARM 5.10
服务器端双缓冲队列s/c
02-11
服务器端双缓冲队列s/c,简单的实现了服务器端的队列实现
slick_queue:强大的，基于环形缓冲区的，无锁的C ++ MPMC队列
03-10
SlickQueue 强大的，基于环形缓冲区的，无锁的，仅标头的C ++ MPMC队列
双缓冲队列的设计与实现
05-05
双缓冲队列的设计与实现，多线程，c语言实现，用于提高程序运行效率
VC++自己写的先进先出队列的例子_QueueDemo
02-21
该程序使用VC++2008实现了先进先出队列的工作原理，对处理大量需要等待的数据非常有用
嵌入式面试C集锦（7） 循环队列
muyepiao1的博客
08-17 219
//运行环境keil c51 //学习目的：循环队列的运用 /*关键算法： 在循环队列中，当队列为空时，有front=rear，而当所有队列空间全占满时， 也有front=rear。为了区别这两种情况，规定循环队列最多只能有MaxSize-1个 队列元素，当循环队列中只剩下一个空存储单元时，队列就已经满了。因此，队 列判空的条件时front=rear，而队列判满的条件时front=（rear+1）%MaxSize。 */ #include "reg51.h" #include <stdio.h&gt.
实战日记：以数组方式实现静态队列操作
小楚的博客
05-28 202
学习背景 工作两年，大多数时间都是用一些常用的代码实现一些功能，对数据结构并没有怎么使用，也没有怎么花时间去了解，只知道队列是先进先出这些基本的东西（-.-），并没有去细究其中的实现过程，直到最近在做一个项目，用到串口收发，为避免极端情况下发生发送碰撞（在极短时间内有两条发送指令一起执行，导致从机无法做到数据的有效识别），受同事启发使用队列结构，其实现效果为：当有指令需要通过串口发送时，将指令标识放入队列中，主函数每隔一定时间（假定为10ms）判断队列是否为空，如果不为空则从队列中取出指令标识，判断该指令
数据结构复习2-队列(c语言 数组实现)
weixin_44646468的博客
05-22 343
数据结构复习-队列(Queue）何为队列C语言 实现功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 何为队列 队列的意思，顾名思义，就像我们排队买票一样，最先来的人也最先买。 C语言 实现 使用数组实现是最简单的方法，首先需要两个
NIO（一）--简介&API介绍
csdn_kenneth的博客
07-18 471
    传统IO模型 NIO模型 通道类比铁路，它建立了两点之间的一个连接。缓冲区类比火车。流是单向的。缓冲区是双向的。   package com.atguigu.nio; import java.nio.ByteBuffer; import org.junit.Test; /* * 一、缓冲区（Buffer）：在 Java NIO 中负责数...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值