Use ChatGPT to develop W7500S2E-D1 Hardware test Code which Deployed in the W5100S_EVB_PICO
Use ChatGPT to develop W7500S2E-D1 Hardware test Code which Deployed in the W5100S_EVB_PICO
COMPONENTSHardware components
WIZnet - W5100S-EVB-Pico
x 1
Software Apps and online services
Arduino - Arduino IDE
x 1
Arduino
PROJECT DESCRIPTION
I want to develop a hardware test Code for W7500S2E-D1 use ChatGPT.
I developed a S2E module with dual network ports, the name is W7500S2E-D1.
W7500S2E-D1 uses WIZNET's W7500 as the MCU, the onboard switch chip can forward serial data to the Ethernet, and has two Ethernet ports(RJ45) onboard, which supports ring network topology, and can be connected between every two modules through a network cable, without the need for Each module is connected to the switch using a network cable, which is convenient for setting up a field network.
Before this product is released, I need to do a detailed test on this module, and I need to design a hardware test program to monitor the operating status of the module. For example, how many modules can be supported on one link at the same time, whether there will be disconnection during operation, and so on.
W7500S2E has a setting software running on a PC, named "WIZS2E ConfigTool", which can discover devices by broadcasting, and can view and configure modules. Its interface is as follows：
The information for each device is as follows:
But if this program is deployed on a computer, the computer needs to be turned on 24 hours and cannot sleep.
My idea is to deploy the test program on the W5100S_EVB_PICO module.
This module has an Ethernet chip, which can monitor the running status of the module on the link by interacting with the data of the test network without the participation of the computer. View the status of each device on the web page.
My hardware test code is generated based on the suggestion of ChatGPT. I only made some modifications according to the characteristics of my device. The development process is as follows:
Q1:Under the arduino platform, using rp2040 and W5100S, how to send broadcast data packets
In this example, the setup() function initializes the Ethernet connection and starts the UDP communication. The loop() function continuously calls the sendBroadcastPacket() function every second.
The sendBroadcastPacket() function creates a UDP packet with the broadcast IP address and port number. It writes the data "Hello, world!" to the packet and sends it using the endPacket() function. The function also prints a message to the serial monitor indicating that the broadcast packet has been sent.
Upload this code to your Arduino board, open the serial monitor, and you should see the "Broadcast packet sent" message being printed every second. Make sure your Arduino board is connected to a network that allows broadcast traffic, and any device listening on the same network and port should receive the broadcast packet with the message "Hello, world!".
Yes, you can print out the received packets in the Arduino code. Here's an updated version of the code that includes receiving and printing out the packets:
In this updated code, the receivePackets() function is added to handle receiving and printing out the received packets. It checks if there is a UDP packet available using udp.parsePacket(). If a packet is available, it reads the packet data into the packetData array and prints it out on the serial monitor using Serial.println().
After sending the broadcast packet in the sendBroadcastPacket() function, the code calls the receivePackets() function to check if any packets have been received. If there is a received packet, it will be printed out on the serial monitor.
Upload this code to your Arduino board, open the serial monitor, and you should see both the "Broadcast packet sent" message and any received packets being printed out.
Certainly! Here's an updated version of the code that sends a broadcast packet, waits for one second, and then prints out all the data received within that one-second interval:
#include <SPI.h>
#include <Ethernet.h>
#include <EthernetUdp.h>
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 0, 100);
IPAddress subnet(255, 255, 255, 0);
EthernetUDP udp;
void setup() {
Ethernet.begin(mac, ip, subnet);
udp.begin(8888);
Serial.begin(9600);
}
void loop() {
sendBroadcastPacket();
delay(1000);
printReceivedPackets();
}
void sendBroadcastPacket() {
IPAddress broadcastIp(255, 255, 255, 255); // Broadcast address
uint16_t port = 1234; // Broadcast port
udp.beginPacket(broadcastIp, port);
udp.write("Hello, world!"); // Write your data to the packet
udp.endPacket();
Serial.println("Broadcast packet sent.");
}
void printReceivedPackets() {
unsigned long startTime = millis();
while (millis() - startTime < 1000) {
int packetSize = udp.parsePacket();
if (packetSize) {
char packetData[255];
int len = udp.read(packetData, sizeof(packetData) - 1);
if (len > 0) {
packetData[len] = '\0';
Serial.print("Received packet: ");
Serial.println(packetData);
}
}
}
}
In this updated code, the loop() function calls the printReceivedPackets() function after sending the broadcast packet. The printReceivedPackets() function uses a while loop that runs for one second (1000 milliseconds). It continuously checks for any received packets using udp.parsePacket() and prints out the received packet data if any packets are available.
Upload this code to your Arduino board, open the serial monitor, and you should see the "Broadcast packet sent" message. After one second, it will print out all the received packets within that one-second interval.
In this sample code, we define a structure named DataPacket to store the received data. The DataPacket structure contains the IP address of the sender, the port number of the sender, and the data itself.
In the printReceivedPackets() function, we use the udp.read() function to read the received data into the receivedPacket structure. Then, we print out the IP address of the sender, the port number of the sender, and the data through the Serial.println() function.
Upload this code to your Arduino board, open the serial monitor, you will see the sender's IP address, sender's port number and data printed out. Send broadcast data every second, then store the received data in the structure and print it.
And download and run the test use W5100S_EVB_PICO.
During the test, it was found that UDP broadcast packets can be sent and RCV normally, However, the test found that only RCV10 devices reply. After checking the error, it is found that the length of each data packet is 194 bytes, and the default receiving buffer size of W5100S is 2k, so it cannot receive more device information.
I modified the ETHERNET library of Arduino, and modified it in the Ethernet.h file as follows:
1.
//#define ETHERNET_LARGE_BUFFERS
change to:
#define ETHERNET_LARGE_BUFFERS
2.
#define MAX_SOCK_NUM 8
change to:
#define MAX_SOCK_NUM 2
In this way, the RX-BUFFER_SIZE of W5100S can be increased, so that the complete information of 16 devices can be received.
This time, the response messages from the current 16 W7500S2E-D1 modules on the link have been completely received. The message format is as follows:
The basic goal of hardware testing has been achieved, and it is now possible to search and view modules on the link. A further goal is to create an embedded web page where the module's information can be viewed using a browser.
The code you provided seems to be designed to send a broadcast packet and print the received packets within 500 milliseconds. It uses a structure S2E_DATA to store the received packet data.
Here's a breakdown of the code's functionality:
The setup() function initializes the serial communication, Ethernet module, server, and UDP socket. It also prints the server's IP address.
The setup() function initializes the serial communication, Ethernet module, server, and UDP socket. It also prints the server's IP address.
The loop() function repeatedly sends a broadcast packet, waits for 500 milliseconds, and then calls the printReceivedPackets() function.
The loop() function repeatedly sends a broadcast packet, waits for 500 milliseconds, and then calls the printReceivedPackets() function.
The sendBroadcastPacket() function sends a UDP packet containing the "SERH" discovery string to the broadcast IP address.
The sendBroadcastPacket() function sends a UDP packet containing the "SERH" discovery string to the broadcast IP address.
The printReceivedPackets() function reads the received packets and stores them in the s2eDataArray array. It checks if the MAC address of the received packet already exists in the array to avoid duplicate entries. If it's a new MAC address, the received packet data is stored in the array and printed.
The printReceivedPackets() function reads the received packets and stores them in the s2eDataArray array. It checks if the MAC address of the received packet already exists in the array to avoid duplicate entries. If it's a new MAC address, the received packet data is stored in the array and printed.
It's important to note that the s2eData structure has a fixed size of 192 bytes (sizeof(s2eData)). If the received packet size is larger than this, it may result in truncated data. Make sure the size of the received packet matches the structure size to ensure correct data parsing.
Please review the code, ensure it meets your requirements, and modify it as needed.
Q7: I want to build a webserver so that I can view the information of the s2eDataArray structure on the browser
In this modified code, a web server is created using the Ethernet library. The loop() function continuously checks for client connections. When a client connects, the processRequest() function is called to handle the request. The server responds to the client with HTML content displaying the information from the s2eDataArray structure.
The sendResponse() function constructs the HTML response to display the data. It iterates over each element in the s2eDataArray and prints the module number, device type, MAC address, and IP address. The response is sent back to the client.
To access the data in a browser, you can open the IP address of the Arduino Ethernet shield in the browser, for example: http://192.168.1.254. The browser will display the S2E data with the module numbers, device types, MAC addresses, and IP addresses.
Please note that this code assumes the presence of an Ethernet shield or module connected to your Arduino board. Make sure to adjust the MAC address and IP address variables (mac and localIP) according to your network configuration.
After running the test, enter the address in the browser: http://192.168.1.254, you can see the following device information.
In order to display interface optimization and beautification, continue to communicate with ChatGPT.
Q8: Put each array of html on the same line, and choose a different color for each type, change the title to WIZS2E ConfigTool Webpage, and the webpage can be refreshed automatically.
In the above modified code, I added <meta> a label and "http-equiv" set the use attribute to "refresh", and "content" the attribute was set to "5", which means that the page is automatically refreshed every 5 seconds. You can adjust the refresh interval according to your needs.
The display interface of the embedded web page changes to the following state：
Finally, The[ Run Time] display is added to the web page. as follows:
This has basically met my test requirements, the following is a test site photo, the network cable connects the adjacent W7500S2E-D1modules(Total 16pcs);
The hardware monitoring code is deployed on W5100S_EVB_PICO:
Software Apps and online services
