rkhtrc_filter.h

Go to the documentation of this file.

/*
 *  --------------------------------------------------------------------------
 *
 *                                Framework RKH
 *                                -------------
 *
 *            State-machine framework for reactive embedded systems
 *
 *                      Copyright (C) 2010 Leandro Francucci.
 *          All rights reserved. Protected by international copyright laws.
 *
 *
 *  RKH is free software: you can redistribute it and/or modify it under the
 *  terms of the GNU General Public License as published by the Free Software
 *  Foundation, either version 3 of the License, or (at your option) any
 *  later version.
 *
 *  RKH is distributed in the hope that it will be useful, but WITHOUT ANY
 *  WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 *  more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with RKH, see copying.txt file.
 *
 *  Contact information:
 *  RKH web site:   http://sourceforge.net/projects/rkh-reactivesys/
 *  e-mail:         francuccilea@gmail.com
 *  ---------------------------------------------------------------------------
 */

/* -------------------------- Development history -------------------------- */
/*
 *  2017.04.15  LeFr  v2.4.05  Initial version
 */

/* -------------------------------- Authors -------------------------------- */
/*
 *  LeFr  Leandro Francucci  francuccilea@gmail.com
 */

/* --------------------------------- Notes --------------------------------- */
/* --------------------------------- Module -------------------------------- */
#ifndef __RKHTRC_FILTER_H__
#define __RKHTRC_FILTER_H__

/* ----------------------------- Include files ----------------------------- */
#include "rkhtrc_define.h"

