UniversalCan/Src/network.c

#include "network.h"
#include "work.h"

Socket_t context;

#define SOCKET_QUEUE_SEND_NUM      100000  //SOCKET接收队列长度
#define SOCKET_QUEUE_RECV_NUM      100000  //SOCKET发送队列长度

QueueHandle_t SocketRecvQueue;
QueueHandle_t SocketSendQueue;

void NetLoopTask(void *p);
void NetReciveTask(void *p);
void NetAnalysis(char *data);
void NetPkgSend(char *data);
void NetReciveQueueTask(void *p);
void NetSendQueueTask(void *p);

Status NetProcessInit(uint32_t Port)
{
    //初始化
    if (xSocketInitEnvironment() == SOCKET_SUCCESS)
    {
        printf("socket init success\n");
    }
    else
    {
        printf("socket init error\n");
        return ERROR;
    }
    // 创建
    context = xSocketCreateUDP();
    // 绑定
    if (xSocketBind(context,Port) == SOCKET_SUCCESS)
    {
        printf("socket listen success\n");
    }
    else
    {
        printf("socket listen error\n");
        return ERROR;
    }
    
    SocketRecvQueue = xQueueCreate(SOCKET_QUEUE_RECV_NUM, PKG_LEN);
    SocketSendQueue = xQueueCreate(SOCKET_QUEUE_SEND_NUM, PKG_LEN);

    //开启任务
    xTaskCreate(NetReciveTask,      /*!< 任务函数  */
                "NetReciveTask",    /*!< 任务名    */
                1024,               /*!< stack大小，单位word，也就是4字节 */
                NULL,               /*!< 任务参数  */
                0,                  /*!< 任务优先级, 数字越大优先级越高*/
                NULL);              /*!< 任务句柄  */

    xTaskCreate(NetReciveQueueTask,      /*!< 任务函数  */
                "NetReciveQueueTask",    /*!< 任务名    */
                1024,                    /*!< stack大小，单位word，也就是4字节 */
                NULL,                    /*!< 任务参数  */
                0,                       /*!< 任务优先级, 数字越大优先级越高*/
                NULL);                   /*!< 任务句柄  */

    xTaskCreate(NetSendQueueTask,        /*!< 任务函数  */
                "NetSendQueueTask",      /*!< 任务名    */
                1024,                    /*!< stack大小，单位word，也就是4字节 */
                NULL,                    /*!< 任务参数  */
                0,                       /*!< 任务优先级, 数字越大优先级越高*/
                NULL);                   /*!< 任务句柄  */

    //网络循环执行任务
    xTaskCreate(NetLoopTask,        /*!< 任务函数  */
                "NetLoopTask",      /*!< 任务名    */
                1024,               /*!< stack大小，单位word，也就是4字节 */
                NULL,               /*!< 任务参数  */
                0,                  /*!< 任务优先级, 数字越大优先级越高*/
                NULL);              /*!< 任务句柄  */
}

//udp接收任务
void NetReciveTask(void *p)
{
    char PcRecvBuf[PKG_LEN];    // 接收缓冲区
    char PcRemoteIP[16];        // 存放谁发过来的 IP
    uint16_t PcRemotePort;      //存放谁发过来的端口
    int PkgLen;                 //接收长度

    while (1)
    {
        PkgLen = xSocketReceiveFrom(context,PcRecvBuf,PKG_LEN,PcRemoteIP,&PcRemotePort);
        if (PkgLen == PKG_LEN)
        {
            xQueueSend(SocketRecvQueue,PcRecvBuf,portMAX_DELAY);
        }
    }
}

//udp解析函数
void NetAnalysis(char *data)
{
    switch (data[1])
    {
        case PKG_OPEN_CAN:
            //打开CAN
            CanFuncRegister(data[2]);
            CanFuncOpen(data[3]);
            break;
        case PKG_CLOSE_CAN:
            //关闭CAN
            break;
        case PKG_CTRL_CAN:
            //收发CAN
            break;
        default:
            return;
    }
}

//心跳包
void NetHeart(void)
{
    static char heart[PKG_LEN];
    heart[0] = PHEAD;
    heart[1] = PKG_HEART;
    heart[2] = work.status;
    heart[3] = work.product;
    heart[4] = work.chnlNum;
    heart[5] = work.canFd;

    for (uint8_t i = 6; i < PKG_LEN; i++)
    {
        heart[i] = DISABLE;
    }
    
    heart[PKG_LEN - 1] = PEND;

    NetPkgSend(heart);
}

//网络循环任务
void NetLoopTask(void *p)
{
    while (1)
    {
        //发送心跳包
        // NetHeart();
        vTaskDelay(500);
    }
}

//udp队列接收任务
void NetReciveQueueTask(void *p)
{
    char PcRecvBuf[PKG_LEN];    // 接收缓冲区

    while(1)
    {
        xQueueReceive(SocketRecvQueue,&PcRecvBuf,portMAX_DELAY);

        NetAnalysis(PcRecvBuf);
    }
}

//网络数据包发送
void NetPkgSend(char *data)
{
    data[0] = PHEAD;
    data[PKG_LEN - 1] = PEND;
    xQueueSend(SocketSendQueue,data,portMAX_DELAY);
}

//网络数据包发送队列
void NetSendQueueTask(void *p)
{
    static uint16_t SendPort = SEND_PORT;
    char PcSendBuf[PKG_LEN];    // 接收缓冲区

    while(1)
    {
        xQueueReceive(SocketSendQueue,&PcSendBuf,portMAX_DELAY);

        xSocketSendTo(context,PcSendBuf,PKG_LEN,"127.0.0.1",SendPort);
    }
}