基于PLC1850平台的UDP报文接收与发送

一、UDP报文格式

　　源端口（2个字节）：发送报文的进程的16位端口号。

　　目的端口（2个字节）：目的设备上的接收进程的16位端口号。

　　长度（2个字节）：整个UDP数据报的长度，包括首都和数据字段。

　　校验和（2个字节）：提供错误检测功能的16位校验和，为可选项。

　　数据（可变长度）：要发送已封存应用报文。

2、UDP封装

3、UDP校验和计算

　　UDP校验和是所计算字段的16位反码和的反码，用IP数据报的某些字段组成一个伪首部，再与UDP报文合在一起计算校验和。因此，校验和是对伪首部、UDP首部和UDP数据的计算结果。如果需要，数据后面可能会填以数值为0的字节，使得数据字节数为两字节的整数倍。

4、发送UDP报文

　　通过java语言编写一个UDP数据报发送个LPC1850平台，程序代码如下：

 /**
  * @Author CFF
  * @Date:Created in 22:45 2019/4/20
  */
 import java.net.DatagramSocket;
 import java.net.DatagramPacket;
 import java.net.InetAddress;

  public class udp {
  public static void main(String[] args ) throws Exception {
          String content = "ABCDEFGHIJ";
          byte [] sentBuf = content .getBytes( "GBK" );
          DatagramSocket client = new DatagramSocket();
          InetAddress destinationAddress =InetAddress. getByName ( "192.168.1.190" );
          int port =2425;
          DatagramPacket sendPacket = new DatagramPacket( sentBuf , sentBuf.length , destinationAddress , port );
          client .send(sendPacket);
          client .close();
     }
 }

5、LPC1850代码

　　LPC1850 Internet初始化主函数，代码如下：

 #include "LPC18xx.h"
 #include "led.h"

 extern void taskEth (void);

 int main(void)
 {
     SystemInit();

     ledInit();
     SysTick_Config(GetCoreClock() / );

     taskEth();

     while ();
 }

 void SysTick_Handler(void)
 {
     static int counter = ;

     counter++;
     if (counter >= )
     {
         counter = ;
         ledRolling();
     }
 }

　　EthTask.c代码如下：

 #include <stdlib.h>
 #include <lpc18xx.h>
 #include "lpc18xx_emac.h"
 #include "lpc18xx_debug.h"

 extern uint32_t ipatol(char * p_input);
 extern void ipInit(uint8_t * mac, uint32_t ip);
 extern uint32_t ipRcvMacFrame(uint8_t * block, uint32_t frameLen);

 uint8_t gFlag = ;

 uint8_t g_emacBuffer[];

 uint8_t g_ethMac[];

 // EMAC½Ó¿Ú½ÓÊÕµ½Êý¾Ý£¬Í¨ÖªÓ¦ÓòãµÄ»Øµ÷º¯Êý¡£
 void ethReadReadyCb()
 {
     gFlag = ;
 }

 void taskEth (void)
 {
     uint32_t len;

     g_ethMac[] = 0x11;
     g_ethMac[] = 0x1F;
     g_ethMac[] = 0xE0;
     g_ethMac[] = 0x12;
     g_ethMac[] = 0x1E;
     g_ethMac[] = 0x0F;

     debugComInit();
     uartPrint("uart init\r\n");

     while (ethInit(ethReadReadyCb, g_ethMac) == );

     uartPrint("eth init complete\r\n");
     // ΪÒÔÌ«Íø½Ó¿ÚÖ¸¶¨MACµØÖ·ºÍIPµØÖ·
     ipInit(g_ethMac, 0xBE01A8C0);   // 192.168.1.190

     while ()
     {
         if (!gFlag)
         {
             continue;
         } 

         len = ethRead(g_emacBuffer, );
         if (len)
         {
             ipRcvMacFrame((uint8_t *)g_emacBuffer, len);
         }
         gFlag = ;
     }
 }

