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("校验错啦
");
        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
", 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>