scom.c

Go to the documentation of this file.

#define HAL_LOG_CHANNEL SCOM

#include "hal.h"
#include "scom.h"
#include "scom_crc.h"
#include <string.h>
#include <stdbool.h>

#ifndef SCOM_MAX_FRAME_REPEAT
#define SCOM_MAX_FRAME_REPEAT               2
#endif

#ifndef SCOM_ACCESS_GUARD_TIMEOUT

#define SCOM_ACCESS_GUARD_TIMEOUT       5000
#endif

static uint32_t SCOM_GetDeltaTime(const uint32_t t1, const uint32_t t2);

static void SCOM_ConnectivityCheck(SCOMDataLinkDesc* const scom);

static void SCOM_ReceiverTimeOutCheck(SCOMDataLinkDesc* const scom);

static uint8_t SCOM_GetNextFrameNumber(SCOMDataLinkDesc* const scom);

static void SCOM_TransmitFrame(SCOMDataLink scom, SCOMFrameQueueItem *frameQueueItem);

static void SCOM_WriteFrameToIODevice(SCOMDataLink scom, SCOMFrameQueueItem *frameQueueItem);

static SCOMResult SCOM_RetransmitFrame(SCOMDataLink scom, SCOMFrameQueueItem *frameQueueItem);

static SCOMResult SCOM_ReceiveFrame(SCOMDataLink scom);

static void SCOM_ProcessReceivedFrame(SCOMDataLink scom);

static void SCOM_SendACK(SCOMDataLink scom);

static SCOMResult SCOM_ReceiveACK(SCOMDataLink scom);



// -----------------------------------------------------------------------------
//  SCOM_Create
// -----------------------------------------------------------------------------
SCOMDataLinkDesc* SCOM_Create(void) {
#ifndef SCOM_DO_NOT_USE_HEAP
        SCOMDataLinkDesc* const scom = (SCOMDataLinkDesc*)HEAP_Alloc(sizeof(SCOMDataLinkDesc));
        if (scom != NULL) {
                *scom = (SCOMDataLinkDesc){0};
                return scom;
        }
#endif
        return NULL;
} /* SCOM_Create */


// -----------------------------------------------------------------------------
//  SCOM_Destroy
// -----------------------------------------------------------------------------
void SCOM_Destroy(SCOMDataLinkDesc* const scom) {
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
#ifndef SCOM_DO_NOT_USE_HEAP
                HEAP_Free(scom);
#endif
        }
} /* SCOM_Destroy */



// -----------------------------------------------------------------------------
//  SCOM_CreateFrameBuffer
// -----------------------------------------------------------------------------
SCOMFrameBuffer* SCOM_CreateFrameBuffer(size_t rxBuffSize, size_t txBuffSize) {
#ifndef SCOM_DO_NOT_USE_HEAP

        typedef struct {
                SCOMFrameQueueItem* pool; 
                SCOMFrameQueueItem* head; 
                size_t size; 
                OSMutex lock; 
        } SCOMFrameQueuePrivate;

        SCOMFrameBuffer *frameBuffer;
        SCOMFrameQueuePrivate *rxQueuePool;
        SCOMFrameQueuePrivate *txQueuePool;

        const size_t rxBuffSizeToAlloc = sizeof(SCOMFrameQueueItem) * rxBuffSize;
        const size_t txBuffSizeToAlloc = sizeof(SCOMFrameQueueItem) * txBuffSize;
        const size_t frameBuffSizeToAlloc = sizeof(SCOMFrameBuffer);

        uint8_t *allocatedDataPtr = (uint8_t*)HEAP_Alloc(rxBuffSizeToAlloc + txBuffSizeToAlloc + frameBuffSizeToAlloc);

        frameBuffer = (SCOMFrameBuffer*)allocatedDataPtr;

        allocatedDataPtr += frameBuffSizeToAlloc;

        rxQueuePool = (SCOMFrameQueuePrivate*)&frameBuffer->rxFrameQueue;
        rxQueuePool->pool = (SCOMFrameQueueItem*)allocatedDataPtr;
        rxQueuePool->size = rxBuffSize;

        allocatedDataPtr += rxBuffSizeToAlloc;

        txQueuePool = (SCOMFrameQueuePrivate*)&frameBuffer->txFrameQueue;
        txQueuePool->pool = (SCOMFrameQueueItem*)allocatedDataPtr;
        txQueuePool->size = txBuffSize;

        return frameBuffer;
#else
        return NULL;
#endif
} /* SCOM_CreateFrameBuffer */


// -----------------------------------------------------------------------------
//  SCOM_DestroyFrameBuffer
// -----------------------------------------------------------------------------
void SCOM_DestroyFrameBuffer(SCOMFrameBuffer* const frameBuffer) {
        HAL_ASSERT_AND_EXECUTE(frameBuffer != NULL) {
#ifndef SCOM_DO_NOT_USE_HEAP
                HEAP_Free(frameBuffer);
#endif
        }
} /* SCOM_DestroyFrameBuffer */


// -----------------------------------------------------------------------------
//  SCOM_Init
// -----------------------------------------------------------------------------
SCOMResult SCOM_Init(SCOMDataLink scom, IODevice iodevice, SCOMFrameBuffer *frameBuffer,
                SCOMClockSource clockSource, uint32_t ackTimeout,
                uint32_t deviceClass, uint8_t* deviceUID,
                uint8_t numberOfServices, uint8_t* serviceIDs
)
{
#if defined SCOM_MAX_SERVICES && (SCOM_MAX_SERVICES > 0)
        size_t serviceIndex;
#endif
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                HAL_ASSERT_AND_EXECUTE(iodevice != NULL) {
                        HAL_ASSERT_AND_EXECUTE(frameBuffer != NULL) {
                                HAL_ASSERT_AND_EXECUTE(clockSource != NULL) {
                                        // todo critical section must be defined to avoid momentary undefined states
                                        // clear the descriptor
                                        *scom = (SCOMDataLinkDesc){0};

                                        scom->frameBuffer = frameBuffer; // bind transmit buffer
                                        // initialize transmission queue
                                        if (SCOMFrameQueue_Init(&scom->frameBuffer->txFrameQueue) == false) {
                                                return SCOM_ERROR;
                                        }
                                        // initialize reception queue
                                        if (SCOMFrameQueue_Init(&scom->frameBuffer->rxFrameQueue) == false) {
                                                return SCOM_ERROR;
                                        }



                                        scom->iodevice = iodevice; // bind IODevice object
                                        scom->clockSource = clockSource; // bind clock source function
                                        scom->timeout = ackTimeout; // save timeout
                                        scom->lastFrameNumber = 0xFF;
                                        scom->rxAck.frame.sync = 0xFF;
                                        scom->rxAck.frame.soack = SCOM_ACK_SOF_CHARACTER;
                                        scom->connectionState = SCOM_CONNECTION_OPERATIONAL;
                                        scom->rxState = SCOM_RX_WAIT_FOR_SOF;

                                        scom->frameBeingTransmitted = NULL;

                                        // save identification data
                                        scom->id.deviceClass = deviceClass;
                                        if (deviceUID) {
                                                memcpy(scom->id.deviceUID, deviceUID, sizeof(scom->id.deviceUID));
                                        } else {
                                                memset(scom->id.deviceUID, 0x00, sizeof(scom->id.deviceUID));
                                        }
                                        scom->id.version.verHi = SCOM_VER_HI;
                                        scom->id.version.verLo = SCOM_VER_LO;
#ifdef SCOM_REVISION
                                        scom->id.version.revision = SCOM_REVISION;
#else
                                        scom->id.version.revision = 0;
#endif
                                        // save information about services
                                        scom->serviceCount = 0;
#if defined SCOM_MAX_SERVICES && (SCOM_MAX_SERVICES > 0)

                                        if ((numberOfServices) && (serviceIDs)) {
                                                // check if services fit into our list
                                                HAL_ASSERT_AND_EXECUTE(numberOfServices <= SCOM_MAX_SERVICES) {
                                                        // save information about services
                                                        scom->serviceCount = numberOfServices;
                                                        memcpy(scom->id.serviceID, serviceIDs, numberOfServices);
                                                        // prepare service handler descriptors
                                                        for (serviceIndex = 0; serviceIndex < numberOfServices; serviceIndex++) {
                                                                scom->serviceHandler[serviceIndex].serviceID = serviceIDs[serviceIndex];
                                                                scom->serviceHandler[serviceIndex].handler = NULL;
                                                        }
                                                }
                                        }
#endif
                                        // reset transmit counters
                                        scom->txCounter = 0;
                                        scom->multiCounter = 0;

                                        // reset connectivity check
                                        scom->connectivityCheckPeriod = 0;
                                        scom->connectivityCheckIncommingCounter = 0;
                                        scom->connectivityCheckOutgoingCounter = 0;
                                        scom->lastConnectivityCheckTime = clockSource();

                                        // reset statistics
                                        scom->stats.framesReceived = 0;
                                        scom->stats.framesSent = 0;
                                        scom->stats.retransmissionsReceived = 0;
                                        scom->stats.retransmissionsSent = 0;

#if SCOM_MAX_FRAME_FILTERS > 0
                                        // Initialize frame filter list
                                        LLST_Init(&scom->filters.list, scom->filters.pool, SCOM_MAX_FRAME_FILTERS);
#endif

#if 1 == HAL_ENABLE_OS
                                        // create guarding mutex
                                        scom->accessGuard = OSMUTEX_Create();
                                        if (!scom->accessGuard) {
                                                return SCOM_ERROR;
                                        }
#endif

                                        return SCOM_RESULT_OK;
                                }
                        }
                }
        }
        return SCOM_ERROR;
} /* SCOM_Init */