　　ip.c代码如下：

 #include <stdint.h>
 #include <string.h>
 #include <stdlib.h>
 #include "lpc18xx_emac.h"
 #include "lpc18xx_debug.h"
 //#include "shell.h"

 #define MAC_TYPE_IP   0x0800  //ipÀàÐÍ
 #define MAC_TYPE_ARP  0x0806  //macÀàÐÍ

 #define ARP_REQ 0x0001      //ARPÇëÇó
 #define ARP_RSP 0x0002        //ARPÏìÓ¦

 #define ICMP_ECHO_REQUEST    8                   // message is an echo request
 #define ICMP_ECHO_REPLY      0                   // message is an echo reply

 #define PROT_ICMP            1                   // Internet Control Message Protocol
 #define PROT_TCP             6                   // Transmission Control Protocol
 #define PROT_UDP             17                  // User Datagram Protocol

 #define DONT_FRAGMENT       0x4000 //fragment
 #define MORE_FRAGMENT       0x2000
 #define FRAGMENT_OFFSET     0x1FFF

 uint8_t * UDPChecksum;
 uint8_t g_ethMacAddr[];
 uint32_t g_ethIpAddr;

 uint32_t g_ipSndBuffer[];

 uint16_t g_ipIdentifier = ;

 // ½«×Ö´ÓÖ÷»úÐòתΪÍøÂçÐò
 uint16_t htons(uint16_t word)
 {
     return ((word >> ) & 0x00FF) | ((word << ) & 0xFF00);
 }

 // ½«×Ö´ÓÍøÂçÐòתΪÖ÷»úÐò
 uint16_t ntohs(uint16_t word)
 {
     return ((word >> ) & 0x00FF) | ((word << ) & 0xFF00);
 }

 uint16_t calcChecksum(uint16_t * buffer, uint32_t size)
 {
     uint32_t cksum;   

     cksum = ;   

     while (size > )
     {
         cksum += *buffer++;
         size -= sizeof(uint16_t);
     }   

     if (size)
     {
         cksum += *(uint8_t*)buffer;
     }   

     cksum = (cksum >> ) + (cksum & 0xffff);
     cksum += (cksum >>);     

     return (uint16_t)(~cksum);
 }

 // ·¢ËÍARPÏìÓ¦
 void arpSndRsp(uint32_t dstIp, uint8_t * mac)
 {
     uint8_t * block;
     //uint32_t blockLen;

     block = (uint8_t *)g_ipSndBuffer;

     memcpy(block, mac, );

     memcpy(block + , g_ethMacAddr, );

     // arp type
     *(uint16_t *)&block[] = htons(MAC_TYPE_ARP);

     // --------- ARP ²ã

     // Hardway type : Ethernet
     block[] = 0x00;
     block[] = 0x01;

     // ip type
     *(uint16_t *)&block[] = htons(MAC_TYPE_IP);

     // Hardway size
     block[] = 0x06;

     // Protocal size
     block[] = 0x04;

     // arp reply
     *(uint16_t *)&block[] = htons(ARP_RSP);

     // Sender MAC address
     memcpy(block + , g_ethMacAddr, );

     // Sender IP address
     *(uint32_t *)&block[] = g_ethIpAddr;

     // Target MAC address
     memcpy(block + , mac, );

     // Target IP address : 192.168.0.67
     block[] = (uint8_t)dstIp;
     block[] = (uint8_t)(dstIp >> );
     block[] = (uint8_t)(dstIp >> );
     block[] = (uint8_t)(dstIp >> );

     // 18¸öÌî³ä×Ö½Ú
     memset(block + , , );

     ethWrite((uint8_t *)block, );
 }

 void arpRcv(uint8_t * block, uint32_t frameLen)
 {
     uint32_t srcIp, dstIp;
     uint16_t msgType;

     msgType = ntohs(*(uint16_t *)(block+));   

     srcIp = (uint32_t)*(uint16_t *)(block + );
     srcIp|= ((uint32_t)*(uint16_t *)(block + )) << ;

     dstIp = (uint32_t)*(uint16_t *)(block + );
     dstIp|= ((uint32_t)*(uint16_t *)(block + )) << ;

     if (dstIp != g_ethIpAddr)
     {
         return;
     }

     if (msgType == ARP_REQ)
     {
         arpSndRsp(srcIp, block + );
     }
 }

 // ²»¹Ü³É¹¦Óë·ñ,¶¼ÓÉIP²ãÀ´ÊÍ·ÅÊý¾Ý°ü¡£
 void ipSnd(uint32_t dstIp, uint8_t * block, uint32_t len, uint8_t protoType, uint8_t * mac)
 {
     block-= ;
     len+= ;

     // ------------ IP ²ã

     block[] = 0x45;  // IP V4.  length 20(5*4)

     block[] = 0x00;  // service

     *(uint16_t *)&block[] = htons(len);

     *(uint16_t *)&block[] = htons((uint16_t)g_ipIdentifier++); // identification

     *(uint16_t *)&block[] = 0x0040; // flag and fragment

     block[] = ;  // TTL

     block[] = protoType;

     *(uint16_t *)&block[] = ; // УÑéºÍÏÈÌîÉÏ0

     *(uint16_t *)&block[] = (uint16_t)g_ethIpAddr;
     *(uint16_t *)&block[] = (uint16_t)(g_ethIpAddr >> );

     *(uint16_t *)&block[] = (uint16_t)dstIp;
     *(uint16_t *)&block[] = (uint16_t)(dstIp >> );

     *(uint16_t *)&block[] = calcChecksum((uint16_t *)block, );

     // ------------ MAC ²ã

     block-= ;
     len+= ;

     memcpy(block, mac , );

     memcpy(block + , g_ethMacAddr, );

     *(uint16_t *)&block[] = htons(MAC_TYPE_IP);

     if (len < )
     {
         // MACÖ¡Ì«¶Ì£¬²¹µ½×î¶Ì³¤¶È¡£
         memset(block + len, ,  - len);
         len = ;
     }

     ethWrite((uint8_t *)block, len);
 }

 // ICMPÊÕµ½ÇëÇó£¬ÐèÒª»ØÏìÓ¦¡£
 void icmpRcvRequest(uint32_t srcIp, uint8_t * icmp, uint32_t len, uint8_t * mac)
 {
     uint8_t * block;

     block = (uint8_t *)g_ipSndBuffer;

     // Áô³ö 14(MAC)+20(IP)¸ö×Ö½Ú
     block+=(+);

     // ----------- ICMP ²ã
     memcpy(block, icmp, len);

     block[] = ICMP_ECHO_REPLY;
     block[] = ;   // code

     *(uint16_t *)&block[] = ;  // УÑéºÍÏÈÌîÉÏ0

     *(uint16_t *)&block[] = calcChecksum((uint16_t *)block, len);

     ipSnd(srcIp, (void *)block, len, PROT_ICMP, mac);
 }
 void udpsend(uint32_t srcIp, uint8_t * udp, uint32_t len, uint8_t * mac)
 {
         uint8_t * block;
     int i;
       char sendData[]={'R','e','c','e','i','v','e','.','.','.'};
     block = (uint8_t *)g_ipSndBuffer;
     // Áô³ö 14(MAC)+20(IP)¸ö×Ö½Ú
     block+=(+);
         memcpy(block,udp,len);

         memcpy(block,udp+,);
         memcpy(block+,udp,);

         for(i=;i<;i++)
         {
             block[+i]=sendData[i];
         }

         *(uint16_t *)&block[] = htons(len);

         *(uint16_t *)&block[] = ;// УÑéºÍÏÈÌîÉÏ0

         *(uint16_t *)&UDPChecksum[]=htons(len);
         memcpy(UDPChecksum+,block,len);
         *(uint16_t *)&block[] = calcChecksum((uint16_t *)UDPChecksum, len+);
         uartPrint("Checksum:0x%04x\r\n",ntohs(*(uint16_t *)&block[]));
         ipSnd(srcIp, (void *)block, len, PROT_UDP, mac);
 }
 //udp½ÓÊÕ
 void udpRcv(uint32_t srcIp,uint8_t * udp, uint32_t len, uint8_t * mac)
 {
     int i;
     uartPrint("Recevie UDP message:\r\n");
     uartPrint("UDP Head:\r\n");
     uartPrint("Source Port:%d\r\n",ntohs(*(uint16_t *)(udp)));
     uartPrint("Destination Port:%d\r\n",ntohs(*(uint16_t *)(udp+)));
     uartPrint("Total Length:%d bytes\r\n",ntohs(*(uint16_t *)(udp+)));
     uartPrint("Checksum:0x%04x\r\n",ntohs(*(uint16_t *)(udp+)));
     uartPrint("UDP Data:\r\n");
     for(i=;i<len-;i++)
     {
         uartPrint("%c",udp[+i]);
     }
     uartPrint("\r\nsending UDP Data...\r\n");
     udpsend(srcIp, udp, len, mac);
     uartPrint("sent UDP Data.\r\n\r\n");
 }
 // ½ÓÊÕµ½IP°üµÄ´¦Àí
 void ipRcv(uint8_t * frame, uint32_t frameLen, uint8_t * mac)
 {
     uint16_t ipLength, flag;
     uint32_t srcIp, dstIp;

     if (frameLen < )
     {
         return;
     }

     if (calcChecksum((uint16_t *)frame, ))
     {
         // УÑéºÍ²»ÕýÈ·
         return;
     }

     if (frame[] != 0x45)
     {
         // IP VERSION ӦΪ4£¬³¤¶ÈӦΪ20£¨5¸öbit32£©×Ö½Ú¡£
         return;
     }

     // ignore Type Of Service

     ipLength = ntohs(*(uint16_t *)&frame[]);

     // ignore identification

     flag = ntohs(*(uint16_t *)&frame[]);

     if (!(flag & DONT_FRAGMENT))
     {
         // IP¿ÉÒÔ±»·Ö°ü£¬µ«ÎÒÃÇÖ»´¦Àí²»·Ö°üµÄÇé¿ö¡£

         if (flag & MORE_FRAGMENT)
         {
             // ·Ç×îºóµÄÒ»°ü£¬¶ªÆú¡£
             return;
         }

         // ÊÇ×îºóÒ»°ü¡£

         if (flag & FRAGMENT_OFFSET)
         {
             // ÊÇ×îºóÒ»°ü£¬ÇÒÆ«ÒÆÁ¿²»Îª0£¬Ò²¶ªÆú¡£
             return;
         }

         // ×îºóÒ»°ü£¬ÇÒÆ«ÒÆÁ¿Îª0£¬ÊÇÕû°ü£¬´¦Àí£¡
     }

     if (frameLen < ipLength)
     {
         return;
     }

     // ignore fragment offset

     //ttl = (uint32_t)frame[8];

     //srcIp = (frame[12] | (frame[13]<< 8) | (frame[14] << 16) | (frame[15] << 24));
     //dstIp = (frame[16] | (frame[17]<< 8) | (frame[18] << 16) | (frame[19] << 24));

     srcIp = *(uint16_t *)(frame + ) | ((uint32_t)*(uint16_t *)(frame + ) << );
     dstIp = *(uint16_t *)(frame + ) | ((uint32_t)*(uint16_t *)(frame + ) << );

     if ((dstIp != g_ethIpAddr) && (dstIp != 0x0100007F) && (dstIp != 0xffffffff))
     {
         return;
     }

 //    if (frame[9] != PROT_ICMP)
 //    {
 //        // ·ÇICMP°ü£¬Ôݲ»´¦Àí
 //        return;
 //    }
         if(frame[] == PROT_UDP)
         {
             //αͷ²¿
             UDPChecksum=(uint8_t *)g_ipSndBuffer;
             memcpy(UDPChecksum,frame+,);
             memcpy(UDPChecksum+,frame+,);
             UDPChecksum[]=;
             UDPChecksum[]=frame[];
             udpRcv(srcIp,frame + , ipLength - ,mac);
         }

     if (frame[] == ICMP_ECHO_REQUEST)
     {
         icmpRcvRequest(srcIp, frame + , ipLength - , mac);
     }
 }

 // IP²ã½ÓÊÕMAC²ãÊý¾ÝÖ¡µÄº¯Êý
 uint32_t ipRcvMacFrame(uint8_t * block, uint32_t frameLen)
 {
     //0xFFFF ¹ã²¥·½Ê½
     if ( ((*(uint16_t *)block == 0xFFFF) && (*(uint16_t *)(block + ) == 0xFFFF) && (*(uint16_t *)(block + ) == 0xFFFF))
        ||(memcmp(block, g_ethMacAddr, ) == ))
     {
         // ÊÇ·¢¸ø±¾»úµÄ¡£
         switch (ntohs(*(uint16_t *)(block+)))
         {
         case MAC_TYPE_ARP:
             arpRcv(block + , frameLen -);
             break;
         case MAC_TYPE_IP:
             ipRcv(block + , frameLen - , block+);
             break;
         default:
             break;
         }
     }
     return ;
 }

 void ipInit(uint8_t * mac, uint32_t ip)
 {
     memcpy(g_ethMacAddr, mac, );
     g_ethIpAddr = ip;
 }

　　通过上面代码，实现UDP报文接收与发送，实现UDP数据通讯。