14. TCP和UDP的例程使用

最新推荐文章于 2022-07-20 08:53:30 发布
最新推荐文章于 2022-07-20 08:53:30 发布
阅读量428 收藏
点赞数
分类专栏： cat1模块M601教程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w_hizyf_m/article/details/108357158
版权

编译方法：.\examples\build\对应的.bat 文件双击执行或打开就可以编译。
生成文件：.\out\对应目录\hex\M601_example_**.pac

1 TCP例程介绍

#include <stdbool.h>
#include <stdint.h>
#include <string.h>

#include "zyf_app.h"

#include "zyf_trace.h"
#include "zyf_timer.h"
#include "zyf_socket.h"
#include "zyf_thread.h"


/* tcp client */
static ZYF_SockParam_t s_tTCPParam;
static ZYF_SockClient_t s_tTCPClient;

static Uart_Param_t g_uart1param;


void UartWriteCallBack(void* Param) // general com
{
    Uart_Param_t *uartparam = (Uart_Param_t *)Param; 
    if(Param == NULL)
    {
        return;
    }    

    ZYF_UartWrite(uartparam->port,(uint8_t *)"UartWrite succeed\r\n",strlen("UartWrite succeed\r\n"));
    ZYF_UartWriteCallbackSwitch(uartparam->port,false);

}

void UartReadCallBack(void* Param) // 
{
    uint32_t recvlen = 0;
    Uart_Param_t *uartparam = (Uart_Param_t *)Param; 

    /*
    UART_PORT1 = 0,
    UART_PORT2 = 1,
    UART_PORT3 = 2,
    */
    ZYF_LOG("Uart%d recv",uartparam->port);

    while(ZYF_UartRead(uartparam->port, &(uartparam->uartbuf[recvlen]), 1))
    {
        ZYF_LOG("recv :%02x",uartparam->uartbuf[recvlen]);
        recvlen++;
    }
    ZYF_UartWrite(uartparam->port,uartparam->uartbuf,recvlen);
    ZYF_UartWriteCallbackSwitch(uartparam->port,true);
}


static void AppUartInit(void)
{
    int32_t ret;
    g_uart1param.port = DEBUG_PORT;
    ZYF_UartRegister(g_uart1param.port, UartReadCallBack,&g_uart1param);
    ZYF_UartWriteCbRegister(g_uart1param.port,UartWriteCallBack,&g_uart1param);
    ZYF_UartOpen(g_uart1param.port, 115200, ZYF_FC_NONE);

    ZYF_LOG("AppUartInit");
    return;
}


void ZYF_TcpPdpActCallback(uint8_t status)
{
    ZYF_SockClient_t *ptClient = &s_tTCPClient;
    ZYF_AppMsg_t tMsg;

    if (ptClient->ptParam != NULL) {
        tMsg.wMsgId = status;
        ZYF_MsgQPut(ptClient->ptParam->ptMsg, (void *)&tMsg);
    }
}


void ZYF_PdpActiveCnf(uint8_t contextId, int32_t errCode)
{
    ZYF_LOG("PDP: Active");

    ZYF_TcpPdpActCallback(APP_MSG_PDP_ACTIVE);
}

void ZYF_PdpDeactiveCnf(uint8_t contextId, int32_t errCode)
{
    ZYF_LOG("PDP: Deactive");
}


static void ZYF_TCPReconnReq(void)
{
    ZYF_SockClient_t *ptClient = &s_tTCPClient;
    ZYF_AppMsg_t tMsg;
    
    if (!ptClient->ptParam->bConnected) {
        tMsg.wMsgId = APP_MSG_TCP_RECONN;
        ZYF_MsgQPut(ptClient->ptParam->ptMsg, (void *)&tMsg);
    }
}

static void ZYF_TCPReconnCallback(void *pvArg)
{
    ZYF_SockClient_t *ptClient = (ZYF_SockClient_t *)pvArg;
    
    ZYF_TCPReconnReq();
    ZYF_StopTimer(ptClient->ptParam->ptConnTimer);
}

static void ZYF_TCPSendDataReq(uint8_t *pchBuffer, uint16_t hwLen)
{
    ZYF_SockClient_t *ptClient = &s_tTCPClient;
    ZYF_AppMsg_t tMsg;
    
    if (ptClient->ptParam->bConnected && 
        ptClient->ptParam->bSent /*|| (check ack num) */) {
        ptClient->ptParam->bSent = false;
        tMsg.wMsgId = APP_MSG_TCP_SEND;  
        ptClient->ptParam->hwTxSize = hwLen;
        memcpy((void *)ptClient->ptParam->chTxBuffer, pchBuffer, hwLen);
        
        ZYF_MsgQPut(ptClient->ptParam->ptMsg, (void *)&tMsg);
    }
}