// -----------------------------------------------------------------------------
//  SCOM_Deinit
// -----------------------------------------------------------------------------
SCOMResult SCOM_Deinit(SCOMDataLinkDesc* const scom) {
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                scom->connectionState = SCOM_CONNECTION_UNINITIALIZED;
                SCOMFrameQueue_Deinit(&scom->frameBuffer->txFrameQueue);
                SCOMFrameQueue_Deinit(&scom->frameBuffer->rxFrameQueue);

#if 1 == HAL_ENABLE_OS
                // Destroy guarding mutex
                if (scom->accessGuard != NULL) {
                        OSMUTEX_Destroy(scom->accessGuard);
                }
#endif
                return SCOM_RESULT_OK;
        }
        return SCOM_RESULT_ERROR;
} /* SCOM_Deinit */

// -----------------------------------------------------------------------------
//  SCOM_InitAsMonitor
// -----------------------------------------------------------------------------
SCOMResult SCOM_InitAsMonitor(SCOMDataLink scom, IODevice iodevice, SCOMFrameBuffer *frameBuffer, SCOMClockSource clockSource, uint32_t ackTimeout) {
         SCOMResult result = SCOM_Init(scom, iodevice, frameBuffer, clockSource, ackTimeout, 0, NULL, 0, NULL);
        if (SCOM_RESULT_OK == result) {
                // in monitor mode, sending ACKs is disabled
                scom->monitorMode = true;
        }
        return result;
} /* SCOM_InitAsMonitor */


// -----------------------------------------------------------------------------
//  SCOM_ProcThread
// -----------------------------------------------------------------------------
static int SCOM_ProcThread(void* param) {
        SCOMDataLinkDesc* scom = (SCOMDataLinkDesc*)param;
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                while (true == OSTASK_IsAlive()) {
                        switch (SCOM_Proc(scom)) {
                        case SCOM_RESULT_OK:
                                // all OK!
                                break;
                        case SCOM_SYNCHRONIZATION_ERROR:
                                break;
                        case SCOM_COMMUNICATION_ERROR:
                                break;
                        case SCOM_RESULT_ERROR:
                                break;
                        default:
                                break;
                        }
                        OS_Sleep(10);
                }
        }
        return 0;
} /* SCOM_ProcThread */


// -----------------------------------------------------------------------------
//  SCOM_RunProcessingThread
// -----------------------------------------------------------------------------
SCOMResult SCOM_RunProcessingThread(SCOMDataLinkDesc* const scom) {
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
#if 1 == HAL_ENABLE_OS
                // Create the thread
                scom->procTask = OSTASK_Create(SCOM_ProcThread, HAL_OSTASK_JOINABLE | HAL_OSTASK_MORTAL, HAL_OSTASK_PRIORITY_NORMAL, 0, scom);
                if(true == OSTASK_IsValid(scom->procTask)) {
                        return SCOM_RESULT_OK;
                }
#endif
        }
        return SCOM_RESULT_ERROR;
} /* SCOM_RunProcessingThread */


// -----------------------------------------------------------------------------
//  SCOM_StopProcessingThread
// -----------------------------------------------------------------------------
void SCOM_StopProcessingThread(SCOMDataLink scom) {
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
#if defined HAL_ENABLE_OS && (HAL_ENABLE_OS == 1)
                // send the termination signal
                OSTASK_Kill(scom->procTask);
                // wait for the thread to finish
                if (!OSTASK_Join(scom->procTask, 10000, NULL)) {
                        HAL_LOG_ERROR("Unable to stop SCOM processing thread");
                }
#endif
        }
} /* SCOM_StopProcessingThread */


// -----------------------------------------------------------------------------
//  SCOM_EnableConnectivityCheck
// -----------------------------------------------------------------------------
SCOMResult SCOM_EnableConnectivityCheck(SCOMDataLinkDesc* const scom, const uint32_t checkPeriod) {
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                HAL_ASSERT_AND_EXECUTE(checkPeriod > 0) {
                        scom->connectivityCheckPeriod = checkPeriod;
                        return SCOM_RESULT_OK;
                }
        }
        return SCOM_RESULT_ERROR;
} /* SCOM_EnableConnectivityCheck */

// -----------------------------------------------------------------------------
//  SCOM_DisableConnectivityCheck
// -----------------------------------------------------------------------------
SCOMResult SCOM_DisableConnectivityCheck(SCOMDataLinkDesc* const scom) {
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                scom->connectivityCheckPeriod = 0;
                return SCOM_RESULT_OK;
        }
        return SCOM_RESULT_ERROR;
} /* SCOM_DisableConnectivityCheck */

// -----------------------------------------------------------------------------
//  SCOM_GetConnectionState
// -----------------------------------------------------------------------------
SCOMConnectionState SCOM_GetConnectionState(const SCOMDataLinkDesc* const scom) {
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
#if 1 == HAL_ENABLE_OS
                // before we proceed, acquire mutex guarding access to the SCOM object
                HAL_ASSERT_AND_EXECUTE(0 == OSMUTEX_Take(scom->accessGuard, SCOM_ACCESS_GUARD_TIMEOUT)) {
                        SCOMConnectionState state = scom->connectionState;
                        OSMUTEX_Give(scom->accessGuard);
                        return state;
                }
#else
                return scom->connectionState;
#endif
                return SCOM_CONNECTION_UNINITIALIZED;
        }
        return SCOM_RESULT_ERROR;
} /* SCOM_GetConnectionState */


// -----------------------------------------------------------------------------
//  SCOM_GetIODevice
// -----------------------------------------------------------------------------
IODevice SCOM_GetIODevice(const SCOMDataLinkDesc* const scom) {
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                return scom->iodevice;
        }
        return NULL;
} /* SCOM_GetIODevice */


