单片机联网,UIP实现tcp/udp协议

最新推荐文章于 2024-04-29 08:52:51 发布
最新推荐文章于 2024-04-29 08:52:51 发布
阅读量1k 收藏 7
点赞数
分类专栏： 物联网 # 嵌入式以太网 文章标签： 嵌入式 以太网
原文链接：https://www.cnblogs.com/dengxiaojun/p/4375047.html
版权

原文地址：https://www.cnblogs.com/dengxiaojun/p/4375047.html

UIP是单片机界联网的一个很好地选择,移植这个库有点复杂,首先是第一步,网卡驱动要写好,使用的网卡芯片为ENC28J60,驱动可以再工程包里面找到

//配置网卡硬件，并设置MAC地址 
//返回值：0，正常；1，失败；
u8 tapdev_init(u8* macaddr)
{        
    u8 i,res=0;                      
    res=ENC28J60_Init((u8*)macaddr);    //初始化ENC28J60                      
    //把IP地址和MAC地址写入缓存区
     for (i = 0; i < 6; i++)uip_ethaddr.addr[i]=macaddr[i];  
    //指示灯状态:0x476 is PHLCON LEDA(绿)=links status, LEDB(红)=receive/transmit
     //PHLCON：PHY 模块LED 控制寄存器        
    ENC28J60_PHY_Write(PHLCON,0x0476);
    return res;    
}


//读取一包数据  
uint16_t tapdev_read(void)
{    
    return  ENC28J60_Packet_Receive(MAX_FRAMELEN,uip_buf);
}


//发送一包数据  
void tapdev_send(void)
{
    ENC28J60_Packet_Send(uip_len,uip_buf);
}

分别是初始化,读,写

这些驱动会在一个叫做uip_call的函数中用到,其次,要设置uip的时钟,这个时钟适用于arp表的更新的

#include "clock-arch.h"
#include "sys.h" 


//时钟驱动文件,

//uip时钟
extern u32 uip_timer;//uip 计时器，每10ms增加1.
/*---------------------------------------------------------------------------*/
clock_time_t
clock_time(void)
{
    return uip_timer; /* 10ms 单位 */     
}
u32 uip_timer=0;//uip 计时器，每10ms增加1.

//定时器6中断服务程序     
void TIM6_IRQHandler(void)
{     if (TIM_GetITStatus(TIM6, TIM_IT_Update) != RESET) //检查指定的TIM中断发生与否:TIM 中断源 
    {
      uip_timer++;//uip计时器增加1    
    } 
        TIM_ClearITPendingBit(TIM6, TIM_IT_Update  );  //清除TIMx的中断待处理位:TIM 中断源 
                                                      
}
 
//基本定时器6中断初始化
//这里时钟选择为APB1的2倍，而APB1为36M
//arr：自动重装值。
//psc：时钟预分频数
//这里使用的是定时器3!
void TIM6_Int_Init(u16 arr,u16 psc)
{    
    TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
    NVIC_InitTypeDef NVIC_InitStructure;

    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM6, ENABLE); //时钟使能

    TIM_TimeBaseStructure.TIM_Period = arr; //设置在下一个更新事件装入活动的自动重装载寄存器周期的值     计数到5000为500ms
    TIM_TimeBaseStructure.TIM_Prescaler =psc; //设置用来作为TIMx时钟频率除数的预分频值  10Khz的计数频率  
    TIM_TimeBaseStructure.TIM_ClockDivision = 0; //设置时钟分割:TDTS = Tck_tim
    TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  //TIM向上计数模式
    TIM_TimeBaseInit(TIM6, &TIM_TimeBaseStructure); //根据TIM_TimeBaseInitStruct中指定的参数初始化TIMx的时间基数单位
 
    TIM_ITConfig( TIM6,TIM_IT_Update|TIM_IT_Trigger,ENABLE);//使能定时器6更新触发中断
 
    TIM_Cmd(TIM6, ENABLE);  //使能TIMx外设
     
      NVIC_InitStructure.NVIC_IRQChannel = TIM6_IRQn;  //TIM3中断
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;  //先占优先级0级
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;  //从优先级3级
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道被使能
    NVIC_Init(&NVIC_InitStructure);  //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器                                  
}

定时器的定时长度取决于这个宏定义 

#ifndef __CLOCK_ARCH_H__
#define __CLOCK_ARCH_H__

typedef int clock_time_t;
#define CLOCK_CONF_SECOND 100

#endif /* __CLOCK_ARCH_H__ */

上面是100,也就是说定时器的长度应该是10MS

接下来是配置回调函数

