求教：如何用W5100实现上下位通讯？

葱拌豆腐

最近做一个项目需要通过以太网通讯，想问一下下位在接收是需不需要进行超时判断？如果哪位能提供一个简单的示例，感激不尽。

贴一下刚完成的接收函数（未测试）

1. //W5100 variable define
   
2. #define SF_WAIT_FRAME_HEAD                0X01
   
3. #define SF_WAIT_FRAME_LEN                        0X02
   
4. #define SF_WAIT_FRAME_CMD                        0X03
   
5. #define SF_WAIT_FRAME_DATA                0X04
   
6. #define SF_WAIT_FRAME_CHK                        0X05
   
7. 
   
8. boolean DataReceivedOK = false;
   
9. boolean alreadyConnected = false;
   
10. boolean EnthernetIsOK = false;
    
11. byte PacketBuffer[30];
    
12. unsigned int LocalPort = 8888;
    
13. 
    
14. byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
    
15. IPAddress ip(192, 168, 1, 177);
    
16. IPAddress gateway(192, 168, 1, 1);
    
17. IPAddress subnet(255, 255, 255, 0);
    
18. IPAddress Center(192, 168, 1, 113);
    
19. // Enter the IP address of the server you're connecting to:
    
20. IPAddress server(192, 168, 1, 113);
    
21. EthernetServer AlarmServer;
    
22. // Initialize the Ethernet client library
    
23. // with the IP address and port of the server
    
24. // that you want to connect to (port 23 is default for telnet;
    
25. // if you're using Processing's ChatServer, use  port 10002):
    
26. EthernetClient AlarmClient;
    
27. byte ReceiveBuf[100];
    
28. byte SendBuf[]={0xaa,0x03,0x05,0x28,0x11,0xbb};
    
29. String str="";
    
30. void setup()
    
31. {
    
32.         // start the Ethernet connection:
    
33.         Ethernet.begin(mac, ip);
    
34.         // Open serial communications and wait for port to open:
    
35.         Serial.begin(9600);
    
36.         // if you get a connection, report back via serial:
    
37.         if (AlarmClient.connect(server, 9050))
    
38.         {
    
39.                 Serial.println("connected");
    
40.         }
    
41.         else
    
42.         {
    
43.                 // if you didn't get a connection to the server:
    
44.                 Serial.println("connection failed");
    
45.         }
    
46. }
    
47. 
    
48. void loop()
    
49. {
    
50.         // if there are incoming bytes available
    
51.         // from the server, read them and print them:
    
52.         if (client.available())
    
53.         {
    
54.                
    
55.                 /*static char sn=0;
    
56.                 static char len=0;*/
    
57.                 char c = client.read();
    
58.                 Serial.println(c);
    
59.                 if (c == 0xaa)
    
60.                 {
    
61.                         Serial.println("Get Frame HEAD 0xAA");
    
62.                 }
    
63.                 else if (c == 0xbb)
    
64.                 {
    
65.                         Serial.println("Get Frame Length 0xBB");
    
66.                 }
    
67.                 else
    
68.                 {
    
69.                         Serial.print("Get other Byte value:");
    
70.                         Serial.println(c);
    
71.                 }
    
72. 
    
73.         }
    
74. 
    
75.         // as long as there are bytes in the serial queue,
    
76.         // read them and send them out the socket if it's open:
    
77.         while (Serial.available() > 0)
    
78.         {
    
79.                 char inChar = Serial.read();
    
80.                 if (client.connected())
    
81.                 {
    
82.                         client.print(inChar);
    
83.                 }
    
84.         }
    
85. 
    
86.         for(int i=0;i<6;i++)
    
87.         {
    
88.                 client.write(SendBuf[i]);
    
89.         }
    
90.         delay(1000);
    
91.         // if the server's disconnected, stop the client:
    
92.         if (!client.connected())
    
93.         {
    
94.                 Serial.println();
    
95.                 Serial.println("disconnecting.");
    
96.                 client.stop();
    
97.                 // do nothing:
    
98.                 while (true);
    
99.         }
    
100. }
     
101. 
     
102. void EthernetInit()
     
103. {
     
104.         Ethernet.begin(mac, ip, gateway, subnet);
     
105.         AlarmServer.begin();
     
106. }
     
107. 
     
108. void AlarmServerStart()
     
109. {
     
110.         EthernetClient client = AlarmServer.available();
     
111. 
     
112.         if (client)
     
113.         {
     
114.                 if (!alreadyConnected)
     
115.                 {
     
116.                         client.flush();
     
117.                         client.println("Hello,client!");
     
118.                         alreadyConnected = true;
     
119.                 }
     
120. 
     
121.                 if (client.available()>0)
     
122.                 {
     
123.                         char thisChar = client.read();
     
124.                         AlarmServer.write(thisChar);
     
125.                 }
     
126.         }
     
127. }
     