// -----------------------------------------------------------------------------
//  SCOM_SendFrame
// -----------------------------------------------------------------------------
SCOMResult SCOM_SendFrame(SCOMDataLinkDesc* const scom, uint8_t framePriority, uint8_t frameType, const void* frameData, uint8_t frameDataSize) {
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                HAL_ASSERT_AND_EXECUTE(scom->frameBuffer != NULL) {
                        HAL_ASSERT_AND_EXECUTE((frameData != NULL && frameDataSize > 0) || (NULL == frameData && 0 == frameDataSize)) {
                                SCOMFrameQueueItem* const frameQueueItem = SCOMFrameQueue_Lock(&scom->frameBuffer->txFrameQueue); // Find empty frame
                                if (frameQueueItem != NULL) {
                                        SCOMFrame* const frame = &frameQueueItem->frame;

                                        frame->sof = SCOM_SOF_CHARACTER;
                                        frame->type = frameType;
                                        frame->null = 0;
                                        //clear old settings
                                        frame->ctrl = 0;
                                        SCOMFrame_SetPriority(frame, framePriority);
                                        frame->size = frameDataSize;
                                        if(frameDataSize > 0){
                                                memcpy(&frame->payload.singleframe.data, frameData, frameDataSize);
                                        }
                                        frameQueueItem->state = SCOM_FRAME_TX_READY_FOR_SEND;
                                        if (true == SCOMFrameQueue_Insert(&scom->frameBuffer->txFrameQueue, frameQueueItem)) {
                                                return SCOM_RESULT_OK;
                                        }
                                } else {
                                        // report overload error
                                        //SCOM_REPORT_ERROR(SCOM_ERR__TX_OVERLOAD);
                                        return SCOM_TX_FRAME_BUFFER_OVERRUN;
                                }
                        }
                }
        }
        return SCOM_RESULT_ERROR;
} /* SCOM_SendFrame */


// -----------------------------------------------------------------------------
//  SCOM_SendFrameWithoutAck
// -----------------------------------------------------------------------------
SCOMResult SCOM_SendFrameWithoutAck(SCOMDataLink scom, uint8_t framePriority, uint8_t frameType, const void* frameData, uint8_t frameDataSize) {
        SCOMResult result = SCOM_ERROR;
        SCOMFrameQueueItem *frameQueueItem;
        SCOMFrame *frame;

        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                HAL_ASSERT_AND_EXECUTE(scom->frameBuffer != NULL) {

                        // find empty frame
                        frameQueueItem = SCOMFrameQueue_Lock(&scom->frameBuffer->txFrameQueue);

                        if (frameQueueItem) {
                                frame = &frameQueueItem->frame;

                                frame->sof = SCOM_SOF_CHARACTER;
                                frame->type = frameType;
                                frame->null = 0;
                                //clear old settings
                                frame->ctrl = 0;
                                SCOMFrame_SetPriority(frame, framePriority);
                                // NO ACK!
                                SCOMFrame_SetAcknowledgement(frame, false);
                                frame->size = frameDataSize;
                                if(frameDataSize){
                                        memcpy(&frame->payload.singleframe.data, frameData, frameDataSize);
                                }
                                frameQueueItem->state = SCOM_FRAME_TX_READY_FOR_SEND;
                                if (true == SCOMFrameQueue_Insert(&scom->frameBuffer->txFrameQueue, frameQueueItem)) {
                                        result = SCOM_RESULT_OK;
                                }
                        } else {
                                // report overload error
                                //SCOM_REPORT_ERROR(SCOM_ERR__TX_OVERLOAD);
                                result =  SCOM_TX_FRAME_BUFFER_OVERRUN;
                        }
                }
        }
        return result;

} /* SCOM_SendFrameWithoutAck */

// -----------------------------------------------------------------------------
//  SCOM_SendMultiFrame
// -----------------------------------------------------------------------------
SCOMResult SCOM_SendMultiFrame(SCOMDataLink scom, uint8_t framePriority, uint8_t frameType,
                const void* frameData, uint32_t frameDataSize, SCOMMultiFrameDesc* multiFrameDesc)
{
        SCOMResult result = SCOM_ERROR;
        SCOMFrameQueueItem *frameQueueItem;
        SCOMFrame *frame;

        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                HAL_ASSERT_AND_EXECUTE(scom->frameBuffer != NULL) {
                        HAL_ASSERT_AND_EXECUTE(multiFrameDesc != NULL) {
                                // search for free slot in TX buffer
                                frameQueueItem = SCOMFrameQueue_Lock(&scom->frameBuffer->txFrameQueue);

                                if (frameQueueItem) {
                                        frame = &frameQueueItem->frame;

                                        frame->sof = SCOM_SOF_CHARACTER;
                                        frame->type = frameType;
                                        frame->null = 0;
                                        //clear old settings and set multiframe id bit
                                        frame->ctrl = SCOM_FRAME_CTRL_MULTI_ID_MASK;
                                        SCOMFrame_SetPriority(frame, framePriority);
                                        frame->payload.multiframe.offset = multiFrameDesc->progress;
                                        frame->payload.multiframe.total_size = frameDataSize;

                                        if (0 == multiFrameDesc->multi_id) {
                                                // this is the first frame of the new multiframe, increase the multi counter
                                                scom->multiCounter++;
                                                // make sure the counter is not 0 (it is used as an non-zero id)
                                                if (0 == scom->multiCounter) {
                                                        scom->multiCounter = 1;
                                                }
                                                // assign id to the frame
                                                frame->payload.multiframe.multi_id = scom->multiCounter;
                                                // save id in a multiFrameDesc descriptor
                                                multiFrameDesc->multi_id = scom->multiCounter;
                                        } else {
                                                // multi id already assigned
                                                frame->payload.multiframe.multi_id = multiFrameDesc->multi_id;
                                        }

                                        if ((frameData) && (frameDataSize)) {
                                                // calculate data size for this part
                                                uint32_t size = frameDataSize - multiFrameDesc->progress;
                                                if (size > SCOMFrame_GetMaxMultiframePayloadSize()) {
                                                        size = SCOMFrame_GetMaxMultiframePayloadSize();
                                                }

                                                frame->size = (uint8_t)size;
                                                memcpy(frame->payload.multiframe.data, ((uint8_t *)frameData) + multiFrameDesc->progress, size);

                                                // update progress
                                                multiFrameDesc->progress += size;
                                        }

                                        // mark that the frame is ready to be sent
                                        frameQueueItem->state = SCOM_FRAME_TX_READY_FOR_SEND;

                                        if(true == SCOMFrameQueue_Insert(&scom->frameBuffer->txFrameQueue, frameQueueItem)) {
                                                result= SCOM_RESULT_OK;
                                        }
                                } else {
                                        // no free frame available at this moment
                                        result = SCOM_TX_FRAME_BUFFER_OVERRUN;
                                }
                        }
                }
        }

        return result;

} /* SCOM_SendMultiFrame */

// -----------------------------------------------------------------------------
//  SCOM_SendAllocatedMultiFrame
// -----------------------------------------------------------------------------
SCOMResult SCOM_SendAllocatedMultiFrame(SCOMDataLink scom, SCOMFrame* frame, SCOMMultiFrameDesc* multiFrameDesc)
{
        SCOMResult result = SCOM_ERROR;
        SCOMFrameQueueItem *frameQueueItem;

        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                HAL_ASSERT_AND_EXECUTE(frame != NULL) {
                        HAL_ASSERT_AND_EXECUTE(scom->frameBuffer != NULL) {
                                HAL_ASSERT_AND_EXECUTE(multiFrameDesc != NULL) {
                                        // retrieve the corresponding item
                                        frameQueueItem = SCOMFrameQueue_GetItemByFrame(&scom->frameBuffer->txFrameQueue, frame);
                                        if (frameQueueItem) {
                                                frame->ctrl |= SCOM_FRAME_CTRL_MULTI_ID_MASK;
                                                frame->null = 0;
                                                frame->sof = SCOM_SOF_CHARACTER;
                                                frame->payload.multiframe.offset = multiFrameDesc->progress;

                                                if (0 == multiFrameDesc->multi_id) {
                                                        // this is the first frame of the new multiframe, increase the multi counter
                                                        scom->multiCounter++;
                                                        // make sure the counter is not 0 (it is used as an non-zero id)
                                                        if (0 == scom->multiCounter) {
                                                                scom->multiCounter = 1;
                                                        }
                                                        // assign id to the frame
                                                        frame->payload.multiframe.multi_id = scom->multiCounter;
                                                        // save id in a multiFrameDesc descriptor
                                                        multiFrameDesc->multi_id = scom->multiCounter;
                                                } else {
                                                        // multi id already assigned
                                                        frame->payload.multiframe.multi_id = multiFrameDesc->multi_id;
                                                }

                                                // update progress
                                                multiFrameDesc->progress += frame->size;

                                                frameQueueItem->state = SCOM_FRAME_TX_READY_FOR_SEND;
                                                if(true == SCOMFrameQueue_Insert(&scom->frameBuffer->txFrameQueue, frameQueueItem)) {
                                                        result = SCOM_RESULT_OK;
                                                }
                                        } else {
                                                result = SCOM_FRAME_NOT_IN_BUFFER;
                                        }
                                }
                        }
                }
        }

        return result;

} // SCOM_SendAlocatedMultiFrame