//uip事件处理函数
//必须将该函数插入用户主循环,循环调用.
void uip_polling(void)
{
    u8 i;
    static struct timer periodic_timer, arp_timer;
    static u8 timer_ok=0;     
    if(timer_ok==0)//仅初始化一次
    {
        timer_ok = 1;
        timer_set(&periodic_timer,CLOCK_SECOND/2);  //创建1个0.5秒的定时器 
        timer_set(&arp_timer,CLOCK_SECOND*10);           //创建1个10秒的定时器 
    }
    uip_len=tapdev_read();    //从网络设备读取一个IP包,得到数据长度.uip_len在uip.c中定义
    if(uip_len>0)             //有数据
    {   
        //处理IP数据包(只有校验通过的IP包才会被接收) 
        if(BUF->type == htons(UIP_ETHTYPE_IP))//是否是IP包? 
        {
            uip_arp_ipin();    //去除以太网头结构，更新ARP表
            uip_input();       //IP包处理
            //当上面的函数执行后，如果需要发送数据，则全局变量 uip_len > 0
            //需要发送的数据在uip_buf, 长度是uip_len  (这是2个全局变量)            
            if(uip_len>0)//需要回应数据
            {
                uip_arp_out();//加以太网头结构，在主动连接时可能要构造ARP请求
                tapdev_send();//发送数据到以太网
            }
        }else if (BUF->type==htons(UIP_ETHTYPE_ARP))//处理arp报文,是否是ARP请求包?
        {
            uip_arp_arpin();
             //当上面的函数执行后，如果需要发送数据，则全局变量uip_len>0
            //需要发送的数据在uip_buf, 长度是uip_len(这是2个全局变量)
             if(uip_len>0)tapdev_send();//需要发送数据,则通过tapdev_send发送     
        }
    }else if(timer_expired(&periodic_timer))    //0.5秒定时器超时
    {
        timer_reset(&periodic_timer);        //复位0.5秒定时器 
        //轮流处理每个TCP连接, UIP_CONNS缺省是40个  
        for(i=0;i<UIP_CONNS;i++)
        {
            uip_periodic(i);    //处理TCP通信事件  
             //当上面的函数执行后，如果需要发送数据，则全局变量uip_len>0
            //需要发送的数据在uip_buf, 长度是uip_len (这是2个全局变量)
             if(uip_len>0)
            {
                uip_arp_out();//加以太网头结构，在主动连接时可能要构造ARP请求
                tapdev_send();//发送数据到以太网
            }
        }
#if UIP_UDP    //UIP_UDP 
        //轮流处理每个UDP连接, UIP_UDP_CONNS缺省是10个
        for(i=0;i<UIP_UDP_CONNS;i++)
        {
            uip_udp_periodic(i);    //处理UDP通信事件
             //当上面的函数执行后，如果需要发送数据，则全局变量uip_len>0
            //需要发送的数据在uip_buf, 长度是uip_len (这是2个全局变量)
            if(uip_len > 0)
            {
                uip_arp_out();//加以太网头结构，在主动连接时可能要构造ARP请求
                tapdev_send();//发送数据到以太网
            }
        }
#endif 
        //每隔10秒调用1次ARP定时器函数 用于定期ARP处理,ARP表10秒更新一次，旧的条目会被抛弃
        if(timer_expired(&arp_timer))
        {
            timer_reset(&arp_timer);
            uip_arp_timer();
        }
    }
}

这个函数是uip的灵魂,可以说全部的功能都是在这个函数里面实现的,然后定义网卡数据回调函数

//通信程序状态字(用户可以自己定义)  
enum
{
    STATE_CMD        = 0,    //命令接收状态 
    STATE_TX_TEST    = 1,    //连续发送数据包状态(速度测试)  
    STATE_RX_TEST    = 2        //连续接收数据包状态(速度测试)  
};    


//定义 uip_tcp_appstate_t 数据类型，用户可以添加应用程序需要用到
//成员变量。不要更改结构体类型的名字，因为这个类型名会被uip引用。
//uip.h 中定义的     struct uip_conn  结构体中引用了 uip_tcp_appstate_t          
struct tcp_appstate
{
    u8_t state;
    u8_t *textptr;
    int textlen;
};    

struct uip_appstate
{
    u8_t state;
    u8_t *textptr;
    int textlen;
};    

typedef struct tcp_appstate uip_tcp_appstate_t;
typedef struct uip_appstate uip_udp_appstate_t;

//TCP的回调
void tcp_appcall(void);
void tcp_client_appcall(void);    //tcp客户端的回调,PC是服务器
void tcp_server_appcall(void);    //tcp服务器的回调,pc是客户端


