an00121: Using XMOS TCP/IP Library for UDP-based Networking on XCORE-200$$$Application Detailed Description$$$The application main() function£££doc/rst/an00121.html#the-application-main-function
For the UDP-based application example, the system comprises four tasks running
on the multicore microcontroller.
The tasks perform the following operations.
The RGMII task rgmii_ethernet_mac which handles RGMII/Ethernet traffic.
The RGMII config task rgmii_ethernet_mac_config which configures the RGMII task and
handles the Ethernet PHY. This task runs on a logical core and
communicates with the lib_xtcp stack.
The SMI task smi which handles the Serial Management Interface (SMI) for
the Ethernet PHY. This is used to configure the Ethernet PHY via the
ar8035_phy_driver task which manages the configuration of the PHY.
The XTCP server which handles the TCP/IP stack and provides the
interface to the application protocol. Either xtcp_uip or xtcp_lwip.
The UDP reflector application udp_reflect running in a single core.
These tasks communicate via the use of xC channels and interface
connections which allow data to be passed between
application code running on separate logical threads.
Below is the source code for the main function of this application,
which is taken from the source file main.xc
int main() {
xtcp_if i_xtcp[NUM_TCP_CLIENTS];
ethernet_cfg_if i_cfg[NUM_CFG_CLIENTS];
ethernet_rx_if i_rx[NUM_ETH_CLIENTS];
ethernet_tx_if i_tx[NUM_ETH_CLIENTS];
streaming chan c_rgmii_cfg;
smi_if i_smi;
par {
on tile[1] : rgmii_ethernet_mac(
i_rx, NUM_ETH_CLIENTS, i_tx, NUM_ETH_CLIENTS,
null, null, c_rgmii_cfg, rgmii_ports,
ETHERNET_DISABLE_SHAPER);
on tile[1].core[0] : rgmii_ethernet_mac_config(i_cfg, NUM_CFG_CLIENTS, c_rgmii_cfg);
on tile[1].core[0] : ar8035_phy_driver(i_smi, i_cfg[CFG_TO_PHY_DRIVER]);
on tile[1] : smi(i_smi, p_smi_mdio, p_smi_mdc);
#ifdef XTCP_STACK_LWIP
// TCP component
on tile[0] : xtcp_lwip(
i_xtcp, 1, null,
i_cfg[CFG_TO_TCP], i_rx[ETH_TO_TCP], i_tx[ETH_TO_TCP],
mac_address_phy, null, ipconfig);
#elif defined XTCP_STACK_UIP
// TCP component
on tile[0] : xtcp_uip(
i_xtcp, NUM_TCP_CLIENTS, null,
i_cfg[CFG_TO_TCP], i_rx[ETH_TO_TCP], i_tx[ETH_TO_TCP],
mac_address_phy, null, ipconfig);
#else
#error "Please define either XTCP_STACK_LWIP or XTCP_STACK_UIP in APP_COMPILER_FLAGS"
#endif
// The simple udp reflector thread
on tile[0] : udp_reflect(i_xtcp[TCP_TO_APP]);
}
return 0;
}
an00121: Using XMOS TCP/IP Library for UDP-based Networking on XCORE-200$$$Application Detailed Description$$$The UDP reflector function£££doc/rst/an00121.html#the-udp-reflector-function
The application code for receiving UDP packets of data from a network machine
and reflecting it back to the same machine is implemented in the file
udp_reflect.xc. Further, a fixed packet is sent periodically to a broadcast IP
address. The code performing these tasks is contained within the function
udp_reflect() which is shown in the following pages:
void udp_reflect(client xtcp_if i_xtcp) {
// The connection to the remote end we are responding to
xtcp_connection_t responding_connection;
// The connection out to the broadcast address
xtcp_connection_t broadcast_connection;
xtcp_ipaddr_t broadcast_addr = BROADCAST_ADDR;
timer tmr;
unsigned int time;
// The buffers for incoming data, outgoing responses and outgoing broadcast messages
char rx_buffer[RX_BUFFER_SIZE];
char tx_buffer[RX_BUFFER_SIZE];
char broadcast_buffer[RX_BUFFER_SIZE] = BROADCAST_MSG;
// The length of the response the thread is sending
int response_len;
// The length of the broadcast message the thread is sending
int broadcast_len;
// Maintain track of two connections. Initially they are not initialized
// which can be represented by setting their ID to -1
responding_connection.id = INIT_VAL;
broadcast_connection.id = INIT_VAL;
debug_printf("Configuration: xcore-200\n");
// Instruct server to listen and create new connections on the incoming port
i_xtcp.listen(INCOMING_PORT, XTCP_PROTOCOL_UDP);
tmr :> time;
In this segment of the code you can see the following.
The network connections, broadcast address and the buffers for holding the transmitted and received data are declared.
The XTCP server is instructed to listen and create new connections on the incoming port.
while (1) {
select {
// Respond to an event from the tcp server
case i_xtcp.packet_ready():
// A temporary variable to hold connections associated with an event
xtcp_connection_t conn;
// A temporary variable to hold the length of the packet received from get_packet()
unsigned data_len = 0;
i_xtcp.get_packet(conn, rx_buffer, RX_BUFFER_SIZE, data_len);
switch (conn.event) {
case XTCP_IFUP:
// Show the IP address of the interface
union x_ip_addr ipconfig;
i_xtcp.get_ipconfig(ipconfig.xtcp);
debug_printf("dhcp: %s\n", ipaddr_ntoa(&ipconfig.ip4));
// When the interface goes up, set up the broadcast connection.
// This connection will persist while the interface is up
// and is only used for outgoing broadcast messages
i_xtcp.connect(BROADCAST_PORT, broadcast_addr, XTCP_PROTOCOL_UDP);
break;
case XTCP_IFDOWN:
Other event handling follows the above code, then the repeated broadcast.
// This is the periodic case, it occurs every BROADCAST_INTERVAL timer ticks
case tmr when timerafter(time + BROADCAST_INTERVAL) :> void:
// A broadcast message can be sent if the connection is established
// and one is not already being sent on that connection
if (broadcast_connection.id != INIT_VAL) {
debug_printf("Sending broadcast message\n");
broadcast_len = strlen(broadcast_buffer);
i_xtcp.send(broadcast_connection, broadcast_buffer, broadcast_len);
}
time += BROADCAST_INTERVAL;
break;
You can see the following in the rest of the code.