// -----------------------------------------------------------------------------
//  SCOM_AllocFrame
// -----------------------------------------------------------------------------
SCOMResult SCOM_AllocFrame(SCOMDataLink scom, SCOMFrame** framePtr) {
        SCOMResult result = SCOM_ERROR;

        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                HAL_ASSERT_AND_EXECUTE(scom->frameBuffer != NULL) {
                        HAL_ASSERT_AND_EXECUTE(framePtr != NULL) {

                                // find and lock empty frame
                                SCOMFrameQueueItem *frameQueueItem = SCOMFrameQueue_Lock(&scom->frameBuffer->txFrameQueue);

                                if (frameQueueItem) {
                                        *framePtr = &frameQueueItem->frame;
                                        result = SCOM_RESULT_OK;
                                } else {
                                        // report overload error
                                        result = SCOM_TX_FULL;
                                }
                        }
                }
        }

        return result;

} /* SCOM_AllocFrame */


// -----------------------------------------------------------------------------
//  SCOM_SendAllocatedFrame
// -----------------------------------------------------------------------------
SCOMResult SCOM_SendAllocatedFrame(SCOMDataLink scom, SCOMFrame* frame)
{
        SCOMResult result = SCOM_ERROR;
        SCOMFrameQueueItem *frameQueueItem;

        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                HAL_ASSERT_AND_EXECUTE(frame != NULL) {
                        HAL_ASSERT_AND_EXECUTE(scom->frameBuffer != NULL) {
                                // retrieve the corresponding item
                                frameQueueItem = SCOMFrameQueue_GetItemByFrame(&scom->frameBuffer->txFrameQueue, frame);
                                if (frameQueueItem) {
                                        frame->sof = SCOM_SOF_CHARACTER;
                                        frameQueueItem->state = SCOM_FRAME_TX_READY_FOR_SEND;
                                        frame->null = 0;
                                        if(true == SCOMFrameQueue_Insert(&scom->frameBuffer->txFrameQueue, frameQueueItem)) {
                                                result = SCOM_RESULT_OK;
                                        }
                                } else {
                                        result = SCOM_FRAME_NOT_IN_BUFFER;
                                }
                        }
                }
        }

        return result;
} /* SCOM_SendAllocatedFrame */


// -----------------------------------------------------------------------------
//  SCOM_SendAllocatedFrameWithoutACK
// -----------------------------------------------------------------------------
SCOMResult SCOM_SendAllocatedFrameWithoutACK(SCOMDataLink scom, SCOMFrame* frame)
{
        SCOMResult result = SCOM_ERROR;
        SCOMFrameQueueItem *frameQueueItem;

        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                HAL_ASSERT_AND_EXECUTE(frame != NULL) {
                        HAL_ASSERT_AND_EXECUTE(scom->frameBuffer != NULL) {
                                // retrieve the corresponding item
                                frameQueueItem = SCOMFrameQueue_GetItemByFrame(&scom->frameBuffer->txFrameQueue, frame);
                                if (frameQueueItem) {
                                        frame->sof = SCOM_SOF_CHARACTER;
                                        frameQueueItem->state = SCOM_FRAME_TX_READY_FOR_SEND;
                                        frame->null = 0;
                                        // NO ACK!
                                        SCOMFrame_SetAcknowledgement(frame, false);
                                        if(true == SCOMFrameQueue_Insert(&scom->frameBuffer->txFrameQueue, frameQueueItem)) {
                                                result = SCOM_RESULT_OK;
                                        }
                                } else {
                                        result = SCOM_FRAME_NOT_IN_BUFFER;
                                }
                        }
                }
        }

        return result;
} /* SCOM_SendAllocatedFrameWithoutACK */





// -----------------------------------------------------------------------------
//  SCOM_SetFrameReceptionHandlerFunc
// -----------------------------------------------------------------------------
SCOMResult SCOM_SetFrameReceptionHandlerFunc(SCOMDataLinkDesc* const scom, SCOMFrameReceptionHandler frameReceptionFunc) {
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
#if 1 == HAL_ENABLE_OS
                HAL_ASSERT_AND_EXECUTE(0 == OSMUTEX_Take(scom->accessGuard, SCOM_ACCESS_GUARD_TIMEOUT)) {
                        scom->receptionHandler = frameReceptionFunc;
                        OSMUTEX_Give(scom->accessGuard);
                        return SCOM_RESULT_OK;
                }
#else
                scom->receptionHandler = frameReceptionFunc;
                return SCOM_RESULT_OK;
#endif
        }
        return SCOM_RESULT_ERROR;
} /* SCOM_SetFrameReceptionHandlerFunc */


// -----------------------------------------------------------------------------
//  SCOM_SetAckReceptionHandlerFunc
// -----------------------------------------------------------------------------
SCOMResult SCOM_SetAckReceptionHandlerFunc(SCOMDataLinkDesc* const scom, SCOMAckReceptionHandler ackReceptionFunc) {
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
#if 1 == HAL_ENABLE_OS
                HAL_ASSERT_AND_EXECUTE(0 == OSMUTEX_Take(scom->accessGuard, SCOM_ACCESS_GUARD_TIMEOUT)) {
                        scom->ackHandler = ackReceptionFunc;
                        OSMUTEX_Give(scom->accessGuard);
                        return SCOM_RESULT_OK;
                }
#else
                scom->ackHandler = ackReceptionFunc;
                return SCOM_RESULT_OK;
#endif
        }
        return SCOM_RESULT_ERROR;
} /* SCOM_SetAckReceptionHandlerFunc */

// -----------------------------------------------------------------------------
//  SCOM_SetServiceHandler
// -----------------------------------------------------------------------------
SCOMResult SCOM_SetServiceHandler(SCOMDataLink scom, uint8_t serviceID, SCOMServiceHandler serviceHandlerFunc) {
#if SCOM_MAX_SERVICES > 0
        size_t i;
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                for (i = 0; i < SCOM_MAX_SERVICES; i++) {
                        if (scom->serviceHandler[i].serviceID == serviceID) {
                                scom->serviceHandler[i].handler = serviceHandlerFunc;
                                return SCOM_RESULT_OK;
                        }
                }
        }
#endif
        return SCOM_RESULT_ERROR;
} /* SCOM_SetServiceHandler */

