LWIP + RTOS - how to avoid netconn block the thread forever?
-
12-06-2021 - |
Question
When the LwIP netconn_accept()
or netconn_recv()
function is called, if we are using a RTOS, it will block the thread and wait for a connection until timeout or forever, depends on the setting of LWIP_SO_RCVTIME0
. The timeout duration is equal to the SYS_ARCH_TIMEOUT
.
The SYS_ARCH_TIMEOUT
is defined as 0xffffffff in the core include part of the LwIP stack, so I think it is not expected to be changed.
Actually, I want it to check if a connection is made, if not then it continue the thread. However, if I call netconn_accept()
, it will just block the thread and wait there forever (or a very long time)...I don't want to jsut change the define value of SYS_ARCH_TIMEOUT
because I need different timeout in different situation...
What is the good way to do that? Thanks.
Solution
Polling for TCP connection (or acceptance) is usually a bad practice. Consider spawning a new thread dedicated exclusively to the blocking netconn_accept() call.
I understand the limitations of using RTOSes, but spawning just one helper thread with minimal stack space shouldn't be a major problem.
I believe that implementing a solution to the classical Producer-Consumer problem is not that hard.
If you're talking about the FreeRTOS, it has all the tools needed - semaphores and threads.
OTHER TIPS
Don't use the blocking API at all. The lwIP stack provides a native, non-blocking, event-driven API, which is more efficient than blocking and does not require a blocking RTOS. A YouTube video shows (at http://youtu.be/MBk5wJ_8jEc) shows how this API has been used in a real-time system based on the QP state machine framework.
Make a new thread trying to make that connection. Aslong as it is not connected, put the thread in sleep for sometime so the RTOS can make a context switch! (switch to another task)
You can use the netconn_set_recvtimeout
function to set the timeout on the listen socket to something small, eg 1ms.
Eg. (Error handling left off new, bind, listen for simplicity)
struct netconn *conn = netconn_new(NETCONN_TCP);
if (conn)
{
if (netconn_bind(conn, IP_ADDR_ANY, 1025/*PORT_NUMBER*/) != ERR_OK)
{
return;
}
if (netconn_listen(conn) != ERR_OK)
{
return;
}
netconn_set_recvtimeout(conn, 1);
}
Then calls to accept will delay maximum 1ms:
struct netconn *newConn;
err_t result = netconn_accept(conn, &newConn);
if (result == ERR_OK)
{
// Handle the connected netconn here
}
else if (result == ERR_TIMEOUT)
{
// No pending connections
}
else
{
// A problem with the listen socket accepting the connection
}