//UDP的回调
void udp_appcall(void);
void udp_send_appcall(void);
void udp_recv_appcall(void);

//定义应用程序回调函数 
#ifndef UIP_APPCALL
#define UIP_APPCALL tcp_appcall //定义回调函数为 tcp_demo_appcall 
#endif

#ifndef UIP_UDP_APPCALL
#define UIP_UDP_APPCALL udp_appcall //定义回调函数为 udp_demo_appcall 
#endif

UIP_UDP_APPCALL和UIP_APPCALL分别是TCP通讯和udp通讯的回调函数,实现的架构如下

//TCP应用接口函数(UIP_APPCALL)
//完成TCP服务(包括server和client)和HTTP服务
void tcp_appcall(void)
{    
      
    switch(uip_conn->lport)//本地监听端口对应的事件处理程序 
    {
        case HTONS(80):
//            httpd_appcall(); 
            break;
        case HTONS(1200):
            tcp_server_appcall(); 
            break;
        default:                          
            break;
    }            
    switch(uip_conn->rport)    //远程连接1400端口
    {
        case HTONS(1400):    //远程连接端口号
            tcp_client_appcall();
           break;
        default: 
           break;
    }   
}

void udp_appcall(void)
{

    switch(uip_udp_conn->lport)//本地监听端口1600 
    {
        case HTONS(1600):
            udp_recv_appcall(); 
            break;
        default:                          
            break;
    }            
    switch(uip_udp_conn->rport)    //远程连接1500端口,也就是数据发送端
    {
        case HTONS(1500):
            udp_send_appcall();
           break;
        default: 
           break;
    }   
}

可以看到,处理过程是分端口处理的,分别是四个,TCP客户端,服务器,UDP客户端,UDP服务器,分别说明

tcp_client_connect();                   //尝试连接到TCP Server端,用于TCP Client
u8 tcp_client_databuf[200];       //发送数据缓存

u8 tcp_client_sta;                //客户端状态
//[7]:0,无连接;1,已经连接;
//[6]:0,无数据;1,收到客户端数据
//[5]:0,无数据;1,有数据需要发送



//这是一个TCP 客户端应用回调函数。
//该函数通过UIP_APPCALL(tcp_demo_appcall)调用,实现Web Client的功能.
//当uip事件发生时，UIP_APPCALL函数会被调用,根据所属端口(1400),确定是否执行该函数。
//例如 : 当一个TCP连接被创建时、有新的数据到达、数据已经被应答、数据需要重发等事件
void tcp_client_appcall(void)
{          
     struct tcp_appstate *s = (struct tcp_appstate *)&uip_conn->appstate;
    if(uip_aborted())tcp_client_aborted();        //连接终止       
    if(uip_timedout())tcp_client_timedout();    //连接超时   
    if(uip_closed())tcp_client_closed();        //连接关闭       
     if(uip_connected())tcp_client_connected();    //连接成功        
    if(uip_acked())tcp_client_acked();            //发送的数据成功送达 
     //接收到一个新的TCP数据包 
    if (uip_newdata())
    {
        if((tcp_client_sta&(1<<6))==0)//还未收到数据
        {
            if(uip_len>199)
            {           
                ((u8*)uip_appdata)[199]=0;
            }            
            strcpy((char*)tcp_client_databuf,uip_appdata);                                   
            tcp_client_sta|=1<<6;//表示收到客户端数据
        }                  
    }else if(tcp_client_sta&(1<<5))//有数据需要发送
    {
        s->textptr=tcp_client_databuf;
        s->textlen=strlen((const char*)tcp_client_databuf);
        tcp_client_sta&=~(1<<5);//清除标记
    }  
    //当需要重发、新数据到达、数据包送达、连接建立时，通知uip发送数据 
    if(uip_rexmit()||uip_newdata()||uip_acked()||uip_connected()||uip_poll())
    {
        tcp_client_senddata();
    }                                               
}


//这里我们假定Server端的IP地址为:192.168.1.101
//这个IP必须根据Server端的IP修改.
//尝试重新连接
void tcp_client_connect()
{
    uip_ipaddr_t ipaddr;
    uip_ipaddr(&ipaddr,192,168,1,100);    //设置IP为192.168.1.103
    uip_connect(&ipaddr,htons(1400));     //端口为1400
}




//终止连接,回调函数                    
void tcp_client_aborted(void)
{
    tcp_client_sta&=~(1<<7);    //标志没有连接
    tcp_client_connect();        //尝试重新连接
    uip_log("tcp_client aborted!\r\n");//打印log
}


