UDP接收及ringbuffer处理

最新推荐文章于 2023-02-28 08:00:40 发布
最新推荐文章于 2023-02-28 08:00:40 发布
阅读量485 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xinshuwei/article/details/86146770
版权

UDP接收及ringbuffer处理 

#include "ringbuffer.h"


ofstream filetest1("ringbuff.txt");
fstream NetDataReader::filetest;
RingBuffer* NetDataReader::databuffer = new RingBuffer();
SOCKET NetDataReader::sock_Client = NULL;

/**
* @brief RingBuffer::RingBuffer
* @param buffersize Byte
*/
RingBuffer::RingBuffer(int size)
{
    if (rbBuf != NULL)
        free(rbBuf);
    rbBuf = (byte*)malloc(size);
    ZeroMemory(rbBuf,size);

    bufferSize = size;
    rbCapacity = size;
    rbBuff = rbBuf;
    rbHead = rbBuff;
    rbTail = rbBuff;
    
    
}

RingBuffer::~RingBuffer()
{
    rbBuff = nullptr;
    rbHead = nullptr;
    rbTail = nullptr;
    rbCapacity = 0;
    delete[]rbBuf; //释放缓冲区
}


/**
* @brief RingBuffer::rbCanRead
* @return 缓冲区可读字节数
*/
int RingBuffer::canRead()
{
    //ring buufer is null, return -1 nullptr 不像NULL会被编译器优化为0
    if ((nullptr == rbBuff) || (nullptr == rbHead) || (nullptr == rbTail))
    {
        return -1;
    }

    if (rbHead == rbTail)
    {
        return 0;
    }

    if (rbHead < rbTail)
    {
        return rbTail - rbHead;
    }
    return rbCapacity - (rbHead - rbTail);
}

/**
* @brief RingBuffer::rbCanWrite  缓冲区剩余可写字节数
* @return  可写字节数
*/
int RingBuffer::canWrite()
{
    if ((nullptr == rbBuff) || (nullptr == rbHead) || (nullptr == rbTail))
    {
        return -1;
    }

    return rbCapacity - canRead();
}

/**
* @brief RingBuffer::read 从缓冲区读数据
* @param 目标数组地址
* @param 读的字节数
* @return
*/
int RingBuffer::read(void *data, int count)
{
    int copySz = 0;

    if ((nullptr == rbBuff) || (nullptr == rbHead) || (nullptr == rbTail))
    {
        return -1;
    }
    if (nullptr == data)
    {
        return -1;
    }

    if (rbHead < rbTail)
    {
        copySz = MIN(count, canRead());
        memcpy(data, rbHead, copySz);
        rbHead += copySz;
        return copySz;
    }
    else
    {
        if (count < rbCapacity - (rbHead - rbBuff))
        {
            copySz = count;
            memcpy(data, rbHead, copySz);
            rbHead += copySz;
            return copySz;
        }
        else
        {
            copySz = rbCapacity - (rbHead - rbBuff);
            memcpy(data, rbHead, copySz);
            rbHead = rbBuff;
            copySz += read((unsigned char *)data + copySz, count - copySz);
            return copySz;
        }
    }
}

/**
* @brief RingBuffer::write
* @param 数据地址
* @param 要写的字节数
* @return 写入的字节数
*/
int RingBuffer::write(const void *data, int count)
{
    int tailAvailSz = 0;

    if ((nullptr == rbBuff) || (nullptr == rbHead) || (nullptr == rbTail))
    {
        return -1;
    }

    if (nullptr == data)
    {
        return -1;
    }

    if (count >= canWrite())
    {
        return -1;
    }

    if (rbHead <= rbTail)
    {
        tailAvailSz = rbCapacity - (rbTail - rbBuff);
        if (count <= tailAvailSz)
        {
            memcpy(rbTail, data, count);
            rbTail += count;
            if (rbTail == rbBuff + rbCapacity)
            {
                rbTail = rbBuff;
            }
            return count;
        }
        else
        {
            memcpy(rbTail, data, tailAvailSz);
            rbTail = rbBuff;

            return tailAvailSz + write((char*)data + tailAvailSz, count - tailAvailSz);
        }
    }
    else
    {
        memcpy(rbTail, data, count);
        rbTail += count;

        return count;
    }
}

/**
* @brief RingBuffer::size
* @return 缓冲区大小
*/
int RingBuffer::size()
{
    return bufferSize;
}




