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_ProcessBufferToSend (ARNETWORK_Sender_t *senderPtr, ARNETWORK_IOBuffer_t *buffer, int hasWaitedMs) { eARNETWORK_MANAGER_CALLBACK_RETURN callbackReturn = ARNETWORK_MANAGER_CALLBACK_RETURN_DEFAULT; eARNETWORK_ERROR error = ARNETWORK_OK; /** lock the IOBuffer */ error = ARNETWORK_IOBuffer_Lock(buffer); if(error == ARNETWORK_OK) { /** decrement the time to wait */ if ((buffer->waitTimeCount > 0) && (hasWaitedMs > 0)) { if (hasWaitedMs > buffer->waitTimeCount) { buffer->waitTimeCount = 0; } else { buffer->waitTimeCount -= hasWaitedMs; } } if (ARNETWORK_IOBuffer_IsWaitAck (buffer)) { /** decrement the time to wait before considering as a timeout */ if ((buffer->ackWaitTimeCount > 0) && (hasWaitedMs > 0)) { if (hasWaitedMs > buffer->ackWaitTimeCount) { buffer->ackWaitTimeCount = 0; } else { buffer->ackWaitTimeCount -= hasWaitedMs; } } if (buffer->ackWaitTimeCount == 0) { ARSAL_PRINT(ARSAL_PRINT_ERROR, ARNETWORK_SENDER_TAG, "[%p] Timeout waiting for ack in buffer %d", senderPtr, buffer->ID); if (buffer->retryCount == 0) { /** if there are timeout and too sending retry ... */ ARSAL_PRINT (ARSAL_PRINT_DEBUG, ARNETWORK_SENDER_TAG, "!!! too retry !!!"); callbackReturn = ARNETWORK_Sender_TimeOutCallback (senderPtr, buffer); ARNETWORK_Sender_ManageTimeOut (senderPtr, buffer, callbackReturn); } else { /** if there is a timeout, retry to send the data */ ARSAL_PRINT(ARSAL_PRINT_ERROR, ARNETWORK_SENDER_TAG, "[%p] Will retry sending data of buffer %d", senderPtr, buffer->ID); error = ARNETWORK_Sender_AddToBuffer (senderPtr, buffer, 1); if (error == ARNETWORK_OK) { /** reset the timeout counter*/ buffer->ackWaitTimeCount = buffer->ackTimeoutMs; /** decrement the number of retry still possible is retryCount isn't -1 */ if (buffer->retryCount > 0) { -- (buffer->retryCount); } } } } } else if ((!ARNETWORK_RingBuffer_IsEmpty (buffer->dataDescriptorRBuffer)) && (buffer->waitTimeCount == 0)) { /** try to add the latest data of the input buffer in the sending buffer; callback with sent status */ if (ARNETWORK_Sender_AddToBuffer (senderPtr, buffer, 0) == ARNETWORK_OK) { buffer->waitTimeCount = buffer->sendingWaitTimeMs; switch (buffer->dataType) { case ARNETWORKAL_FRAME_TYPE_DATA_WITH_ACK: /** * reinitialize the input buffer parameters, * save the sequence wait for the acknowledgement, * and pass on waiting acknowledgement. */ buffer->isWaitAck = 1; buffer->ackWaitTimeCount = buffer->ackTimeoutMs; buffer->retryCount = buffer->numberOfRetry; break; case ARNETWORKAL_FRAME_TYPE_DATA: /** pop the data sent */ ARNETWORK_IOBuffer_PopData (buffer); break; case ARNETWORKAL_FRAME_TYPE_DATA_LOW_LATENCY: /** pop the data sent */ ARNETWORK_IOBuffer_PopData (buffer); break; case ARNETWORKAL_FRAME_TYPE_ACK: /** pop the acknowledgement sent */ ARNETWORK_IOBuffer_PopData (buffer); break; default: ARSAL_PRINT (ARSAL_PRINT_ERROR, ARNETWORK_SENDER_TAG, "[%p] dataType: %d unknow \n", senderPtr, buffer->dataType); break; } } } /** unlock the IOBuffer */ ARNETWORK_IOBuffer_Unlock(buffer); } }
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; }