static void ZYF_TCPTimerCallback(void *pvParam)
{
    ZYF_SockClient_t *ptClient = (ZYF_SockClient_t *)pvParam;
    const char *pcStr = "Hello, world!\r\n";

    ZYF_TCPSendDataReq((uint8_t *)pcStr, strlen(pcStr));
    ZYF_StartTimer(ptClient->ptParam->ptSendTimer, 300000);
}

static void ZYF_TCPClientCallback(ZYF_SocketEvt_t tEvtId)
{
    ZYF_SockClient_t *ptClient = &s_tTCPClient;
    
    switch (tEvtId) {
        case SOC_CONNECT:
            ZYF_LOG("TCP event: SOC_CONNECT");
            ZYF_LOG("tcp socket connect ok");
            ptClient->ptParam->bConnected = true;
            ptClient->ptParam->bSent = true;
            ZYF_StartTimer(ptClient->ptParam->ptSendTimer, 5000);
            break;
            
        case SOC_CLOSE:
            ZYF_LOG("TCP event: SOC_CLOSE");
            ptClient->ptParam->bConnected = false;
            ptClient->ptParam->bSent = false;
            break;
            
        case SOC_ERR_IND:
            ZYF_LOG("TCP event: SOC_ERR_IND");
            ptClient->ptParam->bConnected = false;
            ptClient->ptParam->bSent = false;
            break;
            
        case SOC_BEARER_LOSING_IND:
            ZYF_LOG("TCP event: SOC_BEARER_LOSING_IND");
            ptClient->ptParam->bConnected = false;
            ptClient->ptParam->bSent = false;
            break;
            
        case SOC_CLOSE_IND:
            ZYF_LOG("TCP event: SOC_CLOSE_IND");
            ptClient->ptParam->bConnected = false;
            ptClient->ptParam->bSent = false;
            break;
            
        case SOC_WRITE:
            ZYF_LOG("TCP event: SOC_WRITE");
            ptClient->ptParam->bSent = true;
            break;
            
        case SOC_READ:
            ZYF_LOG("TCP event: SOC_READ");
            
            int iRet = -1;
            iRet = ZYF_SocketRecv(ptClient->nSockFd, 
                                  ptClient->ptParam->chRxBuffer, 
                                  SOCKET_RECV_MAX_SIZE);
            if (iRet <= 0) {
                ZYF_LOG("failed to recv tcp");
            } else {
                ptClient->ptParam->hwRxSize = iRet;
                ZYF_LOG("recv tcp ok => len: %d, %s", ptClient->ptParam->hwRxSize, ptClient->ptParam->chRxBuffer);
                memset((void *)ptClient->ptParam->chRxBuffer, 0, SOCKET_RECV_MAX_SIZE);
            }
            break;
    }
}

static void ZYF_TCPClientConn(ZYF_SockClient_t *ptClient)
{
    ptClient->nSockFd = ZYF_SocketCreate(SOC_TYPE_TCP);
    
    if (ptClient->nSockFd >= 0) {
        ZYF_LOG("tcp socket create ok => %d", ptClient->nSockFd);
        ZYF_SocketRegister(ptClient->nSockFd, ZYF_TCPClientCallback);
        if (!ZYF_SocketConnect(ptClient->nSockFd, ptClient->chIpAddr, ptClient->hwPort)) {
            
        } else {
            ZYF_SocketClose(ptClient->nSockFd);
            ptClient->ptParam->bConnected = false;
            ZYF_StartTimer(ptClient->ptParam->ptConnTimer, 10000);
        }
    }
}

void ZYF_GetIpByNameCallBack(uint8_t contexId, int32_t errCode, uint8_t *ipAddr)
{
    (void)contexId;  //unuse
    
    if (SOC_SUCCESS == errCode) {
        ZYF_LOG("Host IP: %d.%d.%d.%d", ipAddr[0],ipAddr[1],ipAddr[2],ipAddr[3]);
    }
}