// -----------------------------------------------------------------------------
//  SCOM_Proc
// -----------------------------------------------------------------------------
SCOMResult SCOM_Proc(SCOMDataLink scom)
{
        uint8_t byte;
        bool repeat;
        SCOMResult result = SCOM_ERROR;
        uint32_t current_time;
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {

#if defined HAL_ENABLE_OS && (HAL_ENABLE_OS == 1)
                // before we proceed, acquire mutex guarding access to the SCOM object
                HAL_ASSERT_AND_EXECUTE(0 == OSMUTEX_Take(scom->accessGuard, SCOM_ACCESS_GUARD_TIMEOUT)) {
#endif

                        do {
                                repeat = false;
                                switch(scom->rxState) {
                                case SCOM_RX_WAIT_FOR_SOF:
                                        if(IODEV_Read(scom->iodevice, &byte, 1, 0) >= 1){
                                                switch(byte){
                                                case SCOM_ACK_SOF_CHARACTER:
                                                        scom->rxState = SCOM_RX_ACK;
                                                        repeat = true;
                                                        break;
                                                case SCOM_SOF_CHARACTER:
                                                        scom->rxState = SCOM_RX_FRAME;
                                                        repeat = true;
                                                        break;
                                                case 255:       // received sync character
                                                        repeat = true;
                                                        break;
                                                default:
                                                        break;
                                                }
                                        }
                                        break;
                                case SCOM_RX_ACK:
                                        switch(SCOM_ReceiveACK(scom)){
                                        case SCOM_RESULT_OK:
                                                if (scom->frameBeingTransmitted) {
                                                        if (SCOMAckFrame_IsValidAck(&scom->rxAck.frame, &(scom->frameBeingTransmitted->frame))) {
                                                                scom->lastConnectivityCheckTime = scom->clockSource(); // recieved valid ACK so no need to ping
                                                                scom->receptionTime = scom->clockSource(); //we recieved valid frame, so update timeout counter
                                                                // this ACK was expected,
                                                                HAL_LOG_INFO("Received valid ACK");
                                                                SCOMFrameQueue_Unlock(&scom->frameBuffer->txFrameQueue, scom->frameBeingTransmitted);
                                                                scom->frameBeingTransmitted = NULL;
                                                        } else {
                                                                HAL_LOG_WARNING("Received weird ACK, type: %" PRIu8, scom->rxAck.frame.type);

                                                        }
                                                }
                                                // reset the receiver
                                                scom->rxState = SCOM_RX_WAIT_FOR_SOF;
                                                break;
                                        case SCOM_ERROR:
                                                // reset the receiver
                                                scom->rxState = SCOM_RX_WAIT_FOR_SOF;
                                                break;
                                        default:
                                                break;
                                        }
                                        break;
                                        case SCOM_RX_FRAME:
                                                // try to receive the frame
                                                switch(SCOM_ReceiveFrame(scom)){
                                                case SCOM_RESULT_OK:
                                                        // frame was received successfully
                                                        scom->receptionTime = scom->clockSource();

                                                        // check if the frame should be acknowledged
                                                        if (SCOMFrame_IsAcknowledged(&scom->frameBeingReceived->frame)) {
                                                                // prepare ack frame
                                                                SCOMAckFrame_Initialize(&scom->txAck.frame, &scom->frameBeingReceived->frame);
                                                                scom->txAck.frame.crc = SCOMAckFrame_CalculateCRC(&scom->txAck.frame);
                                                                scom->txAck.state = SCOM_FRAME_TX_READY_FOR_SEND;
                                                        }
                                                        // process received frame
                                                        SCOM_ProcessReceivedFrame(scom);

                                                        // reset the receiver
                                                        scom->rxState = SCOM_RX_WAIT_FOR_SOF;
                                                        if ((scom->stats.framesSent + scom->stats.framesReceived) % 100 == 0) {
                                                                HAL_LOG_DEBUG("Current stats: tx=%" PRIu32 ", rx=%" PRIu32 ", txret=%" PRIu32 "rxret=%" PRIu32, scom->stats.framesSent, scom->stats.framesReceived, scom->stats.retransmissionsSent, scom->stats.retransmissionsReceived);
                                                        }
                                                        break;
                                                case SCOM_ERROR:
                                                        // there was an error, cancel the frame
                                                        scom->rxState = SCOM_RX_WAIT_FOR_SOF;
                                                        HAL_LOG_ERROR("Error in receiving frame");

                                                        break;
                                                default:
                                                        break;
                                                }
                                                break;
                                                default:
                                                        // reset the receiver
                                                        scom->rxState = SCOM_RX_WAIT_FOR_SOF;
                                                        break;
                                }
                        } while(repeat);

                        // This code is responsible for sending frame

                        // if packet was received send ack
                        if(scom->txAck.state == SCOM_FRAME_TX_READY_FOR_SEND){
                                SCOM_SendACK(scom);
                        }

                        // get current time
                        current_time = scom->clockSource();

                        if (scom->frameBeingTransmitted) {
                                // there is a frame being currently transmitted
                                if(SCOM_GetDeltaTime(current_time, scom->sendTime) > scom->timeout){
                                        // ACK timeout! Proceed with the retransmission
                                        if (SCOM_COMMUNICATION_ERROR == SCOM_RetransmitFrame(scom, scom->frameBeingTransmitted)) {
                                                // unable to send out frame, cancel (error should be already reported)
                                                scom->frameBeingTransmitted = NULL;
                                        }
                                }
                        } else {
                                scom->frameBeingTransmitted = SCOMFrameQueue_GetFirstInQueue(&scom->frameBuffer->txFrameQueue);
                                if (scom->frameBeingTransmitted) {
                                        if (scom->frameBeingTransmitted->state == SCOM_FRAME_TX_READY_FOR_SEND) {
                                                // set frame number
                                                SCOMFrame_SetFrameNumber(&(scom->frameBeingTransmitted->frame), SCOM_GetNextFrameNumber(scom));
                                                // transmit the frame
                                                SCOM_TransmitFrame(scom, scom->frameBeingTransmitted);
                                                // check if the frame is acknowledged
                                                if (!SCOMFrame_IsAcknowledged(&scom->frameBeingTransmitted->frame)) {
                                                        // the frame is not acknowledged, this is it when it comes to sending it
                                                        SCOMFrameQueue_Unlock(&scom->frameBuffer->txFrameQueue, scom->frameBeingTransmitted);
                                                        scom->frameBeingTransmitted = NULL;
                                                }

                                                // check if we need to print out statistics
                                                if ((scom->stats.framesSent + scom->stats.framesReceived) % 100 == 0) {
                                                        HAL_LOG_DEBUG("Current stats: tx=%" PRIu32 ", rx=%" PRIu32 ", txret=%" PRIu32 "rxret=%" PRIu32, scom->stats.framesSent, scom->stats.framesReceived, scom->stats.retransmissionsSent, scom->stats.retransmissionsReceived);
                                                }
                                        } else {
                                                // frame not ready to be transmitted
                                                scom->frameBeingTransmitted = NULL;
                                        }
                                }
                        }

                        // Run connectivity check (if needed)
                        SCOM_ConnectivityCheck(scom);

                        // Check receiver timeout
                        SCOM_ReceiverTimeOutCheck(scom);

                        // Check for synchronization error condition
                        if (scom->connectionState == SCOM_CONNECTION_UNSYNCHRONIZED) {
                                result = SCOM_SYNCHRONIZATION_ERROR;
                        }

                        // Check for broken connection condition
                        if (scom->connectionState == SCOM_CONNECTION_BROKEN) {
                                result = SCOM_COMMUNICATION_ERROR;
                        }

#if defined HAL_ENABLE_OS && (HAL_ENABLE_OS == 1)

                        // release mutex guarding access to the SCOM object
                        OSMUTEX_Give(scom->accessGuard);
                }

#endif

                // else all OK!
                if (scom->connectionState == SCOM_CONNECTION_OPERATIONAL) {
                        result = SCOM_RESULT_OK;
                }

        } // DIAG0_ASSERT_AND_EXECUTE(SCOM_DIAG_CHANNEL, scom)

        return result;

} /* SCOM_Proc */

// -----------------------------------------------------------------------------
//  SCOM_IsBusy
// -----------------------------------------------------------------------------
bool SCOM_IsBusy(SCOMDataLink scom) {
        SCOMFrameQueueItem *frame;
        // check if there is frame currently being transmitted
        if(scom->frameBeingTransmitted != NULL) {
                return true;
        }
        // check if there are frames waiting to be sent
        frame = SCOMFrameQueue_GetFirstInQueue(&scom->frameBuffer->txFrameQueue);
        if (frame) {
                if (frame->state == SCOM_FRAME_TX_SENT || frame->state == SCOM_FRAME_EMPTY) {
                        return false;
                } else {
                        return true;
                }
        }
        return false;
} /* SCOM_IsBusy */

// -----------------------------------------------------------------------------
//  SCOM_GetReceivedFrame
// -----------------------------------------------------------------------------
SCOMFrame * SCOM_GetReceivedFrame(SCOMDataLink scom)
{
        SCOMFrameQueueItem* frameQueueItem;

        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                HAL_ASSERT_AND_EXECUTE(scom->frameBuffer != NULL) {

                        frameQueueItem = SCOMFrameQueue_GetFirstInQueue(&scom->frameBuffer->rxFrameQueue);
                        if (frameQueueItem) {
                                return &frameQueueItem->frame;
                        }
                }
        }
        return NULL;

} /* SCOM_GetReceivedFrame */


