scom_filtering.c

Go to the documentation of this file.

#define HAL_LOG_CHANNEL SCOM
#define HAL_LOG_SUBCHANNEL FILTERING

#include "hal.h"
#include "scom.h"
#include "scom_filtering.h"
//#include "scom_log.h"
#include <string.h>

#ifndef SCOM_FILTERING_ACCESS_GUARD_TIMEOUT
#define SCOM_FILTERING_ACCESS_GUARD_TIMEOUT 5000
#endif

#ifndef SCOM_FILTER_PROC_PERIOD
#define SCOM_FILTER_PROC_PERIOD 40
#endif

// -----------------------------------------------------------------------------
//  SCOM_FilteringFrameReceptionHandler
// -----------------------------------------------------------------------------
bool SCOM_FilteringFrameReceptionHandler(SCOMDataLink scom, SCOMFrame *frame)
{
#if defined SCOM_MAX_FRAME_FILTERS && (SCOM_MAX_FRAME_FILTERS > 0)
        HAL_ASSERT_AND_EXECUTE(NULL != scom) {
                // give a semaphore
                OSCNTSEM_Give(scom->filters.dataReady);
                HAL_LOG_DEBUG("SCOM_FilteringFrameReceptionHandler: Semaphore give.");
                return false; //return false for add frame to queue
        }
#endif
        return true;    //error occurred return true for frame delete
} /* SCOM_FilteringFrameReceptionHandler */

// -----------------------------------------------------------------------------
//  SCOM_FilterProc
// -----------------------------------------------------------------------------
void SCOM_FilterProc(SCOMDataLink scom)
{
#if defined SCOM_MAX_FRAME_FILTERS && (SCOM_MAX_FRAME_FILTERS > 0)
        LLSTItem item;
        SCOMFilter filter;
        SCOMFrame* frame;

        HAL_ASSERT_AND_EXECUTE(NULL != scom) {
                //if some data to filter
                if(OSCNTSEM_Take(scom->filters.dataReady, 0) == 0) {
                        HAL_LOG_DEBUG("SCOM_FilterProc: Processing filter frame.");
#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_FILTERING_ACCESS_GUARD_TIMEOUT))) {
#endif                  
                                //get frame for filtering
                                frame = SCOM_GetReceivedFrame(scom);
                                HAL_ASSERT_AND_EXECUTE(NULL != frame){
                                        // get first item on the filter list
                                        item = LLST_GetFirstItem(&scom->filters.list);
                                        while (item) {
                                                // item data is a pointer to filter
                                                filter = (SCOMFilter)item->data;
                                                // check filter integrity
                                                if ((filter) && (filter->filter_match_function)) {
                                                        // run the filter
                                                        if (filter->filter_match_function(scom, filter, frame)) {
                                                                // filter matched!
                                                                SCOM_UnlockFrame(scom, frame);
#if defined HAL_ENABLE_OS && (HAL_ENABLE_OS == 1)
                                                                // release mutex guarding access to the SCOM object
                                                                OSMUTEX_Give(scom->accessGuard);
#endif
                                                                return;
                                                        }
                                                }
                                                // move to the next item
                                                item = LLST_GetNextItem(item);
                                        }
                                        HAL_LOG_DEBUG("SCOM_FilterProc: Deleting frame. Failed in matching frame, type: %" PRIu8"", frame->type);
                                        SCOM_UnlockFrame(scom, frame);
                                }
#if defined HAL_ENABLE_OS && (HAL_ENABLE_OS == 1)
                                // release mutex guarding access to the SCOM object
                                OSMUTEX_Give(scom->accessGuard);
                        }
#endif
                }
        }
#endif
} /* SCOM_FilterProc */


// -----------------------------------------------------------------------------
//  SCOM_InsertFilter
// -----------------------------------------------------------------------------
SCOMResult SCOM_InsertFilter(SCOMDataLink scom, SCOMFilter filter)
{
        SCOMResult result = SCOM_FILTER_LIST_FULL;
#if defined SCOM_MAX_FRAME_FILTERS && (SCOM_MAX_FRAME_FILTERS > 0)
        HAL_ASSERT_AND_EXECUTE(NULL != scom) {
                HAL_ASSERT_AND_EXECUTE(NULL != filter) {

#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_FILTERING_ACCESS_GUARD_TIMEOUT))) {
#endif

                        if (HALRESULT_OK == LLST_AddItem(&scom->filters.list, filter, NULL)) {
                                result = SCOM_RESULT_OK;
                        }

#if defined HAL_ENABLE_OS && (HAL_ENABLE_OS == 1)
                        // release mutex guarding access to the SCOM object
                        OSMUTEX_Give(scom->accessGuard);
                }
#endif
                }
        }
#endif

        return result;

} /* SCOM_InsertFilter */


// -----------------------------------------------------------------------------
//  SCOM_RemoveFilter
// -----------------------------------------------------------------------------
SCOMResult SCOM_RemoveFilter(SCOMDataLink scom, SCOMFilter filter)
{
        SCOMResult result = SCOM_ERROR;
#if defined SCOM_MAX_FRAME_FILTERS && (SCOM_MAX_FRAME_FILTERS > 0)
        HAL_ASSERT_AND_EXECUTE(NULL != scom) {
                HAL_ASSERT_AND_EXECUTE(NULL != filter) {

#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_FILTERING_ACCESS_GUARD_TIMEOUT))) {
#endif

                        LLSTItem item = LLST_GetItemByData(&scom->filters.list, filter);
                        if (item) {
                                LLST_UnlinkItem(&scom->filters.list, item);
                                result = SCOM_RESULT_OK;
                        }
#if defined HAL_ENABLE_OS && (HAL_ENABLE_OS == 1)
                        // release mutex guarding access to the SCOM object
                        OSMUTEX_Give(scom->accessGuard);
                }
#endif
                }
        }