//连接超时,回调函数    
void tcp_client_timedout(void)
{
    tcp_client_sta&=~(1<<7);    //标志没有连接       
    uip_log("tcp_client timeout!\r\n");//打印log
}


//连接关闭,回调函数
void tcp_client_closed(void)
{
    tcp_client_sta&=~(1<<7);    //标志没有连接
    tcp_client_connect();        //尝试重新连接
    uip_log("tcp_client closed!\r\n");//打印log
}    


//连接建立,回调函数
void tcp_client_connected(void)
{ 
     tcp_client_sta|=1<<7;        //标志连接成功
      uip_log("tcp_client connected!\r\n");//打印log      
}


//发送的数据成功送达
void tcp_client_acked(void)
{                                                
    struct tcp_appstate *s=(struct tcp_appstate *)&uip_conn->appstate;
    s->textlen=0;//发送清零
    uip_log("tcp_client acked!\r\n");//表示成功发送         
}


//发送数据给服务端
void tcp_client_senddata(void)
{
    struct tcp_appstate *s = (struct tcp_appstate *)&uip_conn->appstate;
    //s->textptr:发送的数据包缓冲区指针
    //s->textlen:数据包的大小（单位字节）           
    if(s->textlen>0)uip_send(s->textptr, s->textlen);//发送TCP数据包     
}

TCP客户端的使用如上,服务器的使用如下

uip_listen(HTONS(1200));            //监听1200端口,用于TCP Server

监听端口,自然就是服务器了,回调如下

u8 tcp_server_databuf[200];       //发送数据缓存      
u8 tcp_server_sta;                //服务端状态
//[7]:0,无连接;1,已经连接;
//[6]:0,无数据;1,收到客户端数据
//[5]:0,无数据;1,有数据需要发送

        
//这是一个TCP 服务器应用回调函数。
//该函数通过UIP_APPCALL(tcp_demo_appcall)调用,实现Web Server的功能.
//当uip事件发生时，UIP_APPCALL函数会被调用,根据所属端口(1200),确定是否执行该函数。
//例如 : 当一个TCP连接被创建时、有新的数据到达、数据已经被应答、数据需要重发等事件
void tcp_server_appcall(void)
{
     struct tcp_appstate *s = (struct tcp_appstate *)&uip_conn->appstate;
    if(uip_aborted())tcp_server_aborted();        //连接终止
     if(uip_timedout())tcp_server_timedout();    //连接超时   
    if(uip_closed())tcp_server_closed();        //连接关闭       
     if(uip_connected())tcp_server_connected();    //连接成功        
    if(uip_acked())tcp_server_acked();            //发送的数据成功送达 
    //接收到一个新的TCP数据包 
    if (uip_newdata())//收到客户端发过来的数据
    {
        if((tcp_server_sta&(1<<6))==0)//还未收到数据
        {
            if(uip_len>199)
            {           
                ((u8*)uip_appdata)[199]=0;
            }            
            strcpy((char*)tcp_server_databuf,uip_appdata);                                   
            tcp_server_sta|=1<<6;//表示收到客户端数据
        }
    }else if(tcp_server_sta&(1<<5))//有数据需要发送
    {
        s->textptr=tcp_server_databuf;
        s->textlen=strlen((const char*)tcp_server_databuf);
        tcp_server_sta&=~(1<<5);//清除标记
    }   
    //当需要重发、新数据到达、数据包送达、连接建立时，通知uip发送数据 
    if(uip_rexmit()||uip_newdata()||uip_acked()||uip_connected()||uip_poll())
    {
        tcp_server_senddata();
    }
}    


//终止连接                    
void tcp_server_aborted(void)
{
    tcp_server_sta&=~(1<<7);    //标志没有连接
    uip_log("tcp_server aborted!\r\n");//打印log
}


//连接超时
void tcp_server_timedout(void)
{
    tcp_server_sta&=~(1<<7);    //标志没有连接
    uip_log("tcp_server timeout!\r\n");//打印log
}


//连接关闭
void tcp_server_closed(void)
{
    tcp_server_sta&=~(1<<7);    //标志没有连接
    uip_log("tcp_server closed!\r\n");//打印log
}