HRESULT NetDataReader::LoadNetData(void* DataInput, NET_DATARET* RetData, BufferData* Data)
{
    if (RetData == NULL)
    {
        RetData = (NET_DATARET*)malloc(1472);//帧格式大小
        ZeroMemory(RetData, 1472);
    }
    if (Data == NULL)
    {
        Data = (BufferData*)malloc(1320);
        ZeroMemory(Data, 1320);
    }

    try
    {
        memcpy(RetData, DataInput, 1472);

    }
    catch (const std::exception&)
    {
        return S_FALSE;

    }

    //异或和校验
    if (NetDataReader::GetMsgXor((byte *)DataInput, 1408) != RetData->crc)
    {
        printf("校验错啦\n");
        return S_FALSE;


    }


    //filetest1.write((char*)RetData, 1472);
    if ((RetData->DataDr != (INT16)0xA5A5) && (RetData->DataLen != (INT16)0xBA05) && (RetData->OverLogo != (INT16)0xF5F5))
    {
        return S_FALSE;
    }


    //try
    //{
    //    memcpy(Data->Data1, RetData->ADCData1, 60);

    //}
    //catch (const std::exception&)
    //{
    //    return S_FALSE;
    //}

    //try
    //{
    //    memcpy(Data->Data2, RetData->ADCData2, 60);

    //}
    //catch (const std::exception&)
    //{
    //    return S_FALSE;
    //}
    //try
    //{
    //    memcpy(Data->Data3, RetData->ADCData3, 60);

    //}
    //catch (const std::exception&)
    //{
    //    return S_FALSE;
    //}
    //try
    //{
    //    memcpy(Data->Data4, RetData->ADCData4, 60);

    //}
    //catch (const std::exception&)
    //{
    //    return S_FALSE;
    //}
    //try
    //{
    //    memcpy(Data->Data5, RetData->ADCData5, 60);

    //}
    //catch (const std::exception&)
    //{
    //    return S_FALSE;
    //}
    //try
    //{
    //    memcpy(Data->Data6, RetData->ADCData6, 60);

    //}
    //catch (const std::exception&)
    //{
    //    return S_FALSE;
    //}
    //try
    //{
    //    memcpy(Data->Data7, RetData->ADCData7, 60);

    //}
    //catch (const std::exception&)
    //{
    //    return S_FALSE;
    //}
    //try
    //{
    //    memcpy(Data->Data8, RetData->ADCData8, 60);

    //}
    //catch (const std::exception&)
    //{
    //    return S_FALSE;
    //}
    //try
    //{
    //    memcpy(Data->Data9, RetData->ADCData9, 60);

    //}
    //catch (const std::exception&)
    //{
    //    return S_FALSE;
    //}
    //try
    //{
    //    memcpy(Data->Data10, RetData->ADCData10, 60);

    //}
    //catch (const std::exception&)
    //{
    //    return S_FALSE;
    //}
    //try
    //{
    //    memcpy(Data->Data11, RetData->ADCData11, 60);

    //}
    //catch (const std::exception&)
    //{
    //    return S_FALSE;
    //}
    //try
    //{
    //    memcpy(Data->Data12, RetData->ADCData12, 60);

    //}
    //catch (const std::exception&)
    //{
    //    return S_FALSE;
    //}


    //try
    //{
    //    memcpy(Data->Data13, RetData->ADCData13, 60);

    //}
    //catch (const std::exception&)
    //{
    //    return S_FALSE;
    //}



    //try
    //{
    //    memcpy(Data->Data14, RetData->ADCData14, 60);

    //}
    //catch (const std::exception&)
    //{
    //    return S_FALSE;
    //}


    //try
    //{
    //    memcpy(Data->Data15, RetData->ADCData15, 60);

    //}
    //catch (const std::exception&)
    //{
    //    return S_FALSE;
    //}



    //try
    //{
    //    memcpy(Data->Data16, RetData->ADCData16, 60);

    //}
    //catch (const std::exception&)
    //{
    //    return S_FALSE;

    //}

    //try
    //{
    //    memcpy(Data->Data17, RetData->ADCData17, 60);

    //}
    //catch (const std::exception&)
    //{
    //    return S_FALSE;

    //}

    //try
    //{
    //    memcpy(Data->Data18, RetData->ADCData18, 60);

    //}
    //catch (const std::exception&)
    //{
    //    return S_FALSE;

    //}
    //try
    //{
    //    memcpy(Data->Data19, RetData->ADCData19, 60);

    //}
    //catch (const std::exception&)
    //{
    //    return S_FALSE;

    //}
    //try
    //{
    //    memcpy(Data->Data20, RetData->ADCData20, 60);

    //}
    //catch (const std::exception&)
    //{
    //    return S_FALSE;

    //}
    //try
    //{
    //    memcpy(Data->Data21, RetData->ADCData21, 60);

    //}
    //catch (const std::exception&)
    //{
    //    return S_FALSE;

    //}
    //try
    //{
    //    memcpy(Data->Data22, RetData->ADCData22, 60);

    //}
    //catch (const std::exception&)
    //{
    //    return S_FALSE;

    //}



    //if (databuffer->write(Data, 1320) == -1)
    //{
    //    return S_FALSE;
    //}
    //filetest1.write((char*)Data, 1320);
    //filetest1.close();
    return S_OK;
}