static void ZYF_TCPClientThread(void *pvParam)
{
    ZYF_SockClient_t *ptClient = (ZYF_SockClient_t *)pvParam;
    ZYF_AppMsg_t tMsg;
    int iRet = -1;

    ZYF_LOG("thread enter!");

    while (1) {
        iRet = ZYF_MsgQGet(ptClient->ptParam->ptMsg, (void *)&tMsg);
        if (iRet < 0) {
            ZYF_LOG("Failed to get msg");
            ZYF_ThreadSleep(10);
        }

        switch (tMsg.wMsgId) {
            case APP_MSG_PDP_ACTIVE:
                ZYF_LOG("PDP active!");

                uint8_t chIpAddr[4] = {0};
                ZYF_ConvertIpAddr((uint8_t *)"192.168.1.100", chIpAddr);   //just for test
                ZYF_LOG("Convert: %d.%d.%d.%d", chIpAddr[0],chIpAddr[1],chIpAddr[2],chIpAddr[3]);
                
                ZYF_GetIPByHostName(1, "mqtt2.gpstracktech.com", ZYF_GetIpByNameCallBack);  //just for test

                ZYF_TCPClientConn(ptClient);
                ZYF_SleepEnable();
                break;
                
            case APP_MSG_PDP_DEACTIVE:
                ZYF_LOG("PDP Deactive!");
                ZYF_StopTimer(ptClient->ptParam->ptSendTimer);
                if (!ZYF_SocketClose(ptClient->nSockFd)) {
                    ZYF_LOG("tcp socket close ok");
                    ptClient->ptParam->bConnected = false;
                }
                break;

            case APP_MSG_TCP_RECONN:
                ZYF_TCPClientConn(ptClient);
                break;

            case APP_MSG_TCP_SEND:
                if (ptClient->ptParam->hwTxSize > 0) {
                    uint16_t hwSentLen = 0;
                    int rc = 0;
                    
                    do {
                        rc = ZYF_SocketSend(ptClient->nSockFd, 
                                           &ptClient->ptParam->chTxBuffer[hwSentLen], 
                                           ptClient->ptParam->hwTxSize - hwSentLen);
                        if (rc > 0) {
                            hwSentLen += rc;
                        } else if (rc < 0) {                             //fixme: check if err here and then re-send
                            ZYF_LOG("failed to send tcp");
                            break;
                        }
                    } while (hwSentLen < ptClient->ptParam->hwTxSize);   //fixme: check if timeout here and then re-send

                    if (rc > 0) {
                        ZYF_LOG("sent tcp ok");
                    }
                }
                break;
                
            default:
                break;
        }
    }
}

void ZYF_TCPClientTest(void)
{
    uint8_t chIpAddr[4] = {120,77,177,56};//{219,133,34,198};

    s_tTCPClient.nSockFd = -1;
    s_tTCPClient.hwPort = 4489;
    memcpy((void *)s_tTCPClient.chIpAddr, chIpAddr, 4);
    
    s_tTCPParam.bConnected = false;
    s_tTCPParam.bSent = false;
    s_tTCPParam.hwTxSize = 0;
    memset((void *)s_tTCPParam.chTxBuffer, 0, SOCKET_SEND_MAX_SIZE);
    s_tTCPParam.hwRxSize = 0;
    memset((void *)s_tTCPParam.chRxBuffer, 0, SOCKET_RECV_MAX_SIZE);

    s_tTCPClient.ptParam = &s_tTCPParam;
    s_tTCPClient.ptParam->ptMsg = ZYF_MsgQCreate(10, sizeof(ZYF_AppMsg_t));
    if (s_tTCPClient.ptParam->ptMsg != NULL) {
        ZYF_LOG("Succeeded to create network msg");
    }
    s_tTCPClient.ptParam->ptSendTimer = ZYF_CreateTimer(ZYF_TCPTimerCallback, (void *)&s_tTCPClient);
    s_tTCPClient.ptParam->ptConnTimer = ZYF_CreateTimer(ZYF_TCPReconnCallback, (void *)&s_tTCPClient);

    ZYF_ThreadCreate("ZYF_TCPClientThread", ZYF_TCPClientThread, (void *)&s_tTCPClient, ZYF_PRIORITY_NORMAL, 1024 * 2);
}