//连接建立
void tcp_server_connected(void)
{                                  
//    struct tcp_appstate *s = (struct tcp_appstate *)&uip_conn->appstate;
    //uip_conn结构体有一个"appstate"字段指向应用程序自定义的结构体。
    //声明一个s指针，是为了便于使用。
     //不需要再单独为每个uip_conn分配内存，这个已经在uip中分配好了。
    //在uip.c 中 的相关代码如下：
    //        struct uip_conn *uip_conn;
    //        struct uip_conn uip_conns[UIP_CONNS]; //UIP_CONNS缺省=10
    //定义了1个连接的数组，支持同时创建几个连接。
    //uip_conn是一个全局的指针，指向当前的tcp或udp连接。
    tcp_server_sta|=1<<7;        //标志连接成功
      uip_log("tcp_server connected!\r\n");//打印log
} 


//发送的数据成功送达
void tcp_server_acked(void)
{                                 
    struct tcp_appstate *s=(struct tcp_appstate *)&uip_conn->appstate;
    s->textlen=0;//发送清零
    uip_log("tcp_server acked!\r\n");//表示成功发送         
}


//发送数据给客户端
void tcp_server_senddata(void)
{
    struct tcp_appstate *s = (struct tcp_appstate *)&uip_conn->appstate;
    //s->textptr : 发送的数据包缓冲区指针
    //s->textlen ：数据包的大小（单位字节）           
    if(s->textlen>0)uip_send(s->textptr, s->textlen);//发送TCP数据包     
}

到此,TCP结束,另外,在UIP的初始化的时候要指明IP地址网关子网掩码子类的,如下

//配置IP地址
    uip_ipaddr(ipaddr, 192,168,1,103);    //设置本地设置IP地址
    uip_sethostaddr(ipaddr);                        
    uip_ipaddr(ipaddr, 192,168,1,1);     //设置网关IP地址(其实就是你路由器的IP地址)
    uip_setdraddr(ipaddr);                         
    uip_ipaddr(ipaddr, 255,255,255,0);    //设置网络掩码
    uip_setnetmask(ipaddr);

而UDP的通讯是无连接的,不分客户端和服务器,只分为接收端和发送端,接收端如下

u8 udp_recv_databuf[200];       //发送数据缓存      
u8 udp_recv_sta;                //客户端状态

void udp_recv_appcall(void)
{
//    struct uip_appstate *s = (struct uip_appstate *)&uip_udp_conn->appstate;
    
    //接收到一个新的udp数据包 
    if (uip_newdata())//收到客户端发过来的数据
    {
        if((udp_recv_sta&(1<<6))==0)//还未收到数据
        {
            if(uip_len>199)
            {           
                ((u8*)uip_appdata)[199]=0;
            }            
            strcpy((char*)udp_recv_databuf,uip_appdata);                                   
            udp_recv_sta|=1<<6;//表示收到客户端数据
        }
    }
    if(uip_poll())//udp空转
    {
        uip_log("udp_server uip_poll!\r\n");//打印log  
    }
}


//建立UDP接收链接
//建立UDP服务器需要将目标IP设置为全1 并对应端口为0,绑定相应的数据端口
void udp_recv_connect(void)
{
    uip_ipaddr_t ipaddr;
    static struct uip_udp_conn *c=0;    
    uip_ipaddr(&ipaddr,0xff,0xff,0xff,0xff);    //将远程IP设置为 255.255.255.255 具体原理见uip.c的源码
    if(c!=0)    //已经建立连接则删除连接
    {                            
        uip_udp_remove(c);
    }
    c = uip_udp_new(&ipaddr,0);     //远程端口为0
    if(c)
    {
        uip_udp_bind(c, HTONS(1600));
    }
}

其回调函数不发送数据,只接收数据,发送端如下

u8 udp_send_databuf[200];       //发送数据缓存    
u8 udp_send_sta;                //发送端状态


//这是一个udp 发送端应用回调函数。
//该函数通过UIP_APPCALL(udp_demo_appcall)调用,实现Web Client的功能.
//当uip事件发生时，UIP_APPCALL函数会被调用,根据所属端口(1400),确定是否执行该函数。
//例如 : 当一个udp连接被创建时、有新的数据到达、数据已经被应答、数据需要重发等事件
void udp_send_appcall(void)
{         
     struct uip_appstate *s = (struct uip_appstate *)&uip_udp_conn->appstate;
    
    if(uip_poll())//当前连接空闲轮训
    {    
        uip_log("udp_send uip_poll!\r\n");//打印log
        if(udp_send_sta&(1<<5))//需要发送数据
        { 
                s->textptr=udp_send_databuf;
                s->textlen=strlen((const char*)udp_send_databuf);
                udp_send_sta&=~(1<<5);//清除标记
                uip_send(s->textptr, s->textlen);//发送udp数据包    
                uip_udp_send(s->textlen);
        }

    }
    
}

