scom_service.c

Go to the documentation of this file.

#define HAL_LOG_CHANNEL SCOM
#define HAL_LOG_SUBCHANNEL SERVICE

#include "hal.h"
#include "scom_service.h"
#include "scom_service_filter.h"
#include "scom_frame.h"
#include <string.h>

// -----------------------------------------------------------------------------
//  SCOM_SendServiceFrame
// -----------------------------------------------------------------------------
SCOMResult SCOM_SendServiceFrame(SCOMDataLink scom, uint8_t framePriority, uint8_t serviceID, uint8_t primitiveID, const void* frameData, uint8_t frameDataSize) {
        HAL_ASSERT_AND_EXECUTE(NULL != scom) {
                HAL_ASSERT_AND_EXECUTE(NULL != scom->frameBuffer) {
      // Find empty frame
      SCOMFrameQueueItem* frameQueueItem = SCOMFrameQueue_Lock(&scom->frameBuffer->txFrameQueue);
      if(NULL != frameQueueItem) {
        SCOMFrame* const frame = &frameQueueItem->frame;
        *frame = (SCOMFrame ) {
          .sof = SCOM_SOF_CHARACTER,
          .type = serviceID,
          .null = 0,
          .size = frameDataSize + 1,
          .payload = { .serviceframe.primitive_id = primitiveID }
        };
        SCOMFrame_SetPriority(frame, framePriority);
        if(frameDataSize > 0) { // fixme check if the size doesn't exceed the buffer size
          memcpy(frame->payload.serviceframe.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_ERROR;

} /* SCOM_SendServiceFrame */


// -----------------------------------------------------------------------------
//  SCOM_SendServiceMultiFrame
// -----------------------------------------------------------------------------
SCOMResult SCOM_SendServiceMultiFrame(SCOMDataLink scom, uint8_t framePriority, uint8_t serviceID, uint8_t primitiveID,
                               const void* frameData, uint32_t frameDataSize, SCOMMultiFrameDesc* multiFrameDesc)
{
    SCOMResult result = SCOM_ERROR;
    SCOMFrameQueueItem *frameQueueItem;
    SCOMFrame *frame;
    size_t frameCount;

    HAL_ASSERT_AND_EXECUTE(NULL != scom) {
        HAL_ASSERT_AND_EXECUTE(NULL != scom->frameBuffer) {
                HAL_ASSERT_AND_EXECUTE(NULL != multiFrameDesc) {
                        // 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 = serviceID;
                                frame->null = 0;
                                //clear old settings and set multiframe id bit
                                frame->ctrl = SCOM_FRAME_CTRL_MULTI_ID_MASK;
                                SCOMFrame_SetPriority(frame, framePriority);
                                // calculate how many frame will be within the multi-frame
                                frameCount = frameDataSize / SCOMFrame_GetMaxServiceMultiframePayloadSize();
                                if (frameDataSize % SCOMFrame_GetMaxServiceMultiframePayloadSize()) {
                                        frameCount++;
                                }
                                frame->payload.servicemultiframe.offset = multiFrameDesc->progress;
                                // each frame adds one extra byte for primitiveID
                                frame->payload.servicemultiframe.total_size = frameDataSize + frameCount;
                                frame->payload.servicemultiframe.primitive_id = primitiveID;

                                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.servicemultiframe.multi_id = scom->multiCounter;
                                        // save id in a multiFrameDesc descriptor
                                        multiFrameDesc->multi_id = scom->multiCounter;
                                } else {
                                        // multi id already assigned
                                        frame->payload.servicemultiframe.multi_id = multiFrameDesc->multi_id;
                                }

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

                                        frame->size = (uint8_t)size+1;
                                        memcpy(frame->payload.servicemultiframe.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_SendServiceMultiFrame */

// -----------------------------------------------------------------------------
//  SCOM_ServiceTransaction
// -----------------------------------------------------------------------------
SCOMResult SCOM_ServiceTransaction(SCOMDataLink scom, const uint8_t framePriority, const uint8_t serviceID, const uint8_t primitiveID, const void* const txData, const uint8_t txDataSize, void* rxData, const size_t rxDataSize) {
  SCOMResult result = SCOM_ERROR;
  HAL_ASSERT_AND_EXECUTE(NULL != scom) {
    SCOMServiceMatchFilter filter;
    if(SCOM_RESULT_OK == SCOM_InitializeServiceMatchFilter(&filter, rxData, rxDataSize)) { // Initialize the filter
      if(SCOM_RESULT_OK == SCOM_SetupServiceMatchFilter(&filter, serviceID, primitiveID)) { // Setup frame-type matching SCOM filter to catch confirmation
        result = SCOM_InsertFilter(scom, &filter.filter); // Insert filter into SCOM
        if(SCOM_RESULT_OK == result) {
          result = SCOM_SendServiceFrame(scom, framePriority, serviceID, primitiveID, txData, txDataSize);
          if(SCOM_RESULT_OK == result) {
            result = SCOM_WaitForServiceFilter(&filter, 3000);
            SCOM_RemoveFilter(scom, &filter.filter); // remove filter
          }
        }
      }
      SCOM_DeinitializeServiceMatchFilter(&filter); // Deinitialize the filter
    }
  }
  return result;
} /* SCOM_ServiceTransaction */