128. //连接server
     
129. void AlarmClientStart()
     
130. {
     
131.         if (AlarmClient.connected())
     
132.         {
     
133.                 EnthernetIsOK = true;
     
134.                 Serial.println("Connected");
     
135.         }
     
136.         else
     
137.         {
     
138.                 EnthernetIsOK = false;
     
139.                 AlarmClient.connect(Center, LocalPort);
     
140.         }
     
141. }
     
142. //读取一个字节
     
143. byte AlarmClientRead()
     
144. {
     
145.         byte c;
     
146.         if (AlarmClient.available())
     
147.         {
     
148.                 c = AlarmClient.read();
     
149.                 FrameStateMachine(c);
     
150.                 //Serial.print(c);
     
151.         }
     
152.         return c;
     
153. }
     
154. //接收报文状态机
     
155. /*
     
156. 报文格式：0xAA   len    cmd    data  check
     
157. 0xaa : 报文头
     
158. len：data区数据长度，不超过20
     
159. cmd：命令字，一个byte
     
160. data：len个byte
     
161. check：校验字，等于len^cmd^data
     
162. */
     
163. void FrameStateMachine(byte c)
     
164. {
     
165.         static byte FSState = SF_WAIT_FRAME_HEAD;
     
166.         static byte len = 0;
     
167.         static byte CheckSum = 0;
     
168.         //static byte TimeOutCounts = 0;//超时计数
     
169. 
     
170.         switch (FSState)
     
171.         {
     
172.         case SF_WAIT_FRAME_HEAD:
     
173.                 CheckSum = 0;
     
174.                 len = 0;
     
175.                 if (c == 0xAA)
     
176.                 {
     
177.                         PacketBuffer[0] = c;
     
178.                         FSState = SF_WAIT_FRAME_LEN;
     
179.                 }
     
180.                 break;
     
181.         case SF_WAIT_FRAME_LEN:
     
182.                 if (c <= 0x14 && c >= 0x00)                                                                                                //数据长度不能大于20个字节
     
183.                 {
     
184.                         PacketBuffer[1] = c;
     
185.                         CheckSum = CheckSum^PacketBuffer[1];
     
186.                         FSState = SF_WAIT_FRAME_CMD;
     
187.                 }
     
188.                 else
     
189.                 {
     
190.                         FSState = SF_WAIT_FRAME_HEAD;
     
191.                 }
     
192.                 break;
     
193.         case SF_WAIT_FRAME_CMD:
     
194.                 if (c>0x01 && c<0x40)                                                                //command word is between 0x01 and 0x40
     
195.                 {
     
196.                         if (PacketBuffer[1]>0)
     
197.                         {
     
198.                                 PacketBuffer[2] = c;
     
199.                                 CheckSum = CheckSum^PacketBuffer[2];
     
200.                                 FSState = SF_WAIT_FRAME_DATA;
     
201.                         }
     
202.                         else
     
203.                         {
     
204.                                 PacketBuffer[2] = c;
     
205.                                 CheckSum = CheckSum^PacketBuffer[2];
     
206.                                 FSState = SF_WAIT_FRAME_CHK;                                        //如果数据长度为0，则进入校验值接收
     
207.                         }
     
208.                 }
     
209.                 else
     
210.                 {
     
211.                         FSState = SF_WAIT_FRAME_HEAD;
     
212.                 }
     
213.                 break;
     
214.         case SF_WAIT_FRAME_DATA:
     
215.                 PacketBuffer[2 + len] = c;
     
216.                 CheckSum = CheckSum^ c;
     
217.                 len++;
     
218.                 if (len>PacketBuffer[1])
     
219.                 {
     
220.                         FSState = SF_WAIT_FRAME_CHK;
     
221.                 }
     
222.                 break;
     
223.         case SF_WAIT_FRAME_CHK:
     
224.                 if (c == CheckSum)
     
225.                 {
     
226.                         FSState = SF_WAIT_FRAME_HEAD;
     
227.                         DataReceivedOK = true;
     
228.                 }
     
229.                 else
     
230.                 {
     
231.                         FSState = SF_WAIT_FRAME_HEAD;
     
232.                 }
     
233.                 break;
     
234.         default:
     
235.                 FSState = SF_WAIT_FRAME_HEAD;
     
236.                 break;
     
237.         }
     
238. }
     

复制代码