// -----------------------------------------------------------------------------
//  SCOM_UnlockFrame
// -----------------------------------------------------------------------------
void SCOM_UnlockFrame(SCOMDataLink scom, SCOMFrame *frame)
{
        SCOMFrameQueueItem* frameQueueItem;

        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                HAL_ASSERT_AND_EXECUTE(scom->frameBuffer != NULL) {
                        // probably, the frame is from the reception queue (most common case)
                        frameQueueItem = SCOMFrameQueue_GetItemByFrame(&scom->frameBuffer->rxFrameQueue, frame);
                        if (frameQueueItem) {
                                SCOMFrameQueue_Unlock(&scom->frameBuffer->rxFrameQueue, frameQueueItem);
                        } else {
                                // maybe the frame is then from the transmission queue
                                SCOMFrameQueue_Unlock(&scom->frameBuffer->rxFrameQueue, SCOMFrameQueue_GetItemByFrame(&scom->frameBuffer->txFrameQueue, frame));
                        }
                }
        }

} /* SCOM_UnlockFrame */


// -----------------------------------------------------------------------------
//  SCOM_GetStatistics
// -----------------------------------------------------------------------------
SCOMStatistics SCOM_GetStatistics(const SCOMDataLinkDesc* const scom) {
        SCOMStatistics result = {0};
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
#if 1 == HAL_ENABLE_OS
                // before we proceed, acquire mutex guarding access to the SCOM object
                HAL_ASSERT_AND_EXECUTE(0 == OSMUTEX_Take(scom->accessGuard, SCOM_ACCESS_GUARD_TIMEOUT)) {
#endif
                        result = scom->stats; // copy statistics from SCOM descriptor

#if 1 == HAL_ENABLE_OS
                        OSMUTEX_Give(scom->accessGuard);
                }
#endif

        }
        return result;
} /* SCOM_GetStatistics */


// -----------------------------------------------------------------------------
//  SCOM_ResetStatistics
// -----------------------------------------------------------------------------
void SCOM_ResetStatistics(SCOMDataLinkDesc* const scom) {
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
#if 1 == HAL_ENABLE_OS
                // before we proceed, acquire mutex guarding access to the SCOM object
                HAL_ASSERT_AND_EXECUTE(0 == OSMUTEX_Take(scom->accessGuard, SCOM_ACCESS_GUARD_TIMEOUT)) {
#endif
                        scom->stats = (SCOMStatistics) {0};

#if 1 == HAL_ENABLE_OS
                        OSMUTEX_Give(scom->accessGuard);
                }
#endif
        }
} /* SCOM_ResetStatistics */


// -----------------------------------------------------------------------------
//  SCOM_GetDeltaTime
// -----------------------------------------------------------------------------
static uint32_t SCOM_GetDeltaTime(const uint32_t t1, const uint32_t t2) {
        return (t1 >= t2) ? (t1 - t2) : (UINT32_MAX - t2 + t1);
} /* SCOM_GetDeltaTime */


// -----------------------------------------------------------------------------
//  SCOM_ConnectivityCheck
// -----------------------------------------------------------------------------
static void SCOM_ConnectivityCheck(SCOMDataLinkDesc* const scom) {
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                if (scom->connectivityCheckPeriod > 0) {
                        const uint32_t currentTime = scom->clockSource();
                        if (SCOM_GetDeltaTime(currentTime, scom->lastConnectivityCheckTime) > scom->connectivityCheckPeriod) {
                                // connectivity check is needed
                                HAL_LOG_INFO("Connectivity check (PING) scheduled");
                                SCOMResult result = SCOM_SendFrame(scom, 0, SCOM_FRAMETYPE_PING, NULL, 0);
                                if(SCOM_RESULT_OK == result) {
                                        scom->connectivityCheckOutgoingCounter++;
                                } else {
                                        HAL_LOG_ERROR("Unable to send PING. SCOMResult: %d", result);
                                }
                                scom->lastConnectivityCheckTime = currentTime;
                        }
                }
        }
} /* SCOM_ConnectivityCheck */

// -----------------------------------------------------------------------------
//  SCOM_ReceiverTimeOutCheck
// -----------------------------------------------------------------------------
static void SCOM_ReceiverTimeOutCheck(SCOMDataLinkDesc* const scom) {
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                const uint32_t currentTime = scom->clockSource();
                if (SCOM_GetDeltaTime(currentTime, scom->receptionTime) > ((SCOM_MAX_FRAME_REPEAT + 1 )* scom->timeout)) {
                        scom->lastFrameCrc = 0;
                        scom->lastFrameNumber = 0xFF;
                }
        }
} /* SCOM_ReceiverTimeOutCheck */

// -----------------------------------------------------------------------------
//  SCOM_GetNextFrameNumber
// -----------------------------------------------------------------------------
static uint8_t SCOM_GetNextFrameNumber(SCOMDataLinkDesc* const scom) {
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                scom->txCounter++;
                if(scom->txCounter > SCOM_FRAME_CTRL_FRAME_NUMBER_MASK) {
                        scom->txCounter = 0;
                }
                return (uint8_t)scom->txCounter;
        }
        return -1;
} /* SCOM_GetNextFrameNumber */


// -----------------------------------------------------------------------------
//  SCOM_TransmitFrame
// -----------------------------------------------------------------------------
static void SCOM_TransmitFrame(SCOMDataLinkDesc* const scom, SCOMFrameQueueItem *frameQueueItem) {
        if(frameQueueItem != NULL) {
                // get the actual SCOM frame
                SCOMFrame* frame = &frameQueueItem->frame;
                HAL_LOG_INFO("Starting sending [type=%" PRIu8 ", prio=%" PRIu8 ", size=%" PRIu8 "]", frame->type, SCOMFrame_GetPriority(frame), frame->size);

                // this is a new transmission, reset the retransmission counter
                scom->retransmissionCounter = 0;
                // calculate frame CRC
                frame->crc = SCOMFrame_CalculateCRC(frame);
                // write the frame to the IODevice (physically send the frame)
                SCOM_WriteFrameToIODevice(scom, frameQueueItem);

                // update statistics
                scom->stats.framesSent++;
        }
} /* SCOM_TransmitFrame */


// -----------------------------------------------------------------------------
//  SCOM_RetransmitFrame
// -----------------------------------------------------------------------------
static SCOMResult SCOM_RetransmitFrame(SCOMDataLinkDesc* const scom, SCOMFrameQueueItem* const frameQueueItem) {
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                HAL_ASSERT_AND_EXECUTE(frameQueueItem != NULL) {
                        // ACK timeout!
                        if (scom->retransmissionCounter < SCOM_MAX_FRAME_REPEAT) {
                                // mark retransmission
                                scom->retransmissionCounter++;
                                HAL_LOG_WARNING("Retransmission of [type=%" PRIu8 ", prio=%" PRIu8 ", size=%" PRIu8 "]", (&(frameQueueItem->frame))->type, SCOMFrame_GetPriority(&frameQueueItem->frame), (&(frameQueueItem->frame))->size);

                                // write the frame into the IODevice (physically send the frame)
                                SCOM_WriteFrameToIODevice(scom, frameQueueItem);

                                // update statistics
                                scom->stats.retransmissionsSent++;

                                return SCOM_RESULT_OK;
                        } else {
                                // connection is lost
                                scom->connectionState = SCOM_CONNECTION_BROKEN;
                                // unblock the transmitter
                                scom->retransmissionCounter = 0;
                                scom->lastFrameNumber = 0xff;
                                // discard the frame
                                SCOMFrameQueue_Unlock(&scom->frameBuffer->txFrameQueue, frameQueueItem);
                                // report an error
                                //SCOM_REPORT_ERROR(SCOM_ERR__COMMUNICATION_ERROR);

                                return SCOM_COMMUNICATION_ERROR;
                        }
                }
        }
        return SCOM_RESULT_ERROR;
} /* SCOM_RetransmitFrame */