void TcpClient_Example(void * Param)
{
    ZYF_MsgQ_t *ptMsg;
    ZYF_AppMsg_t tMsg;
    int iRet = -1;
    ptMsg = ZYF_MsgQCreate(10, sizeof(ZYF_AppMsg_t));
    ZYF_LOG("thread enter!");

    ZYF_NetworkInit();
    ZYF_TCPClientTest();
    while (1) {
        ZYF_LOG("in while.");
        iRet = ZYF_MsgQGet(ptMsg, (void *)&tMsg);
        if (iRet < 0) {
            ZYF_LOG("Failed to get msg");
            ZYF_ThreadSleep(1000);
        }
    }

}

static void prvInvokeGlobalCtors(void)
{
    extern void (*__init_array_start[])();
    extern void (*__init_array_end[])();

    size_t count = __init_array_end - __init_array_start;
    for (size_t i = 0; i < count; ++i)
        __init_array_start[i]();
}


int appimg_enter(void *param)
{
    AppUartInit();
    ZYF_LOG("application image enter, param 0x%x", param);

    prvInvokeGlobalCtors();

    ZYF_ThreadCreate("TcpClient_Example", TcpClient_Example, NULL, ZYF_PRIORITY_HIGH, 10*1024);
    return 0;
}

void appimg_exit(void)
{
    OSI_LOGI(0, "application image exit");
}

 

2 UDP例程介绍

#include <stdbool.h>
#include <stdint.h>
#include <string.h>

#include "zyf_app.h"

#include "zyf_trace.h"
#include "zyf_timer.h"
#include "zyf_socket.h"
#include "zyf_thread.h"


/* udp client */
static ZYF_SockParam_t s_tUDPParam;
static ZYF_SockClient_t s_tUDPClient;

static Uart_Param_t g_uart1param;

void UartWriteCallBack(void* Param) // general com
{
    Uart_Param_t *uartparam = (Uart_Param_t *)Param; 
    if(Param == NULL)
    {
        return;
    }    

    ZYF_UartWrite(uartparam->port,(uint8_t *)"UartWrite succeed\r\n",strlen("UartWrite succeed\r\n"));
    ZYF_UartWriteCallbackSwitch(uartparam->port,false);

}

void UartReadCallBack(void* Param) // 
{
    uint32_t recvlen = 0;
    Uart_Param_t *uartparam = (Uart_Param_t *)Param; 

    /*
    UART_PORT1 = 0,
    UART_PORT2 = 1,
    UART_PORT3 = 2,
    */
    ZYF_LOG("Uart%d recv",uartparam->port);

    while(ZYF_UartRead(uartparam->port, &(uartparam->uartbuf[recvlen]), 1))
    {
        ZYF_LOG("recv :%02x",uartparam->uartbuf[recvlen]);
        recvlen++;
    }
    ZYF_UartWrite(uartparam->port,uartparam->uartbuf,recvlen);
    ZYF_UartWriteCallbackSwitch(uartparam->port,true);
}


static void AppUartInit(void)
{
    int32_t ret;
    g_uart1param.port = DEBUG_PORT;
    ZYF_UartRegister(g_uart1param.port, UartReadCallBack,&g_uart1param);
    ZYF_UartWriteCbRegister(g_uart1param.port,UartWriteCallBack,&g_uart1param);
    ZYF_UartOpen(g_uart1param.port, 115200, ZYF_FC_NONE);

    ZYF_LOG("AppUartInit");
    return;
}

void ZYF_UdpPdpActCallback(uint8_t status)
{
    ZYF_SockClient_t *ptClient = &s_tUDPClient;
    ZYF_AppMsg_t tMsg;

    if (ptClient->ptParam != NULL) {
        tMsg.wMsgId = status;
        ZYF_MsgQPut(ptClient->ptParam->ptMsg, (void *)&tMsg);
    }
}

void ZYF_PdpActiveCnf(uint8_t contextId, int32_t errCode)
{
    ZYF_LOG("PDP: Active");

    ZYF_UdpPdpActCallback(APP_MSG_PDP_ACTIVE);
}

void ZYF_PdpDeactiveCnf(uint8_t contextId, int32_t errCode)
{
    ZYF_LOG("PDP: Deactive");
}


static void ZYF_UDPReconnReq(void)
{
    ZYF_SockClient_t *ptClient = &s_tUDPClient;
    ZYF_AppMsg_t tMsg;
    
    if (!ptClient->ptParam->bConnected) {
        tMsg.wMsgId = APP_MSG_UDP_RECONN;
        ZYF_MsgQPut(ptClient->ptParam->ptMsg, (void *)&tMsg);
    }
}

