COM protection

diff --git a/communication/Com/Com.c b/communication/Com/Com.c
index 6a7b684f335b1ebeacf24ccebbbbdec8d489ddb9..241148ec234362551ae7b1c9c2b7b0b6ec123bcb 100644 (file)
--- a/communication/Com/Com.c
+++ b/communication/Com/Com.c
@@ -171,6 +171,7 @@ void Com_IpduGroupStart(Com_PduGroupIdType IpduGroupId,boolean Initialize) {
        for (uint16 i = 0; !ComConfig->ComIPdu[i].Com_Arc_EOL; i++) {\r
                if (ComConfig->ComIPdu[i].ComIPduGroupRef == IpduGroupId) {\r
                        Com_Arc_Config.ComIPdu[i].Com_Arc_IpduStarted = 1;\r
+                       break;\r
                }\r
        }\r
 }\r
@@ -179,6 +180,7 @@ void Com_IpduGroupStop(Com_PduGroupIdType IpduGroupId) {
        for (uint16 i = 0; !ComConfig->ComIPdu[i].Com_Arc_EOL; i++) {\r
                if (ComConfig->ComIPdu[i].ComIPduGroupRef == IpduGroupId) {\r
                        Com_Arc_Config.ComIPdu[i].Com_Arc_IpduStarted = 0;\r
+                       break;\r
                }\r
        }\r
 }\r