//建立一个udp_client的连接
void udp_send_connect()
{
    uip_ipaddr_t ipaddr;
    static struct uip_udp_conn *c=0;    
    uip_ipaddr(&ipaddr,192,168,1,101);    //设置IP为192.168.1.101
    if(c!=0)
    {                            //已经建立连接则删除连接
        uip_udp_remove(c);
    }
    c = uip_udp_new(&ipaddr,htons(1500));     //端口为1500
    //发送端发送的数据端口为1500
}

只发送数据不接收数据

基本上到这里整个程序的框架就做好了,测试用的一段代码也贴上来

uip_polling();    //处理uip事件，必须插入到用户程序的循环体中
        if(tcp_client_tsta!=tcp_client_sta)//TCP Client状态改变
        {                                                             
            if(tcp_client_sta&(1<<7))
                LCD_ShowString(0,12,240,320,(u8*)"TCP Client Connected              ",LCD_BLACK);
            else
                LCD_ShowString(0,12,240,320,(u8*)"TCP Client Disconnected              ",LCD_BLACK);
            if(tcp_client_sta&(1<<6))    //收到新数据
            {
                LCD_ShowString(18,24,240,320,(u8*)"                                     ",LCD_BLACK);
                LCD_ShowString(18,24,240,320,(u8*)tcp_client_databuf,LCD_BLACK);
                printf("TCP Client RX:%s\r\n",tcp_client_databuf);//打印数据
                tcp_client_sta&=~(1<<6);        //标记数据已经被处理    
            }
            tcp_client_tsta=tcp_client_sta;
        }
        
        if(tcp_server_tsta!=tcp_server_sta)//TCP Server状态改变
        {        
            if(tcp_server_sta&(1<<7))
                LCD_ShowString(0,48,240,320,(u8*)"TCP Server Connected              ",LCD_BLACK);
            else 
                LCD_ShowString(0,48,240,320,(u8*)"TCP Server Disconnected           ",LCD_BLACK);
            if(tcp_server_sta&(1<<6))    //收到新数据
            {
                LCD_ShowString(18,60,240,320,(u8*)"                                     ",LCD_BLACK);
                LCD_ShowString(18,60,240,320,(u8*)tcp_server_databuf,LCD_BLACK);
                printf("TCP Server RX:%s\r\n",tcp_server_databuf);//打印数据
                tcp_server_sta&=~(1<<6);        //标记数据已经被处理    
            }
            tcp_server_tsta=tcp_server_sta;
        }
        if(udp_recv_sta & (1<<6))
        {
            LCD_ShowString(18,120,240,320,(u8*)"                                     ",LCD_BLACK);
            LCD_ShowString(18,120,240,320,(u8*)udp_recv_databuf,LCD_BLACK);
            udp_recv_sta =~(1<<6);//标记数据已经被处理
        }
        
        if(keyValue == KEY_LEFT)
        {
            if(tcp_client_sta&(1<<7))    //连接还存在
            {
                sprintf((char*)tcp_client_databuf,"TCP Client OK %d\r\n",tclientcnt);    
                LCD_ShowString(24,36,240,320,(u8*)"                                     ",LCD_BLACK);
                LCD_ShowString(24,36,240,320,(u8*)tcp_client_databuf,LCD_BLACK);
                tcp_client_sta|=1<<5;//标记有数据需要发送
                tclientcnt++;
                keyValue = 0;
            }
        }
        if(keyValue == KEY_RIGHT)
        {
            if(tcp_server_sta&(1<<7))    //连接还存在
            {
                sprintf((char*)tcp_server_databuf,"TCP Server OK %d\r\n",tserivcecnt);     
                LCD_ShowString(24,72,240,320,(u8*)"                                     ",LCD_BLACK);
                LCD_ShowString(24,72,240,320,(u8*)tcp_server_databuf,LCD_BLACK);
                tcp_server_sta|=1<<5;//标记有数据需要发送
                tserivcecnt++;
                keyValue = 0;
            }
        }
        if(keyValue == KEY_DOWN)
        {
            sprintf((char*)udp_send_databuf,"UDP SEND OK %d\r\n",usendcnt);
            LCD_ShowString(18,96,240,320,(u8*)"                                     ",LCD_BLACK);
            LCD_ShowString(18,96,240,320,(u8*)udp_send_databuf,LCD_BLACK);
            udp_send_sta |= 1<<5;//标记有数据需要发送
            keyValue = 0;
            usendcnt++;
        }
    }

工程下载地址