static void ZYF_UDPReconnCallback(void *pvArg)
{
    ZYF_SockClient_t *ptClient = (ZYF_SockClient_t *)pvArg;
    
    ZYF_UDPReconnReq();
    ZYF_StopTimer(ptClient->ptParam->ptConnTimer);
}

void ZYF_UDPSendDataReq(uint8_t *pchBuffer, uint16_t hwLen)
{
    ZYF_SockClient_t *ptClient = &s_tUDPClient;
    ZYF_AppMsg_t tMsg;
    
    tMsg.wMsgId = APP_MSG_UDP_SEND;  
    ptClient->ptParam->hwTxSize = hwLen;
    memcpy((void *)ptClient->ptParam->chTxBuffer, pchBuffer, hwLen);
    
    ZYF_MsgQPut(ptClient->ptParam->ptMsg, (void *)&tMsg);
}

static void ZYF_UDPTimerCallback(void *pvParam)
{
    ZYF_SockClient_t *ptClient = (ZYF_SockClient_t *)pvParam;
    const char *pcStr = "Hello, M601!\r\n";

    ZYF_UDPSendDataReq((uint8_t *)pcStr, strlen(pcStr));
    ZYF_StartTimer(ptClient->ptParam->ptSendTimer, 5000);
}

static void ZYF_UDPClientCallback(ZYF_SocketEvt_t tEvtId)
{
    ZYF_SockClient_t *ptClient = &s_tUDPClient;
    
    switch (tEvtId) {
        case SOC_CONNECT:
            ZYF_LOG("UDP event: SOC_CONNECT");
            break;
            
        case SOC_CLOSE:
            ZYF_LOG("UDP event: SOC_CLOSE");
            break;
            
        case SOC_ERR_IND:
            ZYF_LOG("UDP event: SOC_ERR_IND");
            break;
            
        case SOC_BEARER_LOSING_IND:
            ZYF_LOG("UDP event: SOC_BEARER_LOSING_IND");
            break;
            
        case SOC_CLOSE_IND:
            ZYF_LOG("UDP event: SOC_CLOSE_IND");
            break;
            
        case SOC_WRITE:
            ZYF_LOG("UDP event: SOC_WRITE");
            break;
            
        case SOC_READ:
            ZYF_LOG("UDP event: SOC_READ");
            
            int iRet = -1;
            iRet = ZYF_SocketRecvFrom(ptClient->nSockFd, 
                                      ptClient->ptParam->chRxBuffer, 
                                      SOCKET_RECV_MAX_SIZE, 
                                      &ptClient->chIpAddr[0], 
                                      &ptClient->hwPort);
            if (iRet <= 0) {
                ZYF_LOG("failed to recv udp");
            } else {
                ptClient->ptParam->hwRxSize = iRet;
                ZYF_LOG("recv udp ok => len: %d, %s", ptClient->ptParam->hwRxSize, ptClient->ptParam->chRxBuffer);
                memset((void *)ptClient->ptParam->chRxBuffer, 0, SOCKET_RECV_MAX_SIZE);
            }
            break;
        default:
            ZYF_LOG("UDP event: unkown %X",tEvtId);
            break;
            
    }
}

static void ZYF_UDPClientConn(ZYF_SockClient_t *ptClient)
{
    ptClient->nSockFd = ZYF_SocketCreate(SOC_TYPE_UDP);
    
    if (ptClient->nSockFd >= 0) {
        ZYF_LOG("udp socket create ok => %d", ptClient->nSockFd);
        ZYF_SocketRegister(ptClient->nSockFd, ZYF_UDPClientCallback);
        ZYF_StartTimer(ptClient->ptParam->ptSendTimer, 5000);
    }
}