@@ -193,11 +195,14 @@ void Com_IpduGroupStop(Com_PduGroupIdType IpduGroupId) {
  */\r
 BufReq_ReturnType Com_CopyTxData(PduIdType PduId, PduInfoType* PduInfoPtr, RetryInfoType* RetryInfoPtr, PduLengthType* TxDataCntPtr) {\r
        imask_t state;\r
-       Irq_Save(state);\r
        BufReq_ReturnType r = BUFREQ_OK;\r
        const ComIPdu_type *IPdu = GET_IPdu(PduId);\r
        boolean dirOk = ComConfig->ComIPdu[PduId].ComIPduDirection == SEND;\r
-       boolean sizeOk = IPdu->ComIPduSize >= Com_BufferPduState[PduId].currentPosition + PduInfoPtr->SduLength;\r
+       boolean sizeOk;\r
+\r
+       Irq_Save(state);\r
+\r
+       sizeOk = IPdu->ComIPduSize >= Com_BufferPduState[PduId].currentPosition + PduInfoPtr->SduLength;\r
        Com_BufferPduState[PduId].locked = true;\r
        if (dirOk && sizeOk) {\r
                void* source = (void *)IPdu->ComIPduDataPtr;\r
@@ -212,12 +217,18 @@ BufReq_ReturnType Com_CopyTxData(PduIdType PduId, PduInfoType* PduInfoPtr, Retry
 }\r
 BufReq_ReturnType Com_CopyRxData(PduIdType PduId, const PduInfoType* PduInfoPtr, PduLengthType* RxBufferSizePtr) {\r
        imask_t state;\r
-       Irq_Save(state);\r
        BufReq_ReturnType r = BUFREQ_OK;\r
-       uint8 remainingBytes = GET_IPdu(PduId)->ComIPduSize - Com_BufferPduState[PduId].currentPosition;\r
-       boolean sizeOk = remainingBytes >= PduInfoPtr->SduLength;\r
-       boolean dirOk = GET_IPdu(PduId)->ComIPduDirection == RECEIVE;\r
-       boolean lockOk = isPduBufferLocked(PduId);\r
+       uint8 remainingBytes;\r
+       boolean sizeOk;\r
+       boolean dirOk;\r
+       boolean lockOk;\r
+\r
+       Irq_Save(state);\r
+\r
+       remainingBytes = GET_IPdu(PduId)->ComIPduSize - Com_BufferPduState[PduId].currentPosition;\r
+       sizeOk = remainingBytes >= PduInfoPtr->SduLength;\r
+    dirOk = GET_IPdu(PduId)->ComIPduDirection == RECEIVE;\r
+       lockOk = isPduBufferLocked(PduId);\r
        if (dirOk && lockOk && sizeOk) {\r
                memcpy((void *)(GET_IPdu(PduId)->ComIPduDataPtr+Com_BufferPduState[PduId].currentPosition), PduInfoPtr->SduDataPtr, PduInfoPtr->SduLength);\r
                Com_BufferPduState[PduId].currentPosition += PduInfoPtr->SduLength;\r
@@ -243,9 +254,10 @@ static void Com_SetDynSignalLength(PduIdType ComRxPduId,PduLengthType TpSduLengt
 BufReq_ReturnType Com_StartOfReception(PduIdType ComRxPduId, PduLengthType TpSduLength, PduLengthType* RxBufferSizePtr) {\r
        PduLengthType ComIPduSize;\r
        imask_t state;\r
-       Irq_Save(state);\r
        BufReq_ReturnType r = BUFREQ_OK;\r
        Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(ComRxPduId);\r
+\r
+       Irq_Save(state);\r
        if (Arc_IPdu->Com_Arc_IpduStarted) {\r
                if (GET_IPdu(ComRxPduId)->ComIPduDirection == RECEIVE) {\r
                        if (!Com_BufferPduState[ComRxPduId].locked) {\r

diff --git a/communication/Com/Com_Com.c b/communication/Com/Com_Com.c
index 467383bcd0b4b9009425f2040a2fc05f6e7d8af6..463a0120ee0d597cdccdb6c542210e9864db5e54 100644 (file)
--- a/communication/Com/Com_Com.c
+++ b/communication/Com/Com_Com.c
@@ -46,8 +46,9 @@ uint8 Com_SendSignal(Com_SignalIdType SignalId, const void *SignalDataPtr) {
        }\r
        //DEBUG(DEBUG_LOW, "Com_SendSignal: id %d, nBytes %d, BitPosition %d, intVal %d\n", SignalId, nBytes, signal->ComBitPosition, (uint32)*(uint8 *)SignalDataPtr);\r
 \r
-       // TODO: CopyData\r
-       // Com_CopyData(IPdu->ComIPduDataPtr, dataPtr, Signal->ComBitSize, Signal->ComBitPosition, 0);\r
+       imask_t irq_state;\r
+\r
+       Irq_Save(irq_state);\r
        Com_WriteSignalDataToPdu(Signal->ComHandleId, SignalDataPtr);\r
 \r
        // If the signal has an update bit. Set it!\r
@@ -61,6 +62,8 @@ uint8 Com_SendSignal(Com_SignalIdType SignalId, const void *SignalDataPtr) {
        if (Signal->ComTransferProperty == TRIGGERED) {\r
                Arc_IPdu->Com_Arc_TxIPduTimers.ComTxIPduNumberOfRepetitionsLeft = IPdu->ComTxIPdu.ComTxModeTrue.ComTxModeNumberOfRepetitions + 1;\r
        }\r
+       Irq_Restore(irq_state);\r
+\r
        return E_OK;\r
 }\r
 \r
@@ -74,12 +77,8 @@ uint8 Com_ReceiveSignal(Com_SignalIdType SignalId, void* SignalDataPtr) {
                return COM_BUSY;\r
        }\r
 \r
-       // Com_CopyFromSignal(&ComConfig->ComSignal[SignalId], SignalDataPtr);\r
        Com_ReadSignalDataFromPdu(SignalId, SignalDataPtr);\r
 \r
-       //uint16 val = *(uint16 *)SignalDataPtr;\r
-       //val = bswap16(val);\r
-       // Sign extend!\r
        return E_OK;\r
 }\r
 \r
@@ -87,17 +86,23 @@ uint8 Com_ReceiveDynSignal(Com_SignalIdType SignalId, void* SignalDataPtr, uint1
        const ComSignal_type * Signal = GET_Signal(SignalId);\r
        Com_Arc_IPdu_type    *Arc_IPdu   = GET_ArcIPdu(Signal->ComIPduHandleId);\r
        const ComIPdu_type   *IPdu       = GET_IPdu(Signal->ComIPduHandleId);\r
+    imask_t state;\r
 \r
        Com_SignalType signalType = Signal->ComSignalType;\r
        if (signalType != UINT8_DYN || isPduBufferLocked(getPduId(IPdu))) {\r
                return COM_SERVICE_NOT_AVAILABLE;\r
        }\r
 \r
+    Irq_Save(state);\r
+\r
        if (*Length > Arc_IPdu->Com_Arc_DynSignalLength) {\r
                *Length = Arc_IPdu->Com_Arc_DynSignalLength;\r
        }\r
        uint8 startFromPduByte = (Signal->ComBitPosition) / 8;\r
        memcpy(SignalDataPtr, IPdu->ComIPduDataPtr + startFromPduByte, *Length);\r
+\r
+    Irq_Restore(state);\r
+\r
        return E_OK;\r
 }\r
 \r
@@ -105,6 +110,7 @@ uint8 Com_SendDynSignal(Com_SignalIdType SignalId, const void* SignalDataPtr, ui
        const ComSignal_type * Signal = GET_Signal(SignalId);\r
        Com_Arc_IPdu_type    *Arc_IPdu   = GET_ArcIPdu(Signal->ComIPduHandleId);\r
        const ComIPdu_type   *IPdu       = GET_IPdu(Signal->ComIPduHandleId);\r
+    imask_t state;\r
 \r
        Com_SignalType signalType = Signal->ComSignalType;\r
        if (signalType != UINT8_DYN) {\r
@@ -119,6 +125,8 @@ uint8 Com_SendDynSignal(Com_SignalIdType SignalId, const void* SignalDataPtr, ui
                return E_NOT_OK;\r
        }\r
        uint8 startFromPduByte = bitPosition / 8;\r
+\r
+       Irq_Save(state);\r
        memcpy((void *)(IPdu->ComIPduDataPtr + startFromPduByte), SignalDataPtr, Length);\r
        Arc_IPdu->Com_Arc_DynSignalLength = Length;\r
        // If the signal has an update bit. Set it!\r
@@ -129,7 +137,9 @@ uint8 Com_SendDynSignal(Com_SignalIdType SignalId, const void* SignalDataPtr, ui
        if (Signal->ComTransferProperty == TRIGGERED) {\r
                Arc_IPdu->Com_Arc_TxIPduTimers.ComTxIPduNumberOfRepetitionsLeft = IPdu->ComTxIPdu.ComTxModeTrue.ComTxModeNumberOfRepetitions + 1;\r
        }\r
-       return E_OK;\r
+    Irq_Restore(state);\r
+\r
+    return E_OK;\r
 }\r
 \r
 Std_ReturnType Com_TriggerTransmit(PduIdType ComTxPduId, PduInfoType *PduInfoPtr) {\r
@@ -144,7 +154,13 @@ Std_ReturnType Com_TriggerTransmit(PduIdType ComTxPduId, PduInfoType *PduInfoPtr
         */\r
        const ComIPdu_type *IPdu = GET_IPdu(ComTxPduId);\r
 \r
-       memcpy(PduInfoPtr->SduDataPtr, IPdu->ComIPduDataPtr, IPdu->ComIPduSize);\r
+    imask_t state;\r
+    Irq_Save(state);\r
+\r
+    memcpy(PduInfoPtr->SduDataPtr, IPdu->ComIPduDataPtr, IPdu->ComIPduSize);\r
+\r
+    Irq_Restore(state);\r
+\r
        PduInfoPtr->SduLength = IPdu->ComIPduSize;\r
        return E_OK;\r
 }\r
@@ -156,14 +172,13 @@ void Com_TriggerIPduSend(PduIdType ComTxPduId) {
 \r
        const ComIPdu_type *IPdu = GET_IPdu(ComTxPduId);\r
        Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(ComTxPduId);\r
+    imask_t state;\r
+    Irq_Save(state);\r
 \r
        // Is the IPdu ready for transmission?\r
        if (Arc_IPdu->Com_Arc_TxIPduTimers.ComTxIPduMinimumDelayTimer == 0) {\r
 \r
-        imask_t state;\r
-\r
         //lint --e(725)        Suppress PC-Lint warning "Expected positive indentation...". What means?\r
-        Irq_Save(state);\r
                // Check callout status\r
                if (IPdu->ComIPduCallout != NULL) {\r
                        if (!IPdu->ComIPduCallout(ComTxPduId, IPdu->ComIPduDataPtr)) {\r
@@ -193,14 +208,13 @@ void Com_TriggerIPduSend(PduIdType ComTxPduId) {
                } else {\r
                        UnlockTpBuffer(getPduId(IPdu));\r
                }\r
-           Irq_Restore(state);\r
 \r
                // Reset miminum delay timer.\r
                Arc_IPdu->Com_Arc_TxIPduTimers.ComTxIPduMinimumDelayTimer = IPdu->ComTxIPdu.ComTxIPduMinimumDelayFactor;\r
-\r
        } else {\r
                //DEBUG(DEBUG_MEDIUM, "failed (MDT)!\n", ComTxPduId);\r
        }\r
+    Irq_Restore(state);\r
 }\r
 \r
 //lint -esym(904, Com_RxIndication) //PC-Lint Exception of rule 14.7\r
@@ -209,9 +223,12 @@ void Com_RxIndication(PduIdType ComRxPduId, const PduInfoType* PduInfoPtr) {
 \r
        const ComIPdu_type *IPdu = GET_IPdu(ComRxPduId);\r
        Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(ComRxPduId);\r
+       imask_t state;\r
+       Irq_Save(state);\r
 \r
        // If Ipdu is stopped\r
        if (!Arc_IPdu->Com_Arc_IpduStarted) {\r
+               Irq_Restore(state);\r
                return;\r
        }\r
 \r
@@ -220,6 +237,7 @@ void Com_RxIndication(PduIdType ComRxPduId, const PduInfoType* PduInfoPtr) {
                if (!IPdu->ComIPduCallout(ComRxPduId, PduInfoPtr->SduDataPtr)) {\r
                        // TODO Report error to DET.\r
                        // Det_ReportError();\r
+                       Irq_Restore(state);\r
                        return;\r
                }\r
        }\r
@@ -229,6 +247,8 @@ void Com_RxIndication(PduIdType ComRxPduId, const PduInfoType* PduInfoPtr) {
 \r
        Com_RxProcessSignals(IPdu,Arc_IPdu);\r
 \r
+       Irq_Restore(state);\r
+\r
        return;\r
 }\r
 \r
@@ -237,24 +257,30 @@ void Com_TpRxIndication(PduIdType PduId, NotifResultType Result) {
 \r
        const ComIPdu_type *IPdu = GET_IPdu(PduId);\r
        Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(PduId);\r
+       imask_t state;\r
+\r
+       Irq_Save(state);\r
 \r
        // If Ipdu is stopped\r
        if (!Arc_IPdu->Com_Arc_IpduStarted) {\r
+               Irq_Restore(state);\r
                return;\r
        }\r
+\r
        // unlock buffer\r
-       imask_t state;\r
-       Irq_Save(state);\r
        UnlockTpBuffer(getPduId(IPdu));\r
-       Irq_Restore(state);\r
 \r
        if (Result == NTFRSLT_OK) {\r
                Com_RxProcessSignals(IPdu,Arc_IPdu);\r
        }\r
+\r
+       Irq_Restore(state);\r
 }\r
+\r
 void Com_TpTxConfirmation(PduIdType PduId, NotifResultType Result) {\r
        PDU_ID_CHECK(PduId, 0x15);\r
        const ComIPdu_type *IPdu = GET_IPdu(PduId);\r
+       (void)Result; // touch\r
 \r
        imask_t state;\r
        Irq_Save(state);\r
@@ -280,10 +306,12 @@ Std_ReturnType Com_SendSignalGroup(Com_SignalGroupIdType SignalGroupId) {
 \r
        // Copy shadow buffer to Ipdu data space\r
        const ComGroupSignal_type *groupSignal;\r
+       imask_t irq_state;\r
+\r
+       Irq_Save(irq_state);\r
        for (uint8 i = 0; Signal->ComGroupSignal[i] != NULL; i++) {\r
                groupSignal = Signal->ComGroupSignal[i];\r
-               // TODO CopyData\r
-               // Com_CopyData(IPdu->ComIPduDataPtr, Arc_Signal->Com_Arc_ShadowBuffer,  groupSignal->ComBitSize, groupSignal->ComBitPosition, groupSignal->ComBitPosition);\r
+\r
                Com_WriteGroupSignalDataToPdu(Signal->ComHandleId, groupSignal->ComHandleId, Signal->Com_Arc_ShadowBuffer);\r
        }\r
 \r
@@ -292,12 +320,11 @@ Std_ReturnType Com_SendSignalGroup(Com_SignalGroupIdType SignalGroupId) {
                SETBIT(IPdu->ComIPduDataPtr, Signal->ComUpdateBitPosition);\r
        }\r
 \r
-       /*\r
-        * If signal has triggered transmit property, trigger a transmission!\r
-        */\r
+       // If signal has triggered transmit property, trigger a transmission!\r
        if (Signal->ComTransferProperty == TRIGGERED) {\r
                Arc_IPdu->Com_Arc_TxIPduTimers.ComTxIPduNumberOfRepetitionsLeft = IPdu->ComTxIPdu.ComTxModeTrue.ComTxModeNumberOfRepetitions + 1;\r
        }\r
+       Irq_Restore(irq_state);\r
 \r
        return E_OK;\r
 }\r
@@ -313,13 +340,15 @@ Std_ReturnType Com_ReceiveSignalGroup(Com_SignalGroupIdType SignalGroupId) {
        }\r
        // Copy Ipdu data buffer to shadow buffer.\r
        const ComGroupSignal_type *groupSignal;\r
+       imask_t irq_state;\r
+\r
+       Irq_Save(irq_state);\r
        for (uint8 i = 0; Signal->ComGroupSignal[i] != NULL; i++) {\r
                groupSignal = Signal->ComGroupSignal[i];\r
-               // TODO: CopyData\r
-               // Com_CopyData(Arc_Signal->Com_Arc_ShadowBuffer, IPdu->ComIPduDataPtr, groupSignal->ComBitSize, groupSignal->ComBitPosition, groupSignal->ComBitPosition);\r
+\r
                Com_ReadSignalDataFromPdu(groupSignal->ComHandleId, (void *)Signal->Com_Arc_ShadowBuffer);\r
        }\r
-\r
+       Irq_Restore(irq_state);\r
 \r
        return E_OK;\r
 }\r
@@ -327,16 +356,13 @@ Std_ReturnType Com_ReceiveSignalGroup(Com_SignalGroupIdType SignalGroupId) {
 void Com_UpdateShadowSignal(Com_SignalIdType SignalId, const void *SignalDataPtr) {\r
        Com_Arc_GroupSignal_type *Arc_GroupSignal = GET_ArcGroupSignal(SignalId);\r
 \r
-       // TODO: CopyData\r
-       // Com_CopyData(Arc_GroupSignal->Com_Arc_ShadowBuffer, SignalDataPtr, GroupSignal->ComBitSize, GroupSignal->ComBitPosition, 0);\r
        Com_WriteSignalDataToPduBuffer(SignalId, TRUE, SignalDataPtr, (void *)Arc_GroupSignal->Com_Arc_ShadowBuffer, 8);\r
 }\r
 \r
 void Com_ReceiveShadowSignal(Com_SignalIdType SignalId, void *SignalDataPtr) {\r
        Com_Arc_GroupSignal_type *Arc_GroupSignal = GET_ArcGroupSignal(SignalId);\r
        uint8 pduSize = GET_IPdu(GET_Signal(SignalId)->ComIPduHandleId)->ComIPduSize;\r
-       // TODO: CopyData\r
-       // Com_CopyData(SignalDataPtr, Arc_GroupSignal->Com_Arc_ShadowBuffer, GroupSignal->ComBitSize, 0, GroupSignal->ComBitPosition);\r
+\r
        Com_ReadSignalDataFromPduBuffer(SignalId, TRUE, SignalDataPtr, (void *)Arc_GroupSignal->Com_Arc_ShadowBuffer,pduSize);\r
 }\r
 \r

diff --git a/communication/Com/Com_Sched.c b/communication/Com/Com_Sched.c
index 72f88c2048f8f0f8dd49a2e63b78b01fea90de94..338a195704ff3925ea890141f2df033c9e304934 100644 (file)
--- a/communication/Com/Com_Sched.c
+++ b/communication/Com/Com_Sched.c
@@ -39,6 +39,9 @@ void Com_MainFunctionRx(void) {
                signal = &ComConfig->ComSignal[i];\r
                Com_Arc_Signal_type * Arc_Signal = GET_ArcSignal(signal->ComHandleId);\r
                Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(signal->ComIPduHandleId);\r
+               imask_t irq_state;\r
+\r
+               Irq_Save(irq_state);\r
 \r
                // Monitor signal reception deadline\r
                if ( (Arc_IPdu->Com_Arc_IpduStarted) && (signal->ComTimeoutFactor > 0) ) {\r
@@ -70,11 +73,15 @@ void Com_MainFunctionRx(void) {
                        }\r
                        Arc_Signal->ComSignalUpdated = 0;\r
                }\r
+\r
+               Irq_Restore(irq_state);\r
        }\r
 }\r
 \r
 \r
 void Com_MainFunctionTx(void) {\r
+       imask_t irq_state;\r
+\r
        //DEBUG(DEBUG_MEDIUM, "Com_MainFunctionTx() excecuting\n");\r
        // Decrease timers.\r
        const ComIPdu_type *IPdu;\r
@@ -82,6 +89,8 @@ void Com_MainFunctionTx(void) {
                IPdu = &ComConfig->ComIPdu[i];\r
                Com_Arc_IPdu_type *Arc_IPdu = GET_ArcIPdu(i);\r
 \r
+               Irq_Save(irq_state);\r
+\r
                // Is this a IPdu that should be transmitted?\r
                if ( (IPdu->ComIPduDirection == SEND) && (Arc_IPdu->Com_Arc_IpduStarted) ) {\r
                        // Decrease minimum delay timer\r
@@ -145,5 +154,7 @@ void Com_MainFunctionTx(void) {
                                // Don't send!\r
                        }\r
                }\r
+\r
+               Irq_Restore(irq_state);\r
        }\r
 }\r

diff --git a/communication/Com/Com_misc.c b/communication/Com/Com_misc.c
index c433347ddd064c540d6f957d45063a5a940056ee..7e67cead290dbc7580b622c3cdca2276f1813767 100644 (file)
--- a/communication/Com/Com_misc.c
+++ b/communication/Com/Com_misc.c
@@ -26,6 +26,11 @@
 #include "debug.h"\r
 #include "Cpu.h"\r
 \r
+static void Com_ReadDataSegment(uint8 *dest, const uint8 *source, uint8 destByteLength,\r
+               Com_BitPositionType segmentStartBitOffset, uint8 segmentBitLength, boolean signedOutput);\r
+\r
+static void Com_WriteDataSegment(uint8 *pdu, uint8 *pduSignalMask, const uint8 *signalDataPtr, uint8 destByteLength,\r
+               Com_BitPositionType segmentStartBitOffset, uint8 segmentBitLength);\r
 \r
 void Com_ReadSignalDataFromPdu(\r
                        const Com_SignalIdType signalId,\r
@@ -96,6 +101,8 @@ void Com_ReadSignalDataFromPduBuffer(
        uint8 signalDataBytesArray[8];\r
        const uint8 *pduBufferBytes = (const uint8 *)pduBuffer + (bitPosition/8);\r
        Com_BitPositionType startBitOffset = 0;\r
+       imask_t state;\r
+       Irq_Save(state);\r
 \r
        if (signalEndianess == COM_OPAQUE || signalType == UINT8_N) {\r
                // Aligned opaque data -> straight copy\r
@@ -144,6 +151,7 @@ void Com_ReadSignalDataFromPduBuffer(
                        assert(0);\r
                }\r
        }\r
+       Irq_Restore(state);\r
 }\r
 \r
 \r
@@ -218,6 +226,9 @@ void Com_WriteSignalDataToPduBuffer(
 \r
        uint8 signalDataBytesArray[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};\r
        const uint8 *signalDataBytes = (const uint8 *)signalData;\r
+       imask_t irq_state;\r
+\r
+       Irq_Save(irq_state);\r
        if (endian == COM_OPAQUE || signalType == UINT8_N) {\r
                //assert(bitPosition % 8 == 0);\r
                //assert(bitSize % 8 == 0);\r
@@ -253,13 +264,10 @@ void Com_WriteSignalDataToPduBuffer(
                        // Straight copy into real pdu buffer (with mutex)\r
                        uint8 *pduBufferBytes = ((uint8 *)pduBuffer)+(bitPosition/8);\r
                        uint8 i;\r
-                       imask_t irq_state;\r
-                       Irq_Save(irq_state);\r
                        for (i = 0; i < 8; i++) {\r
                                pduBufferBytes[ i ]  &=        ~( pduSignalMask[ i ] );\r
                                pduBufferBytes[ i ]  |=  pduBufferBytesStraight[ i ];\r
                        }\r
-                       Irq_Restore(irq_state);\r
 \r
                } else {\r
                        uint8 startBitOffset = intelBitNrToPduOffset(bitPosition%8, bitSize, 64);\r
@@ -271,16 +279,14 @@ void Com_WriteSignalDataToPduBuffer(
                        // Swapped copy into real pdu buffer (with mutex)\r
                        uint8 *pduBufferBytes = ((uint8 *)pduBuffer)+(bitPosition/8);\r
                        uint8 i;\r
-                       imask_t irq_state;\r
-                       Irq_Save(irq_state);\r
                        // actually it is only necessary to iterate through the bytes that are written.\r
                        for (i = 0; i < 8; i++) {\r
                                pduBufferBytes[ i ]  &=       ~( pduSignalMask[ (8 - 1) - i ] );\r
                                pduBufferBytes[ i ]  |=  pduBufferBytesSwapped[ (8 - 1) - i ];\r
                        }\r
-                       Irq_Restore(irq_state);\r
                }\r
        }\r
+       Irq_Restore(irq_state);\r
 }\r
 \r
 \r
@@ -308,7 +314,7 @@ void Com_WriteSignalDataToPduBuffer(
  *    | -------- | -------A | BCDEFGHI | JKLMNOPQ |\r
  *\r
  */\r
-void Com_ReadDataSegment(uint8 *dest, const uint8 *source, uint8 destByteLength,\r
+static void Com_ReadDataSegment(uint8 *dest, const uint8 *source, uint8 destByteLength,\r
                Com_BitPositionType segmentStartBitOffset, uint8 segmentBitLength, boolean signedOutput) {\r
 \r
        Com_BitPositionType sourceEndBitOffset = segmentStartBitOffset + segmentBitLength - 1;\r

diff --git a/communication/Com/Com_misc.h b/communication/Com/Com_misc.h
index d185c86aa09a6f25b5de89671971653e3d93121a..1316e0ca44e1738c5c01a03ad13a1b393f69716f 100644 (file)
--- a/communication/Com/Com_misc.h
+++ b/communication/Com/Com_misc.h
@@ -70,12 +70,6 @@ void Com_WriteSignalDataToPduBuffer(
 \r
 //void Com_CopyData2(char *dest, const char *source, uint8 destByteLength, uint8 segmentStartBitOffset, uint8 segmentBitLength);\r
 \r
-void Com_ReadDataSegment(uint8 *dest, const uint8 *source, uint8 destByteLength,\r
-               Com_BitPositionType segmentStartBitOffset, uint8 segmentBitLength, boolean signedOutput);\r
-\r
-void Com_WriteDataSegment(uint8 *pdu, uint8 *pduSignalMask, const uint8 *signalDataPtr, uint8 destByteLength,\r
-               Com_BitPositionType segmentStartBitOffset, uint8 segmentBitLength);\r
-\r
 Com_BitPositionType motorolaBitNrToPduOffset (Com_BitPositionType motorolaBitNr);\r
 Com_BitPositionType intelBitNrToPduOffset (Com_BitPositionType intelBitNr, Com_BitPositionType segmentBitLength, Com_BitPositionType pduBitLength);\r
 void Com_RxProcessSignals(const ComIPdu_type *IPdu,Com_Arc_IPdu_type *Arc_IPdu);\r