http://download.csdn.net/detail/dengrengong/8542905
Hello Jason
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
uip 协议栈详解及Tcp server及client测试
madao1234的博客
03-08 231
主要对uip协议栈的源码进行了详细的分析，同时进行了tcp server 和 tcp client的测试。文章中包含源码，相信对要使用uip协议栈的同学会有帮助！
一种uIP TCP/IP协议栈在51系列单片机上的实现
01-19
把这些设备接入Internet ,就需要考虑TCP/IP 网络协议的实现。 　51单片机是对目前所有兼容Intel 8031指令系统的单片机的统称。该系列单片机的始祖是Intel的8031单片机，后来随着Flash rom技术的发展，8031单片机...
STM32G0+EMW3080+阿里云飞燕平台实现单片机WiFi智能联网功能（三）EMW3080完成配网，EMW3080连接到阿里云飞平台
AnChenliang_1002的博客
06-22 1772
本节为该项目的第三节，主要任务是实现**EMW3080的配网功能**，也就是EMW3080连接到阿里云飞平台，并可以通过手机app给EMW3080发送指令，完成交互；
51单片机——网络
qq_54378635的博客
10-11 2542
51单片机网络
UIP协议一
Abner
08-18 795
UIP协议多用于嵌入式产品。      结合如CP2200芯片的网卡芯片，组成嵌入式网卡，硬件提供能力，UIP提供的是策略。      由上往下逐步封装用户的数据，如：      应用层----------传输层--------网络层------数据链路层-----物理层      应用数据---TCP封装头部---IP封装头部-----mac封装+尾部-----发送      任何的事
基于ENC28J60+uIP1.0+STM32的UDP Server实现，服务器主动发送数据的实现，几个关键的问题可算整明白了！
zl199203的博客
09-20 1536
ENC28J60，是一款SPI接口的以太网PHY+MAC芯片，实现以太网物理层和MAC层硬件通信。uIP是一个TCP/IP软件协议栈，实现TCP、UDP、ARP、ICMP等网络协议。STM32F103RCT6通过SPI接口与ENC28J60通讯，并移植uIP协议，实现一个小型的UDP服务器。
【STM32+cubemx】0022 HAL库开发：uIP的应用UDP、TCP通信（续上节）
小白白学电子
12-29 2663
上一节我们讲了uIP的移植过程，这一节我们使用移植好的uIP工程来实现UDP和TCP的通信。
uIP的udp实现
liuxizhen2009的专栏
10-18 5933
#ifndef __UDPDEMO_H__ #define __UDPDEMO_H__ //定义应用程序回调函数 #ifndef UIP_APPCALL #define UIP_APPCALL uip_appcall #endif #ifndef UIP_UDP_APPCALL #define UIP_UDP_
ESP32实例学习（六），ＵＰＤ通信的使用方法，遇到的问题，和对ＵＰＤ的初步理解
weixin_42619971的博客
08-16 3014
这期我们介绍ESP32ＵＤＰ通信的使用方法，UＤＰ大家可能有些陌生，但是他是在网络通信中的一种通信协议。学会这个功能，对我们今后在网络应用开发方面有一定的帮助。 一、什么是UDP UDP（User Data Protocol，用户数据报协议）是与TCP相对应的协议。它是面向非连接的协议，它不与对方建立连接，而是直接就把数据包发送过去！ UDP适用于一次只传送少量数据、对可靠性要求不高的应用环境。比如，我们经常使用“ping”命令来测试两台主机之间TCP/IP通信是否正常，其实“ping”命令的原.
使用udp协议实现服务器端程序时,uIP中UDP协议实现的改进
weixin_30788829的博客
08-09 428
摘 要： uIP作为一种广泛使用的轻量级嵌入式TCP/IP协议栈，其UDP协议的实现还不够完善，目前最新的1.0版本中仅实现了UDP客户端，尚没有实现UDP服务端。为此，对其进行了以下三方面的改进：UDP服务端口的初始化；接收到UDP客户端数据包后的端口号判断及匹配；UDP服务端发送报文后目的端口的释放。经过以上改进后，实验证明，uIP 1.0中的UDP实现了服务端的功能。关键词： uIP；嵌入...
单片机与DSP中的一种uIP TCP/IP协议栈在51系列单片机上的实现
10-23
把这些设备接入Internet ,就需要考虑TCP/IP 网络协议的实现。 　51单片机是对目前所有兼容Intel 8031指令系统的单片机的统称。该系列单片机的始祖是Intel的8031单片机，后来随着Flash rom技术的发展，8031单片机...
uIP中UDP协议实现的改进
10-24
uIP作为一种广泛使用的轻量级嵌入式TCP/IP协议栈，其UDP协议的实现还不够完善，目前最新的1.0版本中仅实现了UDP客户端，尚没有实现UDP服务端。为此，对其进行了以下三方面的改进：UDP服务端口的初始化；接收到UDP客户端数据包后的端口号判断及匹配；UDP服务端发送报文后目的端口的释放。经过以上改进后，实验证明，uIP 1.0中的UDP实现了服务端的功能。
浅谈uIP中UDP协议改进方案
01-19
UDP协议的全称是用户数据包协议，在网络中它与TCP协议一样用于处理，数据包。在OSI模型中，在第四层——传输层，处于IP协议的上一层。UDP有不提供数据包分组、组装和不能对数据包进行排序的缺点，也就是说，当报文发送之后，是无法得知其是否安全完整到达的。UDP用来支持那些需要在计算机之间传输数据的网络应用。包括网络视频会议系统在内的众多的客户/服务器模式的网络应用都需要使用UDP协议。UDP协议从问世至今已经被使用了很多年，虽然其初的光彩已经被一些类似协议所掩盖，但是即使是在今天，UDP仍然不失为一项非常实用和可行的网络传输层协议。 　　由于嵌入式系统的软硬件资源都较为有限，大多数嵌入式系统
uip udp应用
01-17
关于UIP中UDP的分析与应用例程，简单的介绍了UDP的使用。
uip中UDP协议实现的改进
05-30
该文档将uip协议栈中，UDP的实现进行了补充，将实现UDP协议，多端口问题。
uIP.rar_TCP/IP_协议栈
09-14
IP协议栈uIP源码，用于实现简单的tcp/IP协议栈
uIP_TCP／IP协议分析及其在嵌入式系统中的应用
04-05
这是一份对uIP协议的描述，详细介绍里面协议的内容与应用，不可错过
ok_什么是函数回调注册机制？实现的大致步骤介绍
最新发布
nuoyigui9889的博客
04-29 194
在函数回调注册机制中，通常会定义一个回调函数类型，用于指定回调函数的参数和返回值类型。函数回调注册机制的基本思想是：将一个函数的指针作为参数传递给另一个函数，然后在需要调用这个函数时，直接调用它的指针即可。函数回调注册机制是一种常见的编程技术，它允许我们在程序运行时动态地注册函数回调，并在适当的时候调用这些回调函数。嵌入式函数回调注册机制是一种常用的解耦技术，它通过在应用程序中注册回调函数的方式来实现模块之间的通信，从而使系统更加灵活、可扩展和易于维护。函数回调注册机制可以通过函数指针和回调函数来实现。
proteus仿真-基于stc89c52的智能风扇，手动（按键）控制、温控（DS18B20/DHT11）、语音控制。L9110/TB6612驱动DC电机
m0_72680791的博客
04-23 665
本篇文章只是考，全部代码。LCD1602显示，按键模拟，电机有三挡PWM0-50-100，ds18b20时间，语音控制模块集成芯片，网上有现成代码可以参考。
51单片机udp通讯
07-28
51单片机可以通过UDP通信进行数据的收发。UDP（User Datagram Protocol）是一种无连接的传输协议，它不需要建立连接，直接将数据包发送给目标设备。在UDP通信中，发送方将数据打包成数据包，包含目标IP地址和端口号，然后通过网络发送给接收方。接收方根据目标IP地址和端口号来接收数据包，并进行处理。UDP通信相比于TCP通信，具有传输速度快、实时性好的特点，但是不保证数据的可靠性和顺序性。因此，在使用UDP通信时，需要注意数据的丢失和乱序的可能性。\[1\] 在51单片机中，可以通过配置串口寄存器来实现UDP通信。首先，需要设置串口的波特率、数据位、停止位和校验位等参数，以确保发送方和接收方的串口设置一致。然后，通过编程将要发送的数据打包成UDP数据包，并指定目标IP地址和端口号。发送方将数据包通过串口发送出去。接收方通过串口接收数据包，并根据目标IP地址和端口号来判断是否接收该数据包。如果接收方需要回复数据，可以将回复的数据打包成UDP数据包，并通过串口发送给发送方。\[2\] 需要注意的是，51单片机的串口通信一般使用的是RS-232标准串口，最高速率为20kb/s，传送距离最大约为15米。因此，UDP通信在51单片机中适合用于本地设备之间的通信，而不适合远程通信。\[3\] #### 引用[.reference_title] - *1* [可运行在单片机上的UDP通讯协议的实现【上】](https://blog.csdn.net/weixin_39836726/article/details/115998869)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* *3* [51单片机之串口](https://blog.csdn.net/m0_52867657/article/details/130112840)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值