eduardo1966 wrote on Monday, April 15, 2019:
Hi
I’ve written some code (see below) that implements a connect/disconnet/receiver using IP sockets and callback functions.
Somehow this ends in the Dummy_Handler()…
Essentialy a socket is created, a callback function is associated with this socket to process events Connect and Disconnect.
When a connect happens an accept is called and a receiving socket is created and associated with another callback function.
When a disconnect happens the receiving socket is closed.
When data arrives some information is printed.
ALl the communication between the callback functions and the main task is done through a message Queue.
Could someone validate this code? It may happen that the code is not using the FreeRTOS IP functions correctly…
I’ve placed several breakpoints and I cannot figure out what makes the code crash.
static void Callback_OnConnectDisconnect ( Socket_t xSocket, BaseType_t ulConnected )
{
Callback_Message_t Callback_Message;
Callback_Message.type = Callback_Connect_Disconnect;
Callback_Message.Connect_Disconnect.xSocket = xSocket;
Callback_Message.Connect_Disconnect.ulConnected = ulConnected;
if ( xQueueSend ( xQueue_Callback, (void*) &Callback_Message, 0 ) != pdPASS )
/* In case there is no space in the Queue,
* we should print something to the service port but we are inside FreeRTOS IP so it's better just increment a counter.
* The printing will take place in the main loop.
*/
xQueue_Callback_Errors++;
}
static BaseType_t Callback_OnReceive ( Socket_t xSocket, void * pData, size_t xLength )
{
Callback_Message_t Callback_Message;
Callback_Message.type = Callback_Receive;
Callback_Message.Receive.xSocket = xSocket;
Callback_Message.Receive.pData = pData;
Callback_Message.Receive.xLength = xLength;
if ( xQueueSend ( xQueue_Callback, (void*) &Callback_Message, 0 ) != pdPASS )
/* In case there is no space in the Queue,
* we should print something to the service port but we are inside FreeRTOS IP so it's better just increment a counter.
* The printing will take place in the main loop.
*/
xQueue_Callback_Errors++;
return 1;
}
void task_IPreceiver ( void *pvParameters )
{
Socket_t IPaccept_Socket, IPreceiver_Socket;
struct freertos_sockaddr xClient, xBindAddress;
const TickType_t xTimeOut = pdMS_TO_TICKS( 2000 );
const TickType_t xZeroTimeOut = 0;
socklen_t xSize = sizeof (struct freertos_sockaddr);
F_TCP_UDP_Handler_t Handler_OnConnectDisconnect;
SP_Printf ( "task_IPreceiver[] running..." );
/* Create a queue capable of containing 10 callback messages. */
xQueue_Callback = xQueueCreate ( 10, sizeof(Callback_Message_t) );
IPaccept_Socket = FreeRTOS_socket ( FREERTOS_AF_INET, FREERTOS_SOCK_STREAM, FREERTOS_IPPROTO_TCP );
if ( IPaccept_Socket == NULL )
SP_Printf_h ( "ERROR - task_IPaccept[] - FreeRTOS_socket failed" );
xBindAddress.sin_port = FreeRTOS_htons ( VDUI_SERVER_PORT );
FreeRTOS_bind ( IPaccept_Socket, &xBindAddress, sizeof(xBindAddress) );
FreeRTOS_listen ( IPaccept_Socket, IP_MAX_CONNECTIONS );
/* Install a callback for connection and disconnection events. */
Handler_OnConnectDisconnect.pxOnTCPConnected = Callback_OnConnectDisconnect;
FreeRTOS_setsockopt ( IPaccept_Socket, 0, FREERTOS_SO_TCP_CONN_HANDLER, (void *) &Handler_OnConnectDisconnect, sizeof(Handler_OnConnectDisconnect) );
//IPconnections_Initialise();
for (;;)
{
Callback_Message_t Callback_Message;
if ( xQueue_Callback_Errors != xQueue_Callback_Errors_prev )
{
SP_Printf ( "WARNING - task_IPreceiver[] - xQueue_Callback_Errors %d", xQueue_Callback_Errors );
xQueue_Callback_Errors_prev = xQueue_Callback_Errors;
}
if ( xQueueReceive ( xQueue_Callback, &Callback_Message, portMAX_DELAY ) )
{
switch ( Callback_Message.type )
{
case Callback_Connect_Disconnect:
{
F_TCP_UDP_Handler_t Handler_OnReceive;
if ( Callback_Message.Connect_Disconnect.ulConnected )
{
IPreceiver_Socket = FreeRTOS_accept ( IPaccept_Socket, &xClient, &xSize );
SP_Printf ( "Connection accepted %d", IPreceiver_Socket );
/* Install a callback for receiving TCP data. */
Handler_OnConnectDisconnect.pxOnTCPReceive = Callback_OnReceive;
FreeRTOS_setsockopt ( IPreceiver_Socket, 0, FREERTOS_SO_TCP_RECV_HANDLER, (void *) &Handler_OnReceive, sizeof(Handler_OnReceive) );
}
else
{
FreeRTOS_shutdown ( Callback_Message.Connect_Disconnect.xSocket, FREERTOS_SHUT_RDWR );
FreeRTOS_closesocket ( Callback_Message.Connect_Disconnect.xSocket );
SP_Printf ( "Connection closed %d", Callback_Message.Connect_Disconnect.xSocket );
}
}break;
case Callback_Receive:
{
static uint8_t Data [1000];
int32_t receivedData;
receivedData = FreeRTOS_recv ( Callback_Message.Receive.xSocket, Data/*pvBuffer*/, sizeof(Data)/*xBufferLength*/, 0/*xFlags*/ );
SP_Printf ( "Callback_Receive Callback_Message.Receive.xSocket %d Callback_Message.Receive.xLength %d receivedData %d",
Callback_Message.Receive.xSocket, Callback_Message.Receive.xLength, receivedData );
}break;
}
}
}
}