/* ---------------------- External C language linkage ---------------------- */
#ifdef __cplusplus
extern "C" {
#endif

/* --------------------------------- Macros -------------------------------- */
#if RKH_CFG_TRC_EN == RKH_ENABLED && RKH_CFG_TRC_RTFIL_EN == RKH_ENABLED

    #define RKH_FILTER_ON_GROUP(grp) \
        rkh_trc_filter_group_(FILTER_ON, (grp), EUNCHANGE)

    #define RKH_FILTER_OFF_GROUP(grp) \
        rkh_trc_filter_group_(FILTER_OFF, (grp), EUNCHANGE)

    #define RKH_FILTER_ON_EVENT(evt) \
        rkh_trc_filter_event_(FILTER_ON, (evt))

    #define RKH_FILTER_OFF_EVENT(evt) \
        rkh_trc_filter_event_(FILTER_OFF, (evt))

    #define RKH_FILTER_ON_GROUP_ALL_EVENTS(grp) \
        rkh_trc_filter_group_(FILTER_ON, (grp), ECHANGE)

    #define RKH_FILTER_OFF_GROUP_ALL_EVENTS(grp) \
        rkh_trc_filter_group_(FILTER_OFF, (grp), ECHANGE)

    #if RKH_CFG_TRC_RTFIL_SMA_EN == RKH_ENABLED

        #define RKH_FILTER_ON_SMA(sma) \
            rkh_trc_symFil(RKHFilterSma, RKH_SMA_ACCESS_CONST(sma, prio), \
                           FILTER_ON)

        #define RKH_FILTER_ON_ALL_SMA() \
            rkh_trc_symFil(RKHFilterSma, 0, RKH_TRC_SET_ALL(FILTER_ON))

        #define RKH_FILTER_OFF_SMA(sma) \
            rkh_trc_symFil(RKHFilterSma, RKH_SMA_ACCESS_CONST(sma, prio), \
                           FILTER_OFF)

        #define RKH_FILTER_OFF_ALL_SMA() \
            rkh_trc_symFil(RKHFilterSma, 0, RKH_TRC_SET_ALL(FILTER_OFF))

    #else
        #define RKH_FILTER_ON_SMA(sma)          (void)0
        #define RKH_FILTER_ON_ALL_SMA()         (void)0
        #define RKH_FILTER_OFF_SMA(sma)         (void)0
        #define RKH_FILTER_OFF_ALL_SMA()        (void)0
    #endif

    #if RKH_CFG_TRC_RTFIL_SIGNAL_EN == RKH_ENABLED

        #define RKH_FILTER_ON_SIGNAL(sig) \
            rkh_trc_symFil(RKHFilterSignal, (sig), FILTER_ON)

        #define RKH_FILTER_ON_ALL_SIGNALS() \
            rkh_trc_symFil(RKHFilterSignal, 0, RKH_TRC_SET_ALL(FILTER_ON))

        #define RKH_FILTER_OFF_SIGNAL(sig) \
            rkh_trc_symFil(RKHFilterSignal, (sig), FILTER_OFF)

        #define RKH_FILTER_OFF_ALL_SIGNALS() \
            rkh_trc_symFil(RKHFilterSignal, 0, RKH_TRC_SET_ALL(FILTER_OFF))
    #else
        #define RKH_FILTER_ON_SIGNAL(sig)       (void)0
        #define RKH_FILTER_ON_ALL_SIGNALS()     (void)0
        #define RKH_FILTER_OFF_SIGNAL(sig)      (void)0
        #define RKH_FILTER_OFF_ALL_SIGNALS()    (void)0
    #endif
#else
    #define RKH_FILTER_ON_GROUP(grp)                (void)0
    #define RKH_FILTER_OFF_GROUP(grp)               (void)0
    #define RKH_FILTER_ON_EVENT(evt)                (void)0
    #define RKH_FILTER_OFF_EVENT(evt)               (void)0
    #define RKH_FILTER_ON_GROUP_ALL_EVENTS(grp)     (void)0
    #define RKH_FILTER_OFF_GROUP_ALL_EVENTS(grp)    (void)0
    #define RKH_FILTER_ON_SMA(sma)                  (void)0
    #define RKH_FILTER_ON_ALL_SMA()                 (void)0
    #define RKH_FILTER_OFF_SMA(sma)                 (void)0
    #define RKH_FILTER_OFF_ALL_SMA()                (void)0
    #define RKH_FILTER_ON_SIGNAL(sig)               (void)0
    #define RKH_FILTER_ON_ALL_SIGNALS()             (void)0
    #define RKH_FILTER_OFF_SIGNAL(sig)              (void)0
    #define RKH_FILTER_OFF_ALL_SIGNALS()            (void)0
#endif

/* -------------------------------- Constants ------------------------------ */
/* ------------------------------- Data types ------------------------------ */
#if RKH_TRC_MAX_SMA > RKH_TRC_MAX_SIGNALS
    #if (RKH_TRC_MAX_SMA * 8) <= RKH_BIT(8)
        typedef rui8_t RKH_TRC_FSLOT;
    #elif (RKH_TRC_MAX_SMA * 8) <= RKH_BIT(16)
        typedef rui16_t RKH_TRC_FSLOT;
    #elif (RKH_TRC_MAX_SMA * 8) <= RKH_BIT(32)
        typedef rui32_t RKH_TRC_FSLOT;
    #else
        typedef rui8_t RKH_TRC_FSLOT;
    #endif
#else
    #if (RKH_TRC_MAX_SIGNALS * 8) <= RKH_BIT(8)
        typedef rui8_t RKH_TRC_FSLOT;
    #elif (RKH_TRC_MAX_SIGNALS * 8) <= RKH_BIT(16)
        typedef rui16_t RKH_TRC_FSLOT;
    #elif (RKH_TRC_MAX_SIGNALS * 8) <= RKH_BIT(32)
        typedef rui32_t RKH_TRC_FSLOT;
    #else
        typedef rui8_t RKH_TRC_FSLOT;
    #endif
#endif

typedef struct RKH_TRC_FIL_T
{
    RKH_TRC_FSLOT size;     
    rui8_t *const tbl;      
} RKH_TRC_FIL_T;

typedef enum
{
    FILTER_ON, FILTER_OFF
} RKH_TRC_FOPT;

typedef enum RKHFilter
{
    RKHFilterTrcEvt, RKHFilterSignal, RKHFilterSma,
    RKHFilterNums
} RKHFilter;

typedef struct RKH_FilterTbl
{
    const RKH_TRC_FIL_T *signal;
    const RKH_TRC_FIL_T *ao;
    rui8_t *event;
    rui8_t *group;
    const RKH_GMTBL_T *grpFilMap;
} RKH_FilterTbl;

/* -------------------------- External variables --------------------------- */
/* -------------------------- Function prototypes -------------------------- */
void rkh_trc_filter_group_(rui8_t ctrl, RKH_TG_T grp, rui8_t mode);

void rkh_trc_filter_event_(rui8_t ctrl, RKH_TE_ID_T evt);

rbool_t rkh_trc_isoff_(RKH_TE_ID_T e);

void rkh_trc_symFil(RKHFilter fd, RKH_TRC_FSLOT slot, rui8_t mode);

rbool_t rkh_trc_symFil_isoff(RKHFilter fd, RKH_TRC_FSLOT slot);

void rkh_trc_filter_get(RKH_FilterTbl *outFilterTbl);

/* -------------------- External C language linkage end -------------------- */
#ifdef __cplusplus
}
#endif

/* ------------------------------ Module end ------------------------------- */
#endif

/* ------------------------------ End of file ------------------------------ */