// -----------------------------------------------------------------------------
//  SCOM_WriteFrameToIODevice
// -----------------------------------------------------------------------------
static void SCOM_WriteFrameToIODevice(SCOMDataLinkDesc* const scom, SCOMFrameQueueItem* const frameQueueItem) {
        // the frame is sent in two parts to omit null field in frame structure.
        const size_t firstPartSize = sizeof(frameQueueItem->frame.sync) + sizeof(frameQueueItem->frame.sof) + SCOMFrame_GetPacketControlSize() - sizeof(frameQueueItem->frame.crc);
        // mark transmission time
        scom->sendTime = scom->clockSource();
        // write the frame into IODevice
        IODEV_Write(scom->iodevice, &frameQueueItem->frame, firstPartSize, 0);
        //omit null field
        IODEV_Write(scom->iodevice, &frameQueueItem->frame.crc, SCOMFrame_GetTotalFrameSize(&frameQueueItem->frame) - firstPartSize, 0);

        // mark that the frame is now awaiting ACK
        frameQueueItem->state = SCOM_FRAME_TX_WAIT_FOR_ACK;
} /* SCOM_WriteFrameToIODevice */


// -----------------------------------------------------------------------------
//  SCOM_ReceiveFrame
// -----------------------------------------------------------------------------
static SCOMResult SCOM_ReceiveFrame(SCOMDataLink scom) {
        SCOMFrame *frame;
        size_t available_bytes;
        //
        if(scom->frameBeingReceived == NULL || scom->frameBeingReceived->state == SCOM_FRAME_RX_RECEIVED){
                scom->frameBeingReceived = SCOMFrameQueue_Lock(&scom->frameBuffer->rxFrameQueue);
                if(scom->frameBeingReceived == NULL) {
                        HAL_LOG_INFO("SCOMFrameQueue_Lock failed in SCOM_ReceiveFrame");
                        return  SCOM_ERROR;
                }
        }

        frame = &scom->frameBeingReceived->frame;

        //get available bytes count
        available_bytes = IODEV_GetReadCount(scom->iodevice);

        //read frame control bytes
        if (scom->frameBeingReceived->state != SCOM_FRAME_RX_READ_DATA) {
                // calculate size of packet control fields
                const uint8_t packetControlSize = SCOMFrame_GetPacketControlSize();

                if (available_bytes >= packetControlSize) {
#if true == SCOM_RECEIVED_FRAME_TIMESTAMP
                        frame->received_timestamp = scom->clockSource();
#endif
                        // the frame is received in to parts to omit null field
                        IODEV_Read(scom->iodevice, &frame->ctrl, packetControlSize - sizeof(frame->crc), 0);
                        //omit null field
                        IODEV_Read(scom->iodevice, &frame->crc, sizeof(frame->crc), 0);
                        available_bytes -= packetControlSize;
                        // mark that we started receiving frame
                        scom->frameBeingReceived->state = SCOM_FRAME_RX_READ_DATA;
#if defined SCOM_RECEPTION_TIMEOUT_AFTER_FRAME_START
                        // mark time of the last character received
                        scom->receptionStartTime = scom->clockSource();
#endif
                }
        }

        //receive packet data fields or multiframe control fields and data
        if (scom->frameBeingReceived->state == SCOM_FRAME_RX_READ_DATA) {
                // calculate number of bytes to read
                uint8_t size_to_read;
                if(SCOMFrame_IsMultiframe(frame)){
                        size_to_read = frame->size + sizeof(frame->payload.multiframe.multi_id) + sizeof(frame->payload.multiframe.offset) + sizeof(frame->payload.multiframe.total_size);
                } else {
                        size_to_read = frame->size;
                }

                if(available_bytes >= size_to_read) {
                        if(size_to_read){
                                IODEV_Read(scom->iodevice, &frame->payload.multiframe.multi_id, size_to_read, 0);
                        }

                        //check CRC
                        if(SCOMFrame_CalculateCRC(frame) == frame->crc){

#if defined SCOM_HANDICAP && (SCOM_HANDICAP > 0)
                                static int handicap_count = 0;

                                handicap_count++;
                                if (handicap_count >= SCOM_HANDICAP) {
                                        handicap_count = 0;

                                        // simulate a situation when the CRC is not matching
                                        HAL_LOG_INFO("Frame discarded by implicit handicap [type=%" PRIu8 ", prio=%" PRIu8 ", size=%" PRIu8 "]", frame->type, SCOMFrame_GetPriority(frame), frame->size);

                                        // received frame is discarded
                                        scom->frameBeingReceived->state = SCOM_FRAME_EMPTY;
                                        return SCOM_ERROR;
                                }
#endif

                                // mark that the frame is received completely
                                scom->frameBeingReceived->state = SCOM_FRAME_RX_RECEIVED;
                                return SCOM_RESULT_OK;
                        } else {
                                HAL_LOG_INFO("Frame discarded due to CRC mismatch [type=%" PRIu8 ", prio=%" PRIu8 ", size=%" PRIu8 "]", frame->type, SCOMFrame_GetPriority(frame), frame->size);
                                // received frame is discarded
                                scom->frameBeingReceived->state = SCOM_FRAME_EMPTY;
                                return SCOM_ERROR;
                        }
                } else {
#if defined SCOM_RECEPTION_TIMEOUT_AFTER_FRAME_START
                        // not enough bytes to read, we must check timeout to ensure that a pending frame is not blocking the reception
                        if (SCOM_GetDeltaTime(scom->clockSource(), scom->receptionStartTime) > SCOM_RECEPTION_TIMEOUT_AFTER_FRAME_START) {
                                // received frame is discarded
                                scom->frameBeingReceived->state = SCOM_FRAME_EMPTY;
                                HAL_LOG_INFO("Frame discarded due to timeout after start of reception [type=%" PRIu8 ", prio=%" PRIu8 ", size=%" PRIu8 "]", frame->type, SCOMFrame_GetPriority(frame), frame->size);

                                return SCOM_ERROR;
                        }
#endif

                }
        }

        return SCOM_NO_FRAME;

} /* SCOM_ReceiveFrame */

// -----------------------------------------------------------------------------
//  SCOM_ProcessReceivedFrame
// -----------------------------------------------------------------------------
static bool SCOM_ProcessServiceFrame(SCOMDataLinkDesc* const scom) {
#if SCOM_MAX_SERVICES > 0
        size_t i;
        // try to find service handler matching the frame
        for (i = 0; i < SCOM_MAX_SERVICES; i++) {
                if (scom->serviceHandler[i].serviceID == scom->frameBeingReceived->frame.type) {
                        // found serviceID, check if hanlder exists
                        if (scom->serviceHandler[i].handler) {
                                // handler exists - run it
                                HAL_LOG_DEBUG("Found service frame handler for serviceID=%d. Executing.", scom->serviceHandler[i].serviceID);
                                scom->serviceHandler[i].handler(scom, &scom->frameBeingReceived->frame);
                                return true;
                        } else {
                                // service exists but without handler
                                return false;
                        }
                }
        }
#endif
        return false;
}

