uint8 Com_ReceiveSignal(Com_SignalIdType SignalId, void* SignalDataPtr) {
VALIDATE_SIGNAL(SignalId, 0x0b, E_NOT_OK);
DEBUG(DEBUG_LOW, "Com_ReceiveSignal: SignalId %d\n", SignalId);
const ComSignal_type * Signal = GET_Signal(SignalId);
const ComIPdu_type *IPdu = GET_IPdu(Signal->ComIPduHandleId);
uint8 r = E_OK;
const void* pduDataPtr = 0;
if (IPdu->ComIPduSignalProcessing == DEFERRED && IPdu->ComIPduDirection == RECEIVE) {
pduDataPtr = IPdu->ComIPduDeferredDataPtr;
} else {
if (isPduBufferLocked(getPduId(IPdu))) {
r = COM_BUSY;
}
pduDataPtr = IPdu->ComIPduDataPtr;
}
Com_ReadSignalDataFromPduBuffer(
SignalId,
FALSE,
SignalDataPtr,
pduDataPtr);
return r;
}
BufReq_ReturnType Com_CopyRxData(PduIdType PduId, const PduInfoType* PduInfoPtr, PduLengthType* RxBufferSizePtr) {
/* !req COM782 */ /* If pdu group stopped -> return BUFREQ_E_NOT_OK */
imask_t state;
BufReq_ReturnType r = BUFREQ_OK;
uint8 remainingBytes;
boolean sizeOk;
boolean dirOk;
boolean lockOk;
if(COM_INIT != initStatus) {
DET_REPORTERROR(COM_COPYRXDATA_ID, COM_E_UNINIT);
return BUFREQ_NOT_OK;
}
Irq_Save(state);
/* @req COM658 */ /* Interrupts disabled */
remainingBytes = GET_IPdu(PduId)->ComIPduSize - Com_BufferPduState[PduId].currentPosition;
sizeOk = remainingBytes >= PduInfoPtr->SduLength;
dirOk = GET_IPdu(PduId)->ComIPduDirection == RECEIVE;
lockOk = isPduBufferLocked(PduId);
if (dirOk && lockOk && sizeOk) {
memcpy((void *)((uint8 *)GET_ArcIPdu(PduId)->ComIPduDataPtr+Com_BufferPduState[PduId].currentPosition), PduInfoPtr->SduDataPtr, PduInfoPtr->SduLength);
Com_BufferPduState[PduId].currentPosition += PduInfoPtr->SduLength;
*RxBufferSizePtr = GET_IPdu(PduId)->ComIPduSize - Com_BufferPduState[PduId].currentPosition;
} else {
r = BUFREQ_NOT_OK;
}
Irq_Restore(state);
return r;
}
Std_ReturnType Com_SendSignalGroup(Com_SignalGroupIdType SignalGroupId) {
//#warning Com_SendSignalGroup should be performed atomically. Should we disable interrupts here?
const ComSignal_type * Signal = GET_Signal(SignalGroupId);
Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(Signal->ComIPduHandleId);
const ComIPdu_type *IPdu = GET_IPdu(Signal->ComIPduHandleId);
if (isPduBufferLocked(getPduId(IPdu))) {
return COM_BUSY;
}
// Copy shadow buffer to Ipdu data space
imask_t irq_state;
Irq_Save(irq_state);
Com_CopySignalGroupDataFromShadowBufferToPdu(SignalGroupId);
// If the signal has an update bit. Set it!
if (Signal->ComSignalArcUseUpdateBit) {
SETBIT(IPdu->ComIPduDataPtr, Signal->ComUpdateBitPosition);
}
// If signal has triggered transmit property, trigger a transmission!
if (Signal->ComTransferProperty == TRIGGERED) {
Arc_IPdu->Com_Arc_TxIPduTimers.ComTxIPduNumberOfRepetitionsLeft = IPdu->ComTxIPdu.ComTxModeTrue.ComTxModeNumberOfRepetitions + 1;
}
Irq_Restore(irq_state);
return E_OK;
}
uint8 Com_SendSignal(Com_SignalIdType SignalId, const void *SignalDataPtr) {
VALIDATE_SIGNAL(SignalId, 0x0a, E_NOT_OK);
// Store pointer to signal for easier coding.
const ComSignal_type * Signal = GET_Signal(SignalId);
const ComIPdu_type *IPdu = GET_IPdu(Signal->ComIPduHandleId);
Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(Signal->ComIPduHandleId);
if (isPduBufferLocked(getPduId(IPdu))) {
return COM_BUSY;
}
//DEBUG(DEBUG_LOW, "Com_SendSignal: id %d, nBytes %d, BitPosition %d, intVal %d\n", SignalId, nBytes, signal->ComBitPosition, (uint32)*(uint8 *)SignalDataPtr);
imask_t irq_state;
Irq_Save(irq_state);
Com_WriteSignalDataToPdu(Signal->ComHandleId, SignalDataPtr);
// If the signal has an update bit. Set it!
if (Signal->ComSignalArcUseUpdateBit) {
SETBIT(IPdu->ComIPduDataPtr, Signal->ComUpdateBitPosition);
}
/*
* If signal has triggered transmit property, trigger a transmission!
*/
if (Signal->ComTransferProperty == TRIGGERED) {
Arc_IPdu->Com_Arc_TxIPduTimers.ComTxIPduNumberOfRepetitionsLeft = IPdu->ComTxIPdu.ComTxModeTrue.ComTxModeNumberOfRepetitions + 1;
}
Irq_Restore(irq_state);
return E_OK;
}
uint8 Com_ReceiveDynSignal(Com_SignalIdType SignalId, void* SignalDataPtr, uint16* Length) {
const ComSignal_type * Signal = GET_Signal(SignalId);
Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(Signal->ComIPduHandleId);
const ComIPdu_type *IPdu = GET_IPdu(Signal->ComIPduHandleId);
imask_t state;
uint8 startFromPduByte;
uint8 r = E_OK;
const void* pduDataPtr;
Com_SignalType signalType = Signal->ComSignalType;
if (signalType != UINT8_DYN) {
return COM_SERVICE_NOT_AVAILABLE;
}
Irq_Save(state);
if (*Length > Arc_IPdu->Com_Arc_DynSignalLength) {
*Length = Arc_IPdu->Com_Arc_DynSignalLength;
}
startFromPduByte = (Signal->ComBitPosition) / 8;
pduDataPtr = 0;
if (IPdu->ComIPduSignalProcessing == DEFERRED && IPdu->ComIPduDirection == RECEIVE) {
pduDataPtr = IPdu->ComIPduDeferredDataPtr;
} else {
if (isPduBufferLocked(getPduId(IPdu))) {
r = COM_BUSY;
}
pduDataPtr = IPdu->ComIPduDataPtr;
}
memcpy((void*)SignalDataPtr, (void*)((uint8*)pduDataPtr + startFromPduByte), *Length);
Irq_Restore(state);
return r;
}
Std_ReturnType Com_Internal_TriggerIPduSend(PduIdType ComTxPduId) {
PDU_ID_CHECK(ComTxPduId, 0x17, E_NOT_OK);
#if PDUR_COM_SUPPORT == STD_OFF
return E_NOT_OK;
#else
const ComIPdu_type *IPdu = GET_IPdu(ComTxPduId);
Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(ComTxPduId);
imask_t state;
Irq_Save(state);
if( isPduBufferLocked(ComTxPduId) ) {
return E_NOT_OK;
}
// Is the IPdu ready for transmission?
if (Arc_IPdu->Com_Arc_TxIPduTimers.ComTxIPduMinimumDelayTimer == 0 && Arc_IPdu->Com_Arc_IpduStarted) {
//lint --e(725) Suppress PC-Lint warning "Expected positive indentation...". What means?
// Check callout status
if (IPdu->ComIPduCallout != NULL) {
if (!IPdu->ComIPduCallout(ComTxPduId, IPdu->ComIPduDataPtr)) {
// TODO Report error to DET.
// Det_ReportError();
Irq_Restore(state);
return E_NOT_OK;
}
}
PduInfoType PduInfoPackage;
PduInfoPackage.SduDataPtr = (uint8 *)IPdu->ComIPduDataPtr;
if (IPdu->ComIPduDynSignalRef != 0) {
uint8 sizeWithoutDynSignal = IPdu->ComIPduSize - (IPdu->ComIPduDynSignalRef->ComBitSize/8);
PduInfoPackage.SduLength = sizeWithoutDynSignal + Arc_IPdu->Com_Arc_DynSignalLength;
} else {
PduInfoPackage.SduLength = IPdu->ComIPduSize;
}
// Send IPdu!
if (PduR_ComTransmit(IPdu->ArcIPduOutgoingId, &PduInfoPackage) == E_OK) {
// Clear all update bits for the contained signals
for (uint8 i = 0; (IPdu->ComIPduSignalRef != NULL) && (IPdu->ComIPduSignalRef[i] != NULL); i++) {
if (IPdu->ComIPduSignalRef[i]->ComSignalArcUseUpdateBit) {
CLEARBIT(IPdu->ComIPduDataPtr, IPdu->ComIPduSignalRef[i]->ComUpdateBitPosition);
}
}
} else {
UnlockTpBuffer(getPduId(IPdu));
return E_NOT_OK;
}
// Reset miminum delay timer.
Arc_IPdu->Com_Arc_TxIPduTimers.ComTxIPduMinimumDelayTimer = IPdu->ComTxIPdu.ComTxIPduMinimumDelayFactor;
} else {
return E_NOT_OK;
}
Irq_Restore(state);
return E_OK;
#endif
}
Std_ReturnType Com_ReceiveSignalGroup(Com_SignalGroupIdType SignalGroupId) {
const ComSignal_type * Signal = GET_Signal(SignalGroupId);
const ComIPdu_type *IPdu = GET_IPdu(Signal->ComIPduHandleId);
if (isPduBufferLocked(getPduId(IPdu))) {
return COM_BUSY;
}
// Copy Ipdu data buffer to shadow buffer.
Com_CopySignalGroupDataFromPduToShadowBuffer(SignalGroupId);
return E_OK;
}
uint8 Com_SendDynSignal(Com_SignalIdType SignalId, const void* SignalDataPtr, uint16 Length) {
const ComSignal_type * Signal = GET_Signal(SignalId);
Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(Signal->ComIPduHandleId);
const ComIPdu_type *IPdu = GET_IPdu(Signal->ComIPduHandleId);
imask_t state;
Com_SignalType signalType = Signal->ComSignalType;
uint8 signalLength;
Com_BitPositionType bitPosition;
uint8 startFromPduByte;
if (signalType != UINT8_DYN) {
return COM_SERVICE_NOT_AVAILABLE;
}
if (isPduBufferLocked(getPduId(IPdu))) {
return COM_BUSY;
}
signalLength = Signal->ComBitSize / 8;
bitPosition = Signal->ComBitPosition;
if (signalLength < Length) {
return E_NOT_OK;
}
startFromPduByte = bitPosition / 8;
Irq_Save(state);
memcpy((void *)((uint8 *)IPdu->ComIPduDataPtr + startFromPduByte), SignalDataPtr, Length);
Arc_IPdu->Com_Arc_DynSignalLength = Length;
// If the signal has an update bit. Set it!
if (Signal->ComSignalArcUseUpdateBit) {
SETBIT(IPdu->ComIPduDataPtr, Signal->ComUpdateBitPosition);
}
// If signal has triggered transmit property, trigger a transmission!
if (Signal->ComTransferProperty == TRIGGERED) {
Arc_IPdu->Com_Arc_TxIPduTimers.ComTxIPduNumberOfRepetitionsLeft = IPdu->ComTxIPdu.ComTxModeTrue.ComTxModeNumberOfRepetitions + 1;
}
Irq_Restore(state);
return E_OK;
}
BufReq_ReturnType Com_CopyRxData(PduIdType PduId, const PduInfoType* PduInfoPtr, PduLengthType* RxBufferSizePtr) {
imask_t state;
BufReq_ReturnType r = BUFREQ_OK;
uint8 remainingBytes;
boolean sizeOk;
boolean dirOk;
boolean lockOk;
Irq_Save(state);
remainingBytes = GET_IPdu(PduId)->ComIPduSize - Com_BufferPduState[PduId].currentPosition;
sizeOk = remainingBytes >= PduInfoPtr->SduLength;
dirOk = GET_IPdu(PduId)->ComIPduDirection == RECEIVE;
lockOk = isPduBufferLocked(PduId);
if (dirOk && lockOk && sizeOk) {
memcpy((void *)(((uint8*)GET_IPdu(PduId)->ComIPduDataPtr)+Com_BufferPduState[PduId].currentPosition), PduInfoPtr->SduDataPtr, PduInfoPtr->SduLength);
Com_BufferPduState[PduId].currentPosition += PduInfoPtr->SduLength;
*RxBufferSizePtr = GET_IPdu(PduId)->ComIPduSize - Com_BufferPduState[PduId].currentPosition;
} else {
r = BUFREQ_NOT_OK;
}
Irq_Restore(state);
return r;
}