NetDataReader::~NetDataReader()
{
    //free()
}
NetDataReader::NetDataReader()
{

}


HRESULT NetDataReader::OpenSocket()
{
    WORD wVersionRequested;
    WSADATA wsadata;
    int err;
    wVersionRequested = MAKEWORD(1, 1);
    err = WSAStartup(wVersionRequested, &wsadata);
    if (err != 0)
    {
        //cout << "socket函数错误:" << WSAGetLastError << endl;
        return 0;
    }
    if (LOBYTE(wsadata.wVersion) != 1 || HIBYTE(wsadata.wVersion) != 1)
    {
        WSACleanup();
        return 0;
    }
    SOCKADDR_IN addr_server;   //服务器的地址数据结构
    addr_server.sin_family = AF_INET;
    addr_server.sin_port = htons(15533);//下位机端口号
    addr_server.sin_addr.S_un.S_addr = inet_addr("192.168.0.2");   //下位机IP地址
    sock_Client = socket(AF_INET, SOCK_DGRAM, 0);

    if (sock_Client == INVALID_SOCKET)
    {
        printf("socket()failed:%d\n", WSAGetLastError());
        return -1;
    }
    int iLen = sizeof(addr_server);

    //监听线程
    return S_OK;
}


byte NetDataReader::GetMsgXor(byte* message, int32_t size)
{
    int i;
    byte check;
    check = 0;
    for (i = 0; i < size; i++)
    {
        check ^= message[i + 4];
    }
    return check;
}
#include "stdafx.h"
#ifndef RB_MAX_LEN
#define RB_MAX_LEN 360*1024
#endif // !RB_MAX_LEN

#define MIN(a,b) (a)<(b)?(a):(b)//求最小


using std::string;
using std::wstring;
using namespace std;

class RingBuffer
{
public:
    RingBuffer(int size = RB_MAX_LEN);
    ~RingBuffer();
    int canRead();//how much can read 
    int canWrite();//how much can write
    int read(void *data, int count);  //read data frome ringbuffer
    int write(const void *data, int count);
    int size();
private:
    int bufferSize;       //buffer size
    unsigned char *rbBuf = new unsigned char[bufferSize];
    /*环形缓冲区变量*/
    int rbCapacity; //容量
    unsigned char  *rbHead;//buffer帧头  用于写数据
    unsigned char  *rbTail;//buffer帧尾 用于读数据
    unsigned char  *rbBuff;

};

struct NET_DATARET
{
    INT16 DataDr;//帧头标志
    INT16 DataLen;//数据长度
    byte ADCData1[60];
    byte ADCData_b1[4];

    byte ADCData2[60];
    byte ADCData_b2[4];

    byte ADCData3[60];
    byte ADCData_b3[4];

    byte ADCData4[60];
    byte ADCData_b4[4];

    byte ADCData5[60];
    byte ADCData_b5[4];

    byte ADCData6[60];
    byte ADCData_b6[4];

    byte ADCData7[60];
    byte ADCData_b7[4];


    byte ADCData8[60];
    byte ADCData_b8[4];

    byte ADCData9[60];
    byte ADCData_b9[4];

    byte ADCData10[60];
    byte ADCData_b10[4];

    byte ADCData11[60];
    byte ADCData_b11[4];


    byte ADCData12[60];
    byte ADCData_b12[4];


    byte ADCData13[60];
    byte ADCData_b13[4];


    byte ADCData14[60];
    byte ADCData_b14[4];


    byte ADCData15[60];
    byte ADCData_b15[4];


    byte ADCData16[60];
    byte ADCData_b16[4];

    byte ADCData17[60];
    byte ADCData_b17[4];

    byte ADCData18[60];
    byte ADCData_b18[4];

    byte ADCData19[60];
    byte ADCData_b19[4];

    byte ADCData20[60];
    byte ADCData_b20[4];

    byte ADCData21[60];
    byte ADCData_b21[4];

    byte ADCData22[60];
    byte ADCData_b22[4];

    //byte ADCData[1408];//ADC数据
    byte timedata[57];//预留及时间戳
    byte crc;
    INT16 OverLogo;//结束标志
};


struct BufferData
{
    byte Data1[60];
    byte Data2[60];
    byte Data3[60];
    byte Data4[60];
    byte Data5[60];
    byte Data6[60];
    byte Data7[60];
    byte Data8[60];
    byte Data9[60];
    byte Data10[60];
    byte Data11[60];
    byte Data12[60];
    byte Data13[60];
    byte Data14[60];
    byte Data15[60];
    byte Data16[60];

