void ARNETWORK_Sender_SendPong (ARNETWORK_Sender_t *senderPtr, uint8_t *data, int dataSize)
{
ARNETWORK_IOBuffer_t *inputBufferPtrTemp;
eARNETWORK_ERROR err = ARNETWORK_OK;
inputBufferPtrTemp = senderPtr->inputBufferPtrMap[ARNETWORK_MANAGER_INTERNAL_BUFFER_ID_PONG];
err = ARNETWORK_IOBuffer_Lock (inputBufferPtrTemp);
if (err != ARNETWORK_OK) {
ARSAL_PRINT (ARSAL_PRINT_ERROR, ARNETWORK_SENDER_TAG, "ARNETWORK_IOBuffer_Lock() failed; error: %s", ARNETWORK_Error_ToString (err));
return;
}
ARNETWORK_IOBuffer_AddData (inputBufferPtrTemp, data, dataSize, NULL, NULL, 1);
ARNETWORK_IOBuffer_Unlock (inputBufferPtrTemp);
}
eARNETWORK_ERROR ARNETWORK_Receiver_CopyDataRecv (ARNETWORK_Receiver_t *receiverPtr, ARNETWORK_IOBuffer_t *outputBufferPtr, ARNETWORKAL_Frame_t *framePtr)
{
/** -- copy the data received to the output buffer -- */
/** local declarations */
eARNETWORK_ERROR error = ARNETWORK_OK;
int semError = 0;
int dataSize = 0;
int nbNew = ARNETWORK_IOBuffer_ShouldAcceptData (outputBufferPtr, framePtr->seq);
/** get the data size*/
dataSize = framePtr->size - offsetof (ARNETWORKAL_Frame_t, dataPtr);
/** if the output buffer can copy the data */
if (ARNETWORK_IOBuffer_CanCopyData (outputBufferPtr))
{
/** copy the data in the IOBuffer */
error = ARNETWORK_IOBuffer_AddData (outputBufferPtr, framePtr->dataPtr, dataSize, NULL, NULL, 1);
}
else
{
error = ARNETWORK_ERROR_BAD_PARAMETER;
ARSAL_PRINT (ARSAL_PRINT_ERROR, ARNETWORK_RECEIVER_TAG, "[%p] Error: output buffer can't copy data", receiverPtr);
}
if (error == ARNETWORK_OK)
{
/** Keep buffer "miss count" accurate */
outputBufferPtr->nbPackets++;
outputBufferPtr->nbNetwork += nbNew;
outputBufferPtr->seq = framePtr->seq;
/** post a semaphore to indicate data ready to be read */
semError = ARSAL_Sem_Post (&(outputBufferPtr->outputSem));
if (semError)
{
error = ARNETWORK_ERROR_SEMAPHORE;
}
#ifdef ENABLE_MONITOR_INCOMING_DATA
/* write 1 in eventfd to wake up consumer */
error = ARNETWORK_Receiver_WriteEventFd(receiverPtr, 1);
#endif
}
return error;
}
eARNETWORK_ERROR ARNETWORK_Receiver_ReturnACK (ARNETWORK_Receiver_t *receiverPtr, int id, uint8_t seq)
{
/** -- return an acknowledgement -- */
/** local declarations */
eARNETWORK_ERROR error = ARNETWORK_OK;
ARNETWORK_IOBuffer_t* ACKIOBufferPtr = receiverPtr->outputBufferPtrMap[ARNETWORK_Manager_IDOutputToIDAck (receiverPtr->networkALManager, id)];
if (ACKIOBufferPtr != NULL)
{
int isEmpty = ARNETWORK_RingBuffer_IsEmpty(ACKIOBufferPtr->dataDescriptorRBuffer);
error = ARNETWORK_IOBuffer_AddData (ACKIOBufferPtr, (uint8_t*) &seq, sizeof(seq), NULL, NULL, 1);
if (error == ARNETWORK_OK && isEmpty > 0)
{
ARNETWORK_Sender_SignalNewData (receiverPtr->senderPtr);
}
}
return error;
}
void* ARNETWORK_Sender_ThreadRun (void* data)
{
/** -- Manage the sending of the data on the sender' -- */
/** local declarations */
ARNETWORK_Sender_t *senderPtr = data;
int inputBufferIndex = 0;
ARNETWORK_IOBuffer_t *inputBufferPtrTemp = NULL; /**< pointer of the input buffer in processing */
eARNETWORK_ERROR error = ARNETWORK_OK;
int waitTimeMs = 0;
struct timespec now;
struct timespec sleepStart;
int sleepDurationMs = 0;
int timeDiffMs;
while (senderPtr->isAlive)
{
waitTimeMs = 500;
for (inputBufferIndex = 0; inputBufferIndex < senderPtr->numberOfInputBuff && waitTimeMs > 0; ++inputBufferIndex)
{
inputBufferPtrTemp = senderPtr->inputBufferPtrArr[inputBufferIndex];
error = ARNETWORK_IOBuffer_Lock(inputBufferPtrTemp);
switch (inputBufferPtrTemp->dataType)
{
// Low latency : no wait if any data available
case ARNETWORKAL_FRAME_TYPE_DATA_LOW_LATENCY:
if ((error == ARNETWORK_OK) &&
(!ARNETWORK_RingBuffer_IsEmpty (inputBufferPtrTemp->dataDescriptorRBuffer)))
{
waitTimeMs = 0;
}
break;
// Acknowledged buffer :
// - If waiting an ack, wait time = time before ack timeout
// - If not waiting an ack and not empty, wait time = time before next send
case ARNETWORKAL_FRAME_TYPE_DATA_WITH_ACK:
if (error == ARNETWORK_OK)
{
if (ARNETWORK_IOBuffer_IsWaitAck(inputBufferPtrTemp))
{
if (inputBufferPtrTemp->ackWaitTimeCount < waitTimeMs)
{
waitTimeMs = inputBufferPtrTemp->ackWaitTimeCount;
}
}
else if (!ARNETWORK_RingBuffer_IsEmpty (inputBufferPtrTemp->dataDescriptorRBuffer))
{
if (inputBufferPtrTemp->waitTimeCount < waitTimeMs)
{
waitTimeMs = inputBufferPtrTemp->waitTimeCount;
}
}
}
break;
// All non Ack buffers
// -
default:
if ((error == ARNETWORK_OK) &&
(!ARNETWORK_RingBuffer_IsEmpty (inputBufferPtrTemp->dataDescriptorRBuffer)))
{
if (inputBufferPtrTemp->waitTimeCount < waitTimeMs)
{
waitTimeMs = inputBufferPtrTemp->waitTimeCount;
}
}
break;
}
ARNETWORK_IOBuffer_Unlock(inputBufferPtrTemp);
}
// Force a minimum wait time after an ARNetworkAL Overflow
if ((senderPtr->hadARNetworkALOverflowOnPreviousRun > 0) &&
(waitTimeMs < ARNETWORK_SENDER_WAIT_TIME_ON_ARNETWORKAL_OVERFLOW_MS))
{
waitTimeMs = ARNETWORK_SENDER_WAIT_TIME_ON_ARNETWORKAL_OVERFLOW_MS;
}
senderPtr->hadARNetworkALOverflowOnPreviousRun = 0;
ARSAL_Time_GetTime(&sleepStart);
if (waitTimeMs > 0)
{
if (waitTimeMs < senderPtr->minimumTimeBetweenSendsMs)
{
waitTimeMs = senderPtr->minimumTimeBetweenSendsMs;
}
ARSAL_Mutex_Lock (&(senderPtr->nextSendMutex));
ARSAL_Cond_Timedwait (&(senderPtr->nextSendCond), &(senderPtr->nextSendMutex), waitTimeMs);
ARSAL_Mutex_Unlock (&(senderPtr->nextSendMutex));
}
/** Process internal input buffers */
ARSAL_Time_GetTime(&now);
sleepDurationMs = ARSAL_Time_ComputeTimespecMsTimeDiff (&sleepStart, &now);
ARSAL_Mutex_Lock (&(senderPtr->pingMutex));
timeDiffMs = ARSAL_Time_ComputeTimespecMsTimeDiff (&(senderPtr->pingStartTime), &now);
/* Send only new pings if ping function is active (min time > 0) */
if (senderPtr->minTimeBetweenPings > 0)
{
int maxWaitTime = senderPtr->minTimeBetweenPings;
if (ARNETWORK_SENDER_PING_TIMEOUT_MS > maxWaitTime)
{
maxWaitTime = ARNETWORK_SENDER_PING_TIMEOUT_MS;
}
/* Send new ping if :
* -> DT > minTimeBetweenPings AND we're not waiting for a ping
* -> DT > maxWaitTime
*/
if (((senderPtr->isPingRunning == 0) &&
(timeDiffMs > senderPtr->minTimeBetweenPings)) ||
(timeDiffMs > maxWaitTime))
{
if (timeDiffMs > ARNETWORK_SENDER_PING_TIMEOUT_MS)
{
senderPtr->lastPingValue = -1;
}
inputBufferPtrTemp = senderPtr->inputBufferPtrMap[ARNETWORK_MANAGER_INTERNAL_BUFFER_ID_PING];
error = ARNETWORK_IOBuffer_Lock (inputBufferPtrTemp);
if (error == ARNETWORK_OK) {
ARNETWORK_IOBuffer_AddData (inputBufferPtrTemp, (uint8_t *)&now, sizeof (now), NULL, NULL, 1);
ARNETWORK_IOBuffer_Unlock (inputBufferPtrTemp);
} else {
ARSAL_PRINT (ARSAL_PRINT_ERROR, ARNETWORK_SENDER_TAG, "ARNETWORK_IOBuffer_Lock() failed; error: %s", ARNETWORK_Error_ToString (error));
}
senderPtr->pingStartTime.tv_sec = now.tv_sec;
senderPtr->pingStartTime.tv_nsec = now.tv_nsec;
senderPtr->isPingRunning = 1;
}
}
ARSAL_Mutex_Unlock (&(senderPtr->pingMutex));
for (inputBufferIndex = 0; inputBufferIndex < senderPtr->networkALManager->maxIds ; inputBufferIndex++)
{
inputBufferPtrTemp = senderPtr->inputBufferPtrMap[inputBufferIndex];
if (inputBufferPtrTemp != NULL)
{
ARNETWORK_Sender_ProcessBufferToSend (senderPtr, inputBufferPtrTemp, (waitTimeMs > 0) ? sleepDurationMs : 0);
}
}
senderPtr->networkALManager->send(senderPtr->networkALManager);
}
return NULL;
}