static void ZYF_UDPClientThread(void *pvParam)
{
    ZYF_SockClient_t *ptClient = (ZYF_SockClient_t *)pvParam;
    ZYF_AppMsg_t tMsg;
    int iRet = -1;

    ZYF_LOG("thread enter!");

    while (1) {
        iRet = ZYF_MsgQGet(ptClient->ptParam->ptMsg, (void *)&tMsg);
        if (iRet < 0) {
            ZYF_LOG("Failed to get msg");
            ZYF_ThreadSleep(10);
        }

        switch (tMsg.wMsgId) {
            case APP_MSG_PDP_ACTIVE:
                ZYF_LOG("PDP active!");
                ZYF_UDPClientConn(ptClient);
                break;
                
            case APP_MSG_PDP_DEACTIVE:
                ZYF_LOG("PDP Deactive!");
                ZYF_StopTimer(ptClient->ptParam->ptSendTimer);
                if (!ZYF_SocketClose(ptClient->nSockFd)) {
                    ZYF_LOG("udp socket close ok");
                }
                break;

            case APP_MSG_UDP_SEND:
                if (ptClient->ptParam->hwTxSize > 0) {
                    uint32_t wTicksToWait = 3000;   // 3S
                    uint16_t hwSentLen = 0;
                    
                    do {
                        int rc = 0;
                        ZYF_SocketSetOpt(ptClient->nSockFd, 
                                         ZYF_SOL_SOCKET, 
                                         ZYF_SO_SNDTIMEO, 
                                         &wTicksToWait, 
                                         sizeof(wTicksToWait));
                        //iRet = CFW_TcpipSocketSendto(ptSockCtx->cSocketId, (uint8_t *)pchBuffer, (uint16_t)wSize, 0, &ptSockCtx->tDestAddr, ptSockCtx->tDestAddr.sin_len);
                        rc = ZYF_SocketSendTo(ptClient->nSockFd, 
                                              &ptClient->ptParam->chTxBuffer[hwSentLen], 
                                              ptClient->ptParam->hwTxSize - hwSentLen, 
                                              &ptClient->chIpAddr[0], 
                                              ptClient->hwPort);
                                           
                        if (rc > 0) {
                            hwSentLen += rc;
                        } else if (rc < 0) {                             //fixme: check if err here and then re-send
                            ZYF_LOG("failed to send udp");
                            break;
                        }
                    } while (hwSentLen < ptClient->ptParam->hwTxSize);   //fixme: check if timeout here and then re-send
                    ZYF_LOG("sent udp ok");
                }
                break;
                
            default:
                break;
        }
    }
}

void ZYF_UDPClientTest(void)
{
    uint8_t chIpAddr[4] = {120,77,177,56};

    s_tUDPClient.nSockFd = -1;
    s_tUDPClient.hwPort = 4499;
    memcpy((void *)s_tUDPClient.chIpAddr, chIpAddr, 4);
    
    s_tUDPParam.bConnected = false;
    s_tUDPParam.bSent = false;
    s_tUDPParam.hwTxSize = 0;
    memset((void *)s_tUDPParam.chTxBuffer, 0, 1024);
    s_tUDPParam.hwRxSize = 0;
    memset((void *)s_tUDPParam.chRxBuffer, 0, 1024);

    s_tUDPClient.ptParam = &s_tUDPParam;
    s_tUDPClient.ptParam->ptMsg = ZYF_MsgQCreate(10, sizeof(ZYF_AppMsg_t));
    if (s_tUDPClient.ptParam->ptMsg != NULL) {
        ZYF_LOG("Succeeded to create network msg");
    }
    s_tUDPClient.ptParam->ptSendTimer = ZYF_CreateTimer(ZYF_UDPTimerCallback, (void *)&s_tUDPClient);
    s_tUDPClient.ptParam->ptConnTimer = ZYF_CreateTimer(ZYF_UDPReconnCallback, (void *)&s_tUDPClient);

    ZYF_ThreadCreate("ZYF_UDPClientThread", ZYF_UDPClientThread, (void *)&s_tUDPClient, ZYF_PRIORITY_NORMAL, 1024 * 2);
}

void UdpClient_Example(void * Param)
{
    ZYF_MsgQ_t *ptMsg;
    ZYF_AppMsg_t tMsg;
    int iRet = -1;
    ptMsg = ZYF_MsgQCreate(10, sizeof(ZYF_AppMsg_t));
    ZYF_LOG("thread enter!");

    ZYF_NetworkInit();
    ZYF_UDPClientTest();
    while (1) {
        ZYF_LOG("in while.");
        iRet = ZYF_MsgQGet(ptMsg, (void *)&tMsg);
        if (iRet < 0) {
            ZYF_LOG("Failed to get msg");
            ZYF_ThreadSleep(1000);
        }
    }

}

static void prvInvokeGlobalCtors(void)
{
    extern void (*__init_array_start[])();
    extern void (*__init_array_end[])();

    size_t count = __init_array_end - __init_array_start;
    for (size_t i = 0; i < count; ++i)
        __init_array_start[i]();
}