    byte Data17[60];
    byte Data18[60];
    byte Data19[60];
    byte Data20[60];
    byte Data21[60];
    byte Data22[60];
};


class NetDataReader
{
public:
     NetDataReader();
    ~NetDataReader();
    static HRESULT LoadNetData(void* DataInput, NET_DATARET*RetData, BufferData* Data);
    HRESULT OpenSocket();
    static byte GetMsgXor(byte* message, int32_t size);
private:
    static fstream filetest;
    static RingBuffer* databuffer;
    static SOCKET sock_Client;
    static SOCKADDR_IN addr_server;

    //static void 

};
#pragma once



#include<stdio.h>
#include<tchar.h>
#include<Windows.h>
#include<process.h>
#include<string.h>
#include <fstream>
#include <iostream>
#include <thread>
#include <vector> 
//The following 2 lines needed for ignore in main() 
#include <limits>

 

posted on 2018-07-25 11:52 xinshuwei 阅读(...) 评论(...) 编辑 收藏

谢娘蓝桥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Rt-thead studio软件下使用ringbuffer
04-21
Rt-thead studio软件下使用ringbuffer
用户层网络缓冲区设计-ringbuffer、chainbuffer
qq_40989769的博客
11-27 2023
用户层网络缓冲区设计-ringbuffer、chainbuffer|为什么用户层需要设计网络缓冲区？、手撕ringbuffer、event buffer的设计 专注于服务器后台开发，包括C/C++，Linux，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK等 直播学习地址：C/C++Linux服务器开发/后台架构师【零声教育】-学习视频教程-腾讯课堂 ...
环形缓冲队列(RingBuffer),自己写的靠谱的代码
CSSEIKOCS的专栏
03-03 7289
kfifo ringbuffer
tcp服务器信息记录,ringbuffer(tcp流编程,用于记录服务器日志).docx
weixin_39613839的博客
08-10 455
ringbuffer(tcp流编程,用于记录服务器日志)/******************************************************************************* ** * ** ...
网卡的 Ring Buffer 详解
关注微信公众号【开源Linux】，后台回复『10T』，领取10T学习资源大放送，涵盖Linux、虚拟化、容器、云计算、网络、Python、Go等书籍和视频
02-28 1561
来源：yangyidba1. 网卡处理数据包流程网卡处理网络数据流程图：图片来自参考链接1上图中虚线步骤的解释：1 DMA 将 NIC 接收的数据包逐个写入 sk_buff ，一个数据包可能占用多个 sk_buff , sk_buff 读写顺序遵循FIFO（先入先出）原则。2 DMA 读完数据之后，NIC 会通过 NIC Interrupt Handler 触发 IRQ （中断请求）。3 NIC ...
适用于单片机的ringbuffer
12-29
适用于单片机的ringbuffer
ringbuffer.rar
04-26
代码中包含了ringbuferr的所有接口函数，使用简单，直接上手，C语言编写。代码中包含了ringbuferr的所有接口函数，使用简单，直接上手，C语言编写。
driver_usart.rar_ring buffer
09-20
Driver UASRT with ring-buffer, macros for calculating BAUD RATE
基于matlab实现实现了基于项目的协同过滤代码，MATLAB实现.rar
05-04
基于matlab实现实现了基于项目的协同过滤代码，MATLAB实现.rar
各地区年末城镇登记失业人员及失业率.xls
05-05
数据来源：中国劳动统计NJ-2023版
企业固定资产信息管理系统设计与实现.doc
05-04
企业固定资产信息管理系统设计与实现.doc
node-v11.14.0-darwin-x64.tar.xz
05-04
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
node-v8.9.1-sunos-x64.tar.xz
05-04
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
node-v12.10.0-linux-armv7l.tar.xz
05-04
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
基于VB实现的学生成绩管理系统(源代码+系统+开题报告+答辩PPT).zip
05-04
【作品名称】：基于VB实现的学生成绩管理系统(源代码+系统+开题报告+答辩PPT) 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
银行信贷管理系统设计与实现-(毕业设计)1.docx
05-04
银行信贷管理系统设计与实现-(毕业设计)1.docx
基于VB实现的银行代扣代发工资系统(源代码+系统+开题报告).zip
05-04
【作品名称】：基于VB实现的银行代扣代发工资系统(源代码+系统+开题报告) 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
（更新至2022年）全国镇分年龄、性别的人口数.xls
最新发布
05-05
数据来源：中国人口与就业统计NJ-2023版
uart ringbuffer
02-03
同时，RingBuffer还可以实现数据的先进先出（FIFO）处理，确保数据的有序传输。 UART RingBuffer的应用在于解决UART通信中可能出现的数据丢失或者溢出问题，特别是在高速数据传输或者数据量较大的情况下。通过使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

谢娘蓝桥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值