#endif
        return result;

} /* SCOM_RemoveFilter */


// -----------------------------------------------------------------------------
//  SCOM_InitFiltering
// -----------------------------------------------------------------------------
SCOMResult SCOM_InitFiltering(SCOMDataLink scom)
{
        SCOMResult result = SCOM_ERROR;
#if defined SCOM_MAX_FRAME_FILTERS && (SCOM_MAX_FRAME_FILTERS > 0)

        HAL_ASSERT_AND_EXECUTE(NULL != scom) {
#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_FILTERING_ACCESS_GUARD_TIMEOUT))) {
#endif
                        // clear the memory space used for filters
                        memset(scom->filters.pool, 0x00, sizeof(LLSTItemDesc) * SCOM_MAX_FRAME_FILTERS);
                        // initialize link list
                        LLST_Init(&scom->filters.list, scom->filters.pool, SCOM_MAX_FRAME_FILTERS);
                        //
                        if (scom->frameBuffer->rxFrameQueue.size > 0) {
                                scom->filters.dataReady = OSCNTSEM_Create(0, scom->frameBuffer->rxFrameQueue.size);
                        } else {
                                scom->filters.dataReady = OSCNTSEM_Create(0, 255);
                        }
#if defined HAL_ENABLE_OS && (HAL_ENABLE_OS == 1)
                                // release mutex guarding access to the SCOM object
                                OSMUTEX_Give(scom->accessGuard);
                        }
#endif
                // Set filtering reception handler
                SCOM_SetFrameReceptionHandlerFunc(scom, SCOM_FilteringFrameReceptionHandler);

                result = SCOM_RESULT_OK;
        }
#endif
        return result;

} /* SCOM_InitFiltering */


// -----------------------------------------------------------------------------
//  SCOM_DeinitFiltering
// -----------------------------------------------------------------------------
SCOMResult SCOM_DeinitFiltering(SCOMDataLink scom)
{
        SCOMResult result = SCOM_ERROR;
#if defined SCOM_MAX_FRAME_FILTERS && (SCOM_MAX_FRAME_FILTERS > 0)
        HAL_ASSERT_AND_EXECUTE(NULL != scom) {

#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_FILTERING_ACCESS_GUARD_TIMEOUT))) {
#endif

                if (scom->filters.dataReady) {
                        OSCNTSEM_Destroy(scom->filters.dataReady);
                        scom->filters.dataReady = NULL;
                }
                result = SCOM_RESULT_OK;

#if defined HAL_ENABLE_OS && (HAL_ENABLE_OS == 1)
                        // release mutex guarding access to the SCOM object
                        OSMUTEX_Give(scom->accessGuard);
                }
#endif
        }
#endif
        return result;
} /* SCOM_DeinitFiltering */


#if defined SCOM_MAX_FRAME_FILTERS && (SCOM_MAX_FRAME_FILTERS > 0)

// -----------------------------------------------------------------------------
//  SCOM_FilterThread
// -----------------------------------------------------------------------------
static int SCOM_FilterThread(void* param)
{
        HAL_ASSERT_AND_EXECUTE(NULL != param) {
                SCOMDataLink scom = (SCOMDataLink)param;

                HAL_ASSERT_AND_EXECUTE(NULL != scom) {

                        while (OSTASK_IsAlive()) {
                                SCOM_FilterProc(scom);
                                OS_Sleep(SCOM_FILTER_PROC_PERIOD);
                        }
                }
        }
        return 0;
} /* SCOM_ProcThread */

#endif


// -----------------------------------------------------------------------------
//  SCOM_RunFilteringThread
// -----------------------------------------------------------------------------
SCOMResult SCOM_RunFilteringThread(SCOMDataLink scom) {
#if defined SCOM_MAX_FRAME_FILTERS && (SCOM_MAX_FRAME_FILTERS > 0)
#if defined HAL_ENABLE_OS && (HAL_ENABLE_OS == 1)
        HAL_ASSERT_AND_EXECUTE(NULL != scom) {
                // run the filtering thread
                scom->filterTask = OSTASK_Create(SCOM_FilterThread, HAL_OSTASK_JOINABLE | HAL_OSTASK_MORTAL, HAL_OSTASK_PRIORITY_NORMAL, 0, scom);
                HAL_ASSERT_AND_EXECUTE(OSTASK_IsValid(scom->filterTask)) {
                        return SCOM_RESULT_OK;
                }
        }
#endif
#endif
        return SCOM_ERROR;
} /* SCOM_RunFilteringThread */

// -----------------------------------------------------------------------------
//  SCOM_StopFilteringThread
// -----------------------------------------------------------------------------
void SCOM_StopFilteringThread(SCOMDataLink scom) {
#if defined SCOM_MAX_FRAME_FILTERS && (SCOM_MAX_FRAME_FILTERS > 0)
#if defined HAL_ENABLE_OS && (HAL_ENABLE_OS == 1)
        HAL_ASSERT_AND_EXECUTE(NULL != scom) {
                // send the termination signal
                OSTASK_Kill(scom->filterTask);
                // wait for the thread to finish
                if (!OSTASK_Join(scom->filterTask, 10000, NULL)) {
                        HAL_LOG_WARNING("Unable to stop SCOM filtering thread");
                }
        }
#endif
#endif

} /* SCOM_StopFilteringThread */