int appimg_enter(void *param)
{
    AppUartInit();
    ZYF_LOG("application image enter, param 0x%x", param);

    prvInvokeGlobalCtors();

    ZYF_ThreadCreate("UdpClient_Example", UdpClient_Example, NULL, ZYF_PRIORITY_HIGH, 10*1024);
    return 0;
}

void appimg_exit(void)
{
    OSI_LOGI(0, "application image exit");
}

 

智云服
关注
专栏目录
TCP/UDP基础例程
01-02
最基础的TCP/UDP客户端和服务段代码配置。服务端和客户端均实现了发送接收，在Ubuntu平台测试通过。一共四个程序
c语言TCP/UDP程序例程
11-23
c语言的TCP和UDP 网络编程实例，希望对大家有所帮助
TCP/UDP编程实例详解
weixin_44863976的博客
10-15 369
一、基于UPD（面向无连接）的socket编程 步骤： 服务器端（接受端）程序 1、创建socket套接字 2、将套接字socket绑定到一个主机地址和端口上 3、等待接受数据 4、关闭套接字 客户端（发送端）程序 1、创建套接字socket 2、向服务器发送数据 3、关闭套接字 代码 二、基于TCP（面向连接）的socket编程 步骤： 服务器端程序 1、创建套接字socket 2、将套接...
TCP、UDP通信例程（C语言）
zhy的博客
09-13 1340
TCP、UDP通信例程（C语言） 1. 基于TCP的本地客户端、服务端信息交互实例（windows）（已验证） 2. 基于UDP的本地客户端、服务端信息交互实例（待验证）
5. M601 定时器的使用
haas506开发板
07-02 292
1 定时器相关 API 本文介绍的 API 可以参考 SDK 中 zyf_timer.h 文件。 1.1 ZYF_CreateTimer 此函数用来创建一个定时器，每个任务最多支持 10 个定时器。· 函数原型 ZYF_Timer_t *ZYF_CreateTimer(ZYF_TimeOutCallback callback, void* param);· 参数 callback：定时器的回调函数 param：用于传递用户参数。· 返回值 创建的计时器实例。内存不足时为 NULL，或参数无效 1.3
STM32F4上使用TCP和UDP的例程
07-16
在这个特定的项目中，我们关注的是如何在STM32F4上实现TCP（传输控制协议）和UDP（用户数据报协议）的通信功能，这通常涉及到网络编程和LWIP（Lightweight TCP/IP）协议栈的使用。 **TCP（传输控制协议）**是一种...
UDP.rar_UDP_linux udp例程_lwip udp例程_zhouligong
09-24
本文将深入探讨Linux环境下的UDP编程和LWIP UDP例程，以及周立功提供的以太网UDP例程，这对于初学者理解和掌握UDP协议非常有帮助。 一、UDP协议基础 1. **无连接性**：与TCP的面向连接不同，UDP不进行三次握手或四...
TCP、UDP客户端服务端例程代码
09-24
本资料提供了TCP和UDP的客户端和服务端的例程代码，这有助于理解这两种协议的工作原理以及如何在实际编程中应用它们。 TCP是一种面向连接的协议，它确保了数据的可靠传输，包括顺序传输、错误检查和流量控制。在TCP...
使用C#实现基于TCP和UDP协议的网络通信程序的基本示例
01-20
C#中使用TCP通信 TCP通信需要通信双方都在线，所以需要先启动服务端进行监听，客户端才能获得连接，服务端代码： static void Main(string[] args) { TcpClient client = null; NetworkStream stream = null; ...
网络编程——TCP实例
W31003的博客
01-13 1061
网络编程 java.net 包中提供了两种常见的网络协议的支持： TCP: TCP（Transmission Control Protocol，传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议，TCP层是位于IP层之上，应用层之下的中间层。TCP保障了两个应用程序之间的可靠通信。通常用于互联网协议，被称TCP/IP。 UDP：UDP（User Datagram Protocol，用户数据报协议），位于OSI模型的传输层。一个五连接的协议。提供了应用程序之间要发送的数据报。由于UDP缺乏可
VS2010 UDP协议client和server简单通信例程
03-03
UDP工程可以在VS2010编译通过，亲测是可以使用的。机器环境是windows10 x64。不清楚的可以参考：https://blog.csdn.net/armwind/article/details/87564919
PDP PPP SOCKET之间的关系
07-24
ppp 相当于链路层协议 socket 套接字，对 tcp/ip 协议的封装、应用 gprs 上网首先要设置 pdp，接着建立 ppp 连接，ppp 连接建立后，就可以进行 tcp/ip 传输了， 要进行 tcp/ip 数据传输，很多时候都采用 socket PDP：是 GPRS 连接的软硬件环境，指定 GPRS 连接的接入点APN，连接类型 IP 或 PPP
Linux网络编程 | TCP编程实例（也可以当做一个Ubuntu TCP通信的例程代码，发的也是字符串。）
诗筱涵的博客
09-08 1112
也可以当做一个Ubuntu TCP通信的例程代码，发的也是字符串。 转载自：https://mp.weixin.qq.com/s/sm5W8H6iWcVZVBhDTL244w Linux网络编程 | TCP编程实例 原创 安迪西 嵌入式攻城狮 2020-12-13 点击蓝字 关注我们 TCP编程实例 TCP编程分为客户端和服务器端两个部分，其中服务器端首先建立起socket，然后与本地端口进行绑定，接着开始接收客户端的连接请求并建立与它的连接，最后接收客户端发送的消息；客户端则.
[物联网]NB-IOT(RDA8909) udp收发数据
slimmm的博客
10-31 2469
熟悉linux网络编程的应该对这个很熟悉了，直接上代码ing： #include &quot;...&quot; #define DES_IPADDR &quot;xxx.xxx.xxx.xxx&quot; #define DES_PORT (xxxxx) CFW_TCPIP_SOCKET_ADDR dest_addr; uint8_t sockfd1 = -1; //sockfd #define M...
Zircon - Fuchsia 内核分析 - 启动(内核初始化)
热门推荐
ganyao939543405的博客
01-10 1万+
简介 前面已经介绍了 Zircon 内核启动的汇编代码部分，主要是一些 CPU 的初始化。 现在 prime CPU 已经来到了 C 世界的 lk_main() 函数 其他 CPU 也来到了 arm64_secondary_entry() 函数 lk_main lk_main() 是打开 Zircon 内核世界的大门，由 prime cpu 敲开，一眼望去你就会发现 lk_main 一行行代码目的...
TCP 通信流程详解（附有案例代码）
热爱数据库的小胖
07-20 1万+
4）阻塞等待，当有客户端发起连接，解除阻塞，接受客户端的连接，会得到一个和客户端通信的套接字（fd）（2）将这个监听文件描述符和本地的IP和端口绑定（IP和端口就是服务器的地址信息）UDP用户数据报协议，面向无连接，可以单播，多播，广播，面向数据报，不可靠。TCP传输控制协议，面向连接的，可靠的，基于字节流，仅支持单播传输。-客户端连接服务器的时候使用的就是这个IP和端口。（2）连接服务器，需要指定连接的服务器的IP和端口。（1）创建一个用于通信的套接字（fd）.........
9. M601 FTP的使用
haas506开发板
07-09 231
1 FTP API介绍 具体请参考 ftp_client.c 文件，里面是函数实现，可供使用的函数如下： struct ftp_client { char ipaddr[FTP_CLIENT_IPADDR_LEN]; uint32_t port; uint8_t contextid; uint8_t transmode; uint16_t rsptimeout; uint8_t ssltype; uint8_t sslctxid; ftp_client_cb upload; ftp_client_cb d
10. M601 HTTP例程介绍
haas506开发板
07-09 3777
#include <stdint.h> #include <stdbool.h> #include <stdio.h> #include <string.h> #include "zyf_app.h" #include "zyf_trace.h" #include "zyf_timer.h" #include "zyf_thread.h" #include "httpclient.h" #include "example_httpclient.h..
2. M601 GPIO 的使用
haas506开发板
07-02 312
1 GPIO 相关的数据结构和 API 本文介绍的数据结构和 API 可以参考 SDK 中 zyf_gpio.h 文件 1.1 GPIO 引脚枚举 typedef enum{ PINNAME_WAKE_IN = 0, PINNAME_AP_READY, PINNAME_W_DISABLE, PINNAME_NET_MODE, PINNAME_NET_STATUS, PINNAME_SD_INS_DET, PINNAME_PCM_IN, PINNAME_PCM_OUT, PINNAME_PCM_S
周立功UDP例程：Linux与LwIP下的UDP通信初学指南
在本例程中，周立功讲解了如何将UDP例程与lwIP协议栈结合使用，以及如何在嵌入式系统中部署和运行UDP服务端和客户端程序。学习者将通过这个例程了解到如何在资源有限的设备上实现网络通信，这对于开发物联网（IoT）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值