// -----------------------------------------------------------------------------
//  SCOM_ProcessReceivedFrame
// -----------------------------------------------------------------------------
static void SCOM_ProcessReceivedFrame(SCOMDataLinkDesc* const scom) {

        SCOMFrame *frame;
        bool frameProcessed;

        // This function is called when a valid frame has been received.
        // The frame is stored in scom->frameBeingReceived

        frame = &scom->frameBeingReceived->frame;

        // Now we check, if this frame is not a retransmission, we already received.
        // Two things happen when a retransmission takes place:
        // 1. frame crc is same
        // 2. frame counter is not incremented
        if ((scom->lastFrameNumber == SCOMFrame_GetFrameNumber(frame) && (scom->lastFrameCrc == frame->crc))) {
                HAL_LOG_WARNING("Frame retransmission detected [type=%" PRIu8 ", prio=%" PRIu8 ", size=%" PRIu8 "]", frame->type, SCOMFrame_GetPriority(frame), frame->size);
                // update statistics
                scom->stats.retransmissionsReceived++;

                // this frame is discarded, as it was already received, unless we're in monitor mode
                if (scom->monitorMode) {
                        // monitor mode
                        if (scom->receptionHandler)  {
                                scom->receptionHandler(scom, &scom->frameBeingReceived->frame);
                        }
                } else {
                        HAL_LOG_WARNING("Frame discarded [type=%" PRIu8 ", prio=%" PRIu8 ", size=%" PRIu8 "]", frame->type, SCOMFrame_GetPriority(frame), frame->size);
                        scom->frameBeingReceived->state = SCOM_FRAME_EMPTY;
                }
        } else {
                // first occurrence of this frame
                scom->lastFrameNumber = SCOMFrame_GetFrameNumber(frame);
                scom->lastFrameCrc = frame->crc;

                // update statistics
                scom->stats.framesReceived++;
                if(true == SCOMFrame_IsMultiframe(frame)) {
                        HAL_LOG_INFO("Multi-frame received [type=%" PRIu8 ", prio=%" PRIu8 ", size=%" PRIu8 ", mid=%" PRIu32 ", offs=%" PRIu32 ", totl=%" PRIu32 "]", frame->type, SCOMFrame_GetPriority(frame), frame->size, frame->payload.multiframe.multi_id, frame->payload.multiframe.offset, frame->payload.multiframe.total_size);
                } else {
                        HAL_LOG_INFO("Frame received [type=%" PRIu8 ", prio=%" PRIu8 ", size=%" PRIu8 "]", frame->type, SCOMFrame_GetPriority(frame), frame->size);
                }

                frameProcessed = true;
                // handle PING, PONG and IDENTIFY packets automatically, unless SCOM runs in monitor mode
                if (scom->monitorMode == false) {
                        SCOMResult tempResult;
                        // not in monitor mode
                        switch (frame->type) {
                        case SCOM_FRAMETYPE_PING:
                                scom->connectivityCheckIncommingCounter++;
                                // answer automatically with PONG, sending back our own connectivity counter
                                tempResult = SCOM_SendFrame(scom, SCOMFrame_GetPriority(frame), SCOM_FRAMETYPE_PONG,
                                                (const void*)&(scom->connectivityCheckIncommingCounter), sizeof(scom->connectivityCheckIncommingCounter));

                                if(SCOM_RESULT_OK != tempResult) {
                                        HAL_LOG_WARNING("Unable to send PONG, result code=%d", tempResult);
                                        scom->connectivityCheckIncommingCounter--;
                                } else {
                                        HAL_LOG_INFO("Sending PONG with outgoingCounter=%" PRIu32, scom->connectivityCheckIncommingCounter);
                                }

                                break;
                        case SCOM_FRAMETYPE_PONG:
                                if (scom->connectivityCheckOutgoingCounter != *((uint32_t*)frame->payload.singleframe.data)) {
                                        scom->connectionState = SCOM_CONNECTION_UNSYNCHRONIZED;
                                        // report an error
                                        //SCOM_REPORT_ERROR(SCOM_ERR__SYNCHRONIZATION_ERROR);
                                        HAL_LOG_CRITICAL("SYNCHRONIZATION ERROR, got PONG with %" PRIu32 ", expected incommingCounter=%" PRIu32, *((uint32_t*)frame->payload.singleframe.data), scom->connectivityCheckOutgoingCounter);
                                }
                                break;
                        case SCOM_FRAMETYPE_IDENTIFY:
                                // answer automatically to IDENTIFY request (request means zero-length frame data size)
                                if (frame->size == 0) {
                                        // test for a possible loopback
                                        const SCOMFrameQueueItem* const loopbackFrame = SCOMFrameQueue_GetFirstInQueue(&scom->frameBuffer->txFrameQueue);
                                        if (loopbackFrame && loopbackFrame->state == SCOM_FRAME_TX_WAIT_FOR_ACK && loopbackFrame->frame.type == SCOM_FRAMETYPE_IDENTIFY) {
                                                // we're receiving an IDENTIFY request, but the same request was just sent and we're waiting for response
                                                // this most probably indicates a loopback connection
                                                HAL_LOG_WARNING("Detected loopback connection");
                                        } else {
                                                // answer to IDENTIFY request
                                                tempResult = SCOM_SendFrame(scom, SCOMFrame_GetPriority(frame), SCOM_FRAMETYPE_IDENTIFY, &scom->id, SCOM_DEVICE_INFO_LEN + scom->serviceCount);

                                                if(SCOM_RESULT_OK != tempResult) {
                                                        HAL_LOG_ERROR("Unable to send IDENTIFY confirmation, result code=%d", tempResult);
                                                } else {
                                                        HAL_LOG_INFO("IDENTIFY confirmation sent");
                                                }
                                        }
                                } else {
                                        // got IDENTIFY response - this needs to be processed by application
                                        frameProcessed = false;
                                }
                                break;
                        default:
                                frameProcessed = false;
                                break;
                        } // switch

                        //unlock frame if was processed
                        if(frameProcessed == true){
                                //SCOM_UnlockFrame(scom, scom->frameBeingReceived);
                                scom->frameBeingReceived->state = SCOM_FRAME_EMPTY;
                        }
                }

                if (frameProcessed == false) {
                        // frame has not yet been processed
                        // try to process the frame as service frame
                        if (!SCOM_ProcessServiceFrame(scom)) {
                                // if this is not a service frame, process it like an ordinary one
                                if (scom->receptionHandler) {
                                        // there is a reception handler - execute it
                                        if(SCOMFrameQueue_Append(&scom->frameBuffer->rxFrameQueue, scom->frameBeingReceived) == true) {
                                                HAL_LOG_INFO("Frame was processed and stored in reception queue");
                                                if (scom->receptionHandler(scom, &scom->frameBeingReceived->frame) == true) {
                                                        HAL_LOG_INFO("Frame was processed and deleted");
                                                        SCOMFrameQueue_Delete(&scom->frameBuffer->rxFrameQueue, scom->frameBeingReceived);
                                                        SCOMFrameQueue_Unlock(&scom->frameBuffer->rxFrameQueue, scom->frameBeingReceived);
                                                }
                                        } else {
                                                HAL_LOG_WARNING("Frame was processed but storing it in reception queue failed");
                                                SCOMFrameQueue_Unlock(&scom->frameBuffer->rxFrameQueue, scom->frameBeingReceived);
                                        }
                                } else {
                                        // no reception handler - store frame
                                        if(SCOMFrameQueue_Append(&scom->frameBuffer->rxFrameQueue, scom->frameBeingReceived) == true) {
                                                HAL_LOG_WARNING("Reception handler is missing. Frame stored in reception queue");
                                        } else {
                                                HAL_LOG_WARNING("Reception handler is missing. Storing frame in reception queue failed");
                                                SCOMFrameQueue_Unlock(&scom->frameBuffer->rxFrameQueue, scom->frameBeingReceived);
                                        }
                                }
                        }
                }
                // either way we're done with the frame
                scom->frameBeingReceived = NULL;

        }

} /* SCOM_ProcessReceivedFrame */


// -----------------------------------------------------------------------------
//  SCOM_SendACK
// -----------------------------------------------------------------------------
static void SCOM_SendACK(SCOMDataLinkDesc* const scom) {
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                // write ACK packet to IODevice
                IODEV_Write(scom->iodevice, &scom->txAck.frame, sizeof(SCOMAckFrame), 0);
                // reset ACK state
                scom->txAck.state = SCOM_FRAME_EMPTY;
        }
} /* SCOM_SendACK */


// -----------------------------------------------------------------------------
//  SCOM_ReceiveACK
// -----------------------------------------------------------------------------
static SCOMResult SCOM_ReceiveACK(SCOMDataLinkDesc* const scom) {
        HAL_ASSERT_AND_EXECUTE(scom != NULL) {
                const uint8_t ackSize = sizeof(SCOMAckFrame) - sizeof(scom->rxAck.frame.sync) - sizeof(scom->rxAck.frame.soack);
                if (IODEV_GetReadCount(scom->iodevice) >= ackSize) {
                        IODEV_Read(scom->iodevice, &scom->rxAck.frame.ctrl, ackSize, 0);
                        return (SCOMAckFrame_CalculateCRC(&scom->rxAck.frame) == scom->rxAck.frame.crc) ? SCOM_RESULT_OK : SCOM_RESULT_CRC_MISMATCH;
                }
                return SCOM_NO_FRAME;
        }
        return SCOM_RESULT_ERROR;
} /* SCOM_ReceiveACK */