rkhcfg.h

/**
 *  \file       rkhcfg.c
 *  \brief      RKH user configuration.
 */

#ifndef __RKHCFG_H__
#define __RKHCFG_H__

/**
 *  Defines standard constants and macros.
 */
#include "rkhdef.h"

/* --- Configuration options related to framework ------------------------- */

/**
 *	Specify the maximum number of state machine applications (SMA) to be used
 *	by the application (can be a number in the range [1..64]).
 */
#define RKH_CFG_FWK_MAX_SMA             2u

/**
 *	If the dynamic event support (see #RKH_CFG_FWK_DYN_EVT_EN) is set to
 *	1, RKH allows to use event with parameters, defer/recall, allocating
 *	and recycling dynamic events, among other features.
 */
#define RKH_CFG_FWK_DYN_EVT_EN          RKH_ENABLED

/**
 *	If the dynamic event support is enabled (see #RKH_CFG_FWK_DYN_EVT_EN)
 *	then the #RKH_CFG_FWK_MAX_EVT_POOL can be used to specify the maximum
 *	number of fixed-size memory block pools to be used by the application
 *	(can be a number in the range [0..256]).
 *	Note that a value of 0 will completely suppress the memory pool services.
 */
#define RKH_CFG_FWK_MAX_EVT_POOL        3u

/**
 *  Specify the size of the event signal. The valid values [in bits] are
 *  8, 16 or 32. Default is 8. The higher the signal size, the higher the
 *  event structure size and therefore more memory consumption.
 *  See #RKH_SIG_T data type.
 */
#define RKH_CFG_FWK_SIZEOF_EVT          8u

/**
 *	Specify the maximum number of event signals to be used by the
 *	application.
 */
#define RKH_CFG_FWK_MAX_SIGNALS         16u

/**
 *  Specify the data type of event size. The valid values [in bits] are
 *  8, 16 or 32. Default is 8. See #RKH_ES_T, rkh_fwk_epool_register(), and
 *	RKH_ALLOC_EVT(). Use a 8 value if the bigger event size is minor to
 *	256 bytes.
 */
#define RKH_CFG_FWK_SIZEOF_EVT_SIZE     16u

/**
 *	If the #RKH_CFG_FWK_DEFER_EVT_EN is set to 1 and the dynamic event
 *	support is enabled (see #RKH_CFG_FWK_DYN_EVT_EN), RKH enables the
 *	defer and recall event features.
 */
#define RKH_CFG_FWK_DEFER_EVT_EN        RKH_DISABLED

/**
 *	If the #RKH_CFG_FWK_ASSERT_EN is set to 0 the checking assertions are
 *	disabled.
 *  In particular macros RKH_ASSERT(), RKH_REQUIRE(), RKH_ENSURE(),
 *  RKH_INVARIANT(), and RKH_ERROR() do NOT evaluate the test condition
 *  passed as the argument to these macros. One notable exception is the
 *  macro RKH_ALLEGE(), that still evaluates the test condition, but does
 *  not report assertion failures when the #RKH_CFG_FWK_ASSERT_EN is enabled.
 */
#define RKH_CFG_FWK_ASSERT_EN           RKH_ENABLED

/**
 *  \brief
 *  If the #RKH_CFG_FWK_PUBSUB_EN is set to 1 then RKH will include the native
 *  publish-subscriber module.
 *
 *  \type       Boolean
 *  \range      
 *  \default    RKH_ENABLED
 */
#define RKH_CFG_FWK_PUBSUB_EN           RKH_ENABLED

/**
 *  \brief
 *  Specify the maximum number of channels (topics) to which an active 
 *  object wants to subscribe (can be a number in the range [1..128]).
 *
 *  \type       Integer
 *  \range      [1..128]
 *  \default    16
 */
#define RKH_CFG_FWK_MAX_SUBS_CHANNELS   16

/**
 *	If the #RKH_CFG_HOOK_DISPATCH_EN is set to 1, RKH will invoke the
 *	dispatch hook function rkh_hook_dispatch() when dispatching an event to
 *	a SMA. When this is set the application must provide the hook function.
 */
#define RKH_CFG_HOOK_DISPATCH_EN        RKH_DISABLED

/**
 *	If the #RKH_CFG_HOOK_SIGNAL_EN is set to 1, RKH will invoke the signal
 *	hook function rkh_hook_signal() when the producer of an event directly
 *	posts the event to the event queue of the consumer SMA.
 *	When this is set the application must provide the hook function.
 */
#define RKH_CFG_HOOK_SIGNAL_EN          RKH_DISABLED

/**
 *	If the #RKH_CFG_HOOK_TIMEOUT_EN is set to 1, RKH will invoke the timeout
 *	hook function rkh_hook_timeout() when a timer expires just before the
 *	assigned event is directly posted into the state machine application
 *	queue.
 *	When this is set the application must provide the hook function.
 */
#define RKH_CFG_HOOK_TIMEOUT_EN         RKH_DISABLED

/**
 *	If the #RKH_CFG_HOOK_START_EN is set to 1, RKH will invoke the start
 *	hook function rkh_hook_start() just before the RKH takes over control of
 *  the application.
 *	When this is set the application must provide the hook function.
 */
#define RKH_CFG_HOOK_START_EN           RKH_ENABLED

/**
 *	If the #RKH_CFG_HOOK_EXIT_EN is set to 1, RKH will invoke the exit
 *	hook function just before it returns to the underlying OS/RTOS. Usually,
 *	the rkh_hook_exit() is useful when executing clean-up code upon SMA
 *	terminate or framework exit.
 *	When this is set the application must provide the hook function.
 */
#define RKH_CFG_HOOK_EXIT_EN            RKH_ENABLED

/**
 *	If the #RKH_CFG_HOOK_TIMETICK_EN is set to 1, RKH will invoke the time
 *	tick hook function from rkh_tmr_tick(), at the very beginning of that,
 *	to give priority to user or port-specific code when the tick interrupt
 *	occurs.
 *	Usually, the rkh_hook_timetick() allows to the application to extend the
 *	functionality of RKH, giving the port developer the opportunity to add
 *	code that will be called by rkh_tmr_tick(). Frequently, the
 *	rkh_hook_timetick() is called from the tick ISR and must not make any
 *	blocking calls and must execute as quickly as possible.
 *	When this is set the application must provide the hook function.
 */
#define RKH_CFG_HOOK_TIMETICK_EN        RKH_ENABLED

/**
 *  If the #RKH_CFG_HOOK_PUT_TRCEVT_EN is set to 1, RKH will invoke the
 *  rkh_hook_putTrcEvt() function from rkh_trc_end() function, at the end of
 *  that, to allow to the application to extend the functionality of RKH,
 *  giving the port developer the opportunity to add code that will be called
 *  when is put a trace event into the stream buffer.
 *  When this is set the application must provide the hook function.
 */
#define RKH_CFG_HOOK_PUT_TRCEVT_EN        RKH_DISABLED

/**
 *  Specify the frequency of the framework tick interrupt (number of ticks
 *  in one second). It's the rate at which the rkh_tmr_tick() function is
 *  invoked. This configuration constant is not used by RKH, it is just a
 *  value to allow an application to deal with time when using timer
 *  services, converting ticks to time. See RKH_TICK_RATE_MS constant.
 */
#define RKH_CFG_FWK_TICK_RATE_HZ            100u

/* --- Configuration options related to state machine applications -------- */

/**
 *	If the #RKH_CFG_SMA_GET_INFO_EN is set to 1 then RKH will include the
 *	rkh_clear_info() and rkh_get_info() functions.
 */
#define RKH_CFG_SMA_GET_INFO_EN         RKH_DISABLED

/**
 *	If the #RKH_CFG_SMA_PPRO_EN is set to 1 then RKH allows to reference a
 *	event preprocessor to any basic state. Aditionally, by means of single
 *	inheritance in C it could be used as state's abstract data.
 *	Moreover, implementing the single inheritance in C is very simply by
 *	literally embedding the base type, #RKH_PPRO_T in this case, as the first
 *	member of the derived structure. See \a prepro member of #RKH_ST_T
 *	structure for more information.
 */
#define RKH_CFG_SMA_PPRO_EN             RKH_DISABLED

/**
 *	If the #RKH_CFG_SMA_HCAL_EN is set to 1, the RKH allows state nesting.
 *	When #RKH_CFG_SMA_HCAL_EN is set to 0 some important features of RKH are
 *	not included: state nesting, composite state, history (shallow and deep)
 *	pseudostate, entry action, and exit action.
 */
#define RKH_CFG_SMA_HCAL_EN             RKH_ENABLED

/**
 *  Specify the maximum number of hierarchical levels. The smaller this
 *  number, the lower the RAM consumption. Typically, the most of
 *  hierarchical state machines uses up to 4 levels. Currently
 *  #RKH_CFG_SMA_MAX_HCAL_DEPTH cannot exceed 8.
 */
#define RKH_CFG_SMA_MAX_HCAL_DEPTH      2u

/**
 *	Specify the maximum number of linked transition segments. The smaller
 *	this number, the lower the RAM consumption. Typically, the most of
 *	hierarchical state machines uses up to 4 transition segments.
 *	Currently #RKH_CFG_SMA_MAX_TRC_SEGS cannot exceed 8.
 */
#define RKH_CFG_SMA_MAX_TRC_SEGS        2u

/**
 *	If the #RKH_CFG_SMA_PSEUDOSTATE_EN is set to 1, the RKH allows
 *	pseudostates usage.
 */
#define RKH_CFG_SMA_PSEUDOSTATE_EN      RKH_DISABLED

/**
 *	If the #RKH_CFG_SMA_DEEP_HIST_EN and #RKH_CFG_SMA_PSEUDOSTATE_EN are
 *	set to 1, the RKH allows deep history pseudostate usage.
 */
#define RKH_CFG_SMA_DEEP_HIST_EN        RKH_DISABLED

/**
 *	If the #RKH_CFG_SMA_SHALLOW_HIST_EN and #RKH_CFG_SMA_PSEUDOSTATE_EN
 *	are set to 1, the RKH allows shallow history pseudostate usage.
 */
#define RKH_CFG_SMA_SHALLOW_HIST_EN     RKH_DISABLED

/**
 *	If the #RKH_CFG_SMA_CHOICE_EN and #RKH_CFG_SMA_PSEUDOSTATE_EN are set to
 *	1, the RKH allows choice pseudostate usage.
 */
#define RKH_CFG_SMA_CHOICE_EN           RKH_DISABLED

/**
 *	If the #RKH_CFG_SMA_CONDITIONAL_EN and #RKH_CFG_SMA_PSEUDOSTATE_EN are
 *	set to 1, the RKH allows branch (or conditional) pseudostate usage.
 */
#define RKH_CFG_SMA_CONDITIONAL_EN      RKH_DISABLED

/**
 *	If the #RKH_CFG_SMA_SUBMACHINE_EN and #RKH_CFG_SMA_PSEUDOSTATE_EN are
 *	set to 1, the RKH allows submachine state (and exit/entry points) usage.
 */
#define RKH_CFG_SMA_SUBMACHINE_EN       RKH_DISABLED

/**
 *	If the #RKH_CFG_SMA_TRC_SNDR_EN and #RKH_CFG_TRC_EN are set to 1,
 *	when posting an event the RKH inserts a pointer to the sender object.
 */
#define RKH_CFG_SMA_TRC_SNDR_EN         RKH_DISABLED

/**
 *	If the #RKH_CFG_SMA_INIT_EVT_EN is set to 1 then an initial event could
 *	be be passed to state machine application when it starts, like an
 *	argc/argv. Also, the #RKH_CFG_SMA_INIT_EVT_EN changes the initial action
 *	prototype.
 */
#define RKH_CFG_SMA_INIT_EVT_EN         RKH_DISABLED

/* --- Configuration options related to SMA action featues ---------------- */

/**
 *	If the #RKH_CFG_SMA_ENT_ARG_SMA_EN is set to 1 then the entry action
 *	prototype will add as argument a pointer to state machine structure
 *	#RKH_SMA_T. See #RKH_ENT_ACT_T definition.
 */
#define RKH_CFG_SMA_ENT_ARG_SMA_EN      RKH_ENABLED

/**
 *	If the #RKH_CFG_SMA_ENT_ARG_STATE_EN is set to 1 then the entry action
 *	prototype will add as argument a pointer to "this" state structure
 *	#RKH_ST_T. See #RKH_ENT_ACT_T definition.
 */
#define RKH_CFG_SMA_ENT_ARG_STATE_EN    RKH_DISABLED

/**
 *	If the #RKH_CFG_SMA_EXT_ARG_SMA_EN is set to 1 then the exit action
 *	prototype will add as argument a pointer to state machine structure
 *	#RKH_SMA_T. See #RKH_EXT_ACT_T definition.
 */
#define RKH_CFG_SMA_EXT_ARG_SMA_EN      RKH_ENABLED

/**
 *	If the #RKH_CFG_SMA_EXT_ARG_STATE_EN is set to 1 then the exit action
 *	prototype will add as argument a pointer to "this" state structure
 *	#RKH_ST_T. See #RKH_EXT_ACT_T definition.
 */
#define RKH_CFG_SMA_EXT_ARG_STATE_EN    RKH_DISABLED

/**
 *	If the #RKH_CFG_SMA_ACT_ARG_SMA_EN is set to 1 then the transition action
 *	prototype will add as argument a pointer to state machine structure
 *	#RKH_SMA_T. See #RKH_TRN_ACT_T definition.
 */
#define RKH_CFG_SMA_ACT_ARG_SMA_EN      RKH_ENABLED

/**
 *	If the #RKH_CFG_SMA_ACT_ARG_EVT_EN is set to 1 then the transition action
 *	prototype will add as argument a pointer to ocurred event.
 *	See RKH_TRN_ACT_T definition.
 */
#define RKH_CFG_SMA_ACT_ARG_EVT_EN      RKH_ENABLED

/**
 *	If the #RKH_CFG_SMA_GRD_ARG_EVT_EN is set to 1 then the transition guard
 *	prototype will add as argument a pointer to ocurred event.
 *	See RKH_GUARD_T definition.
 */
#define RKH_CFG_SMA_GRD_ARG_EVT_EN      RKH_ENABLED

/**
 *	If the #RKH_CFG_SMA_GRD_ARG_SMA_EN is set to 1 then the transition guard
 *	prototype will add as argument a pointer to state machine structure
 *	RKH_SMA_T. See RKH_GUARD_T definition.
 */
#define RKH_CFG_SMA_GRD_ARG_SMA_EN      RKH_ENABLED

/**
 *	If the #RKH_CFG_SMA_PPRO_ARG_SMA_EN is set to 1 then the event preprocessor
 *	(Moore function like entry and exit actions) prototype will add as
 *	argument a pointer to state machine structure
 *	RKH_SMA_T. See RKH_PPRO_T definition.
 */
#define RKH_CFG_SMA_PPRO_ARG_SMA_EN     RKH_ENABLED

/**
 *  \brief
 *  If RKH_CFG_SMA_SM_CONST_EN is set to RKH_ENABLED then much of the state
 *  machine object is allocated in ROM. This approach does have as key benefit
 *  the little RAM consuming as compared when RKH_CFG_SMA_SM_CONST_EN is set
 *  to RKH_DISABLED.
 *  Nevertheless, the primary drawback of this approach is the obfuscated API
 *  to use it.
 *  In constrast, if RKH_CFG_SMA_SM_CONST_EN is set to RKH_ENABLED then the
 *  whole state machine object is allocated in RAM, including its own
 *  constant part. However, the API to use it is very simple, intuitive,
 *  and flexible, allowing easily the dynamic memory allocation
 */
#define RKH_CFG_SMA_SM_CONST_EN         RKH_ENABLED

/**
 *  \brief
 *  If RKH_CFG_SMA_RT_CTOR_EN is set to RKH_ENABLED then is allowed the use
 *  of run-time constructors of RKH_SM_T and RKH_SMA_T classes, rkh_sm_ctor()
 *  and rkh_sma_ctor() respectively.
 *
 *  \type       Boolean
 *  \range
 *  \default    RKH_DISABLED
 */
#define RKH_CFG_SMA_RT_CTOR_EN          RKH_DISABLED

/**
 *  \brief
 *  If RKH_CFG_SMA_VFUNCT_EN is set to RKH_ENABLED, the active objects are
 *  defined as polymorphics, since it incorporates a virtual table of
 *  functions. See the default virtual table rkhSmaVtbl to known the
 *  available polymorphic operations.
 *
 *  \type       Boolean
 *  \range
 *  \default    RKH_DISABLED
 */
#define RKH_CFG_SMA_VFUNCT_EN           RKH_DISABLED

/**
 *  \brief
 *  If RKH_CFG_SMA_ORTHREG_EN is set to RKH_ENABLED, the state machine 
 *  functions are reentrant, therefore it could be used as workaround to 
 *  easily emulates a state machine or composite state with orthogonal 
 *  regions, for example, dispatching the same event to multiple state 
 *  machines (regions) at the same time.
 *
 *  \type       Boolean
 *  \range
 *  \default    RKH_DISABLED
 */
#define RKH_CFG_SMA_ORTHREG_EN          RKH_ENABLED

/* --- Configuration options related to trace facility -------------------- */

/**
 *	If the #RKH_CFG_TRC_EN is set to 1 then RKH will include the trace
 *	facility.
 */
#define RKH_CFG_TRC_EN                  RKH_ENABLED

/**
 *	If the #RKH_CFG_TRC_RTFIL_EN is set to 1 then RKH will include
 *	the runtime trace filter facility.
 *  When #RKH_CFG_TRC_RTFIL_EN is enabled RKH also will
 *  automatically define RKH_FILTER_ON_GROUP(), RKH_FILTER_OFF_GROUP(),
 *  RKH_FILTER_ON_EVENT(), RKH_FILTER_OFF_EVENT(),
 *  RKH_FILTER_ON_GROUP_ALL_EVENTS(), RKH_FILTER_OFF_GROUP_ALL_EVENTS(),
 *  RKH_FILTER_ON_SMA(), and RKH_FILTER_OFF_SMA() macros.
 */
#define RKH_CFG_TRC_RTFIL_EN            RKH_ENABLED

/**
 *	If the #RKH_CFG_TRC_RTFIL_EN and #RKH_CFG_TRC_RTFIL_SMA_EN are
 *	set to 1, the RKH allows the usage of runtime trace filter for state
 *	machine applications (active objects).
 */
#define RKH_CFG_TRC_RTFIL_SMA_EN        RKH_ENABLED

/**
 *	If the #RKH_CFG_TRC_RTFIL_EN and #RKH_CFG_TRC_RTFIL_SIGNAL_EN
 *	are set to 1, the RKH allows the usage of runtime trace filter for
 *	signals (events).
 */
#define RKH_CFG_TRC_RTFIL_SIGNAL_EN     RKH_ENABLED

/**
 *	If the #RKH_CFG_TRC_USER_TRACE_EN is set to 1 then RKH will allow to
 *	build and generate tracing information from the application-level code.
 *	This trace records are application-specific.
 */
#define RKH_CFG_TRC_USER_TRACE_EN       RKH_DISABLED

/**
 *	If the #RKH_CFG_TRC_ALL_EN is set to 1 then RKH will include all its own
 *	trace records.
 */
#define RKH_CFG_TRC_ALL_EN              RKH_ENABLED

/**
 *	If the #RKH_CFG_TRC_MP_EN is set to 1 then RKH will include all trace
 *	records related to the native fixed-size memory blocks.
 */
#define RKH_CFG_TRC_MP_EN               RKH_DISABLED

/**
 *	If the #RKH_CFG_TRC_QUE_EN is set to 1 then RKH will include all trace
 *	records related to the native queues.
 */
#define RKH_CFG_TRC_QUE_EN               RKH_DISABLED

/**
 *	If the #RKH_CFG_TRC_SMA_EN is set to 1 then RKH will include all trace
 *	records related to the state machine applications.
 */
#define RKH_CFG_TRC_SMA_EN              RKH_DISABLED

/**
 *	If the #RKH_CFG_TRC_TMR_EN is set to 1 then RKH will include all trace
 *	records related to the native software timer.
 */
#define RKH_CFG_TRC_TMR_EN              RKH_ENABLED

/**
 *	If the #RKH_CFG_TRC_SM_EN is set to 1 then RKH will include all trace
 *	records related to the state machine (hierarchical and "flat").
 */
#define RKH_CFG_TRC_SM_EN               RKH_ENABLED

/**
 *	If the #RKH_CFG_TRC_FWK_EN is set to 1 then RKH will include all trace
 *	records related to the nativenative  event framework.
 */
#define RKH_CFG_TRC_FWK_EN              RKH_ENABLED

/**
 *	If the #RKH_CFG_TRC_ASSERT_EN and #RKH_CFG_TRC_FWK_EN are set to 1 then
 *	RKH will include the "assertion" trace record.
 */
#define RKH_CFG_TRC_ASSERT_EN           RKH_ENABLED

/**
 *	If the #RKH_CFG_TRC_SM_INIT_EN and #RKH_CFG_TRC_SM_EN are set to 1 then
 *	RKH will include the "init state machine" trace record.
 */
#define RKH_CFG_TRC_SM_INIT_EN          RKH_ENABLED

/**
 *	If the #RKH_CFG_TRC_SM_DCH_EN and #RKH_CFG_TRC_SM_EN are set to 1 then
 *	RKH will include the "start a state machine" trace record.
 */
#define RKH_CFG_TRC_SM_DCH_EN          RKH_ENABLED

/**
 *	If the #RKH_CFG_TRC_SM_CLRH_EN and #RKH_CFG_TRC_SM_EN are set to 1 then
 *	RKH will include the "dispatch an event to state machine" trace record.
 */
#define RKH_CFG_TRC_SM_CLRH_EN          RKH_DISABLED

/**
 *	If the #RKH_CFG_TRC_SM_CLRH_EN and #RKH_CFG_TRC_SM_EN are set to 1 then
 *	RKH will include the "clear the history pseudostate" trace record.
 */
#define RKH_CFG_TRC_SM_TRN_EN           RKH_ENABLED

/**
 *	If the #RKH_CFG_TRC_SM_STATE_EN and #RKH_CFG_TRC_SM_EN are set to 1 then
 *	RKH will include the "final state of transition" trace record.
 */
#define RKH_CFG_TRC_SM_STATE_EN         RKH_ENABLED

/**
 *	If the #RKH_CFG_TRC_SM_CLRH_EN and #RKH_CFG_TRC_SM_EN are set to 1 then
 *	RKH will include the "entry state" trace record.
 */
#define RKH_CFG_TRC_SM_ENSTATE_EN       RKH_ENABLED

/**
 *	If the #RKH_CFG_TRC_SM_CLRH_EN and #RKH_CFG_TRC_SM_EN are set to 1 then
 *	RKH will include the "exit state" trace record.
 */
#define RKH_CFG_TRC_SM_EXSTATE_EN       RKH_ENABLED

/**
 *	If the #RKH_CFG_TRC_SM_CLRH_EN and #RKH_CFG_TRC_SM_EN are set to 1 then
 *	RKH will include the "number of entry and exit states in transition"
 *	trace record.
 */
#define RKH_CFG_TRC_SM_NENEX_EN         RKH_DISABLED

/**
 *	If the #RKH_CFG_TRC_SM_CLRH_EN and #RKH_CFG_TRC_SM_EN are set to 1 then
 *	RKH will include the "number of executed actions in transition" trace
 *	record.
 */
#define RKH_CFG_TRC_SM_NTRNACT_EN       RKH_DISABLED

/**
 *	If the #RKH_CFG_TRC_SM_CLRH_EN and #RKH_CFG_TRC_SM_EN are set to 1 then
 *	RKH will include the "state or pseudostate in a compound transition"
 *	trace record.
 */
#define RKH_CFG_TRC_SM_TS_STATE_EN      RKH_ENABLED

/**
 *	If the #RKH_CFG_TRC_SM_CLRH_EN and #RKH_CFG_TRC_SM_EN are set to 1 then
 *	RKH will include the "returned code from dispatch function" trace record.
 */
#define RKH_CFG_TRC_SM_PROCESS_EN       RKH_DISABLED

/**
 *	If the #RKH_CFG_TRC_SM_EXE_ACT_EN and #RKH_CFG_TRC_SM_EN are set to 1
 *	then RKH will include the "executed behavior of state machine" trace
 *	record.
 */
#define RKH_CFG_TRC_SM_EXE_ACT_EN       RKH_ENABLED

/**
 *	If the #RKH_CFG_TRC_NSEQ_EN is set to 1 then RKH will add to the trace
 *	record an incremental number (1-byte), used like a sequence number.
 *	See RKH_TRC_NSEQ() and RKH_TRC_HDR() macros.
 */
#define RKH_CFG_TRC_NSEQ_EN             RKH_ENABLED

/**
 *	If the #RKH_CFG_TRC_CHK_EN is set to 1 then RKH will add to the trace
 *	record a checksum (1-byte). See RKH_TRC_CHK() macro.
 */
#define RKH_CFG_TRC_CHK_EN              RKH_ENABLED

/**
 *	If the #RKH_CFG_TRC_TSTAMP_EN is set to 1 then RKH will add to the trace
 *	record a timestamp field. It's configurable by means of
 *	#RKH_CFGPORT_TRC_SIZEOF_TSTAMP.
 */
#define RKH_CFG_TRC_TSTAMP_EN           RKH_ENABLED

/**
 *	Specify the maximum number of trace events in the stream. The smaller
 *	this number, the lower the RAM consumption.
 */
#define RKH_CFG_TRC_SIZEOF_STREAM       512u

/* --- Configuration options related to queue (by reference) facility ----- */

/**
 *	If the #RKH_CFG_QUE_EN is set to 1 then RKH will include the native queue
 *	facility.
 */
#define RKH_CFG_QUE_EN                   RKH_ENABLED

/**
 *  Specify the maximum number of elements that any queue can contain.
 *  The valid values [in bits] are 8, 16 or 32. Default is 8.
 *	See #RKH_QUENE_T type.
 */
#define RKH_CFG_QUE_SIZEOF_NELEM         8u

/**
 *	If the #RKH_CFG_QUE_GET_LWMARK_EN is set to 1 then RKH allows to known the
 *  minimum number of free elements ever in the queue (low-watermark ).
 *  This provides valuable empirical data for proper sizing of the queue.
 *  See rkh_rq_get_lwm() function.
 */
#define RKH_CFG_QUE_GET_LWMARK_EN        RKH_DISABLED

/**
 *	If the #RKH_CFG_QUE_GET_INFO_EN is set to 1 then RKH allows to collect and
 *	retrives performance information for a particular queue.
 *	See rkh_rq_get_info() and rkh_rq_clear_info() functions.
 */
#define RKH_CFG_QUE_GET_INFO_EN          RKH_DISABLED

/**
 *	If the #RKH_CFG_QUE_READ_EN is set to 1 then RKH will include the
 *	rkh_rq_read() function that allows read an element from a queue without
 *	remove it. See rkh_rq_read() function.
 */
#define RKH_CFG_QUE_READ_EN              RKH_DISABLED

/**
 *	If the #RKH_CFG_QUE_DEPLETE_EN is set to 1 then RKH will include the
 *	rkh_rq_deplete() function that empties the contents of the queue and
 *	eliminates all stored elements.
 *	See rkh_rq_deplete() function.
 */
#define RKH_CFG_QUE_DEPLETE_EN           RKH_DISABLED

/**
 *	If the #RKH_CFG_QUE_IS_FULL_EN is set to 1 then RKH will include the
 *	rkh_rq_is_full() function that allows to known if a queue is full.
 *	See rkh_rq_is_full() function.
 */
#define RKH_CFG_QUE_IS_FULL_EN           RKH_DISABLED

/**
 *	If the #RKH_CFG_QUE_GET_NELEMS_EN is set to 1 then RKH will include the
 *	rkh_rq_get_num() function that returns the number of elements currently
 *	in the queue.
 *	See rkh_rq_get_num() function.
 */
#define RKH_CFG_QUE_GET_NELEMS_EN        RKH_DISABLED

/**
 *	If the #RKH_CFG_QUE_PUT_LIFO_EN is set to 1 then RKH will include the
 *	rkh_rq_put_lifo() function that puts an element on a queue in a LIFO
 *	manner.
 *	See rkh_rq_put_lifo() function.
 */
#define RKH_CFG_QUE_PUT_LIFO_EN          RKH_DISABLED

/* --- Configuration options related to fixed-sized memory block facility - */

/**
 *	If the #RKH_CFG_MP_EN is set to 1 then RKH will include the native
 *	fixed-size memory block management.
 */
#define RKH_CFG_MP_EN                   RKH_ENABLED

/**
 *	If the #RKH_CFG_MP_EN is set to 1 then RKH will include the native
 *	fixed-size memory block management.
 */
#define RKH_CFG_MP_REDUCED_EN           RKH_DISABLED

/**
 *  Specify the size of memory block size. The valid values [in bits] are
 *  8, 16 or 32. Default is 8. See #RKH_MPBS_T type.
 */
#define RKH_CFG_MP_SIZEOF_BSIZE         8u

/**
 *  Specify size of number of memory block size. The valid values [in bits]
 *  are 8, 16 or 32. Default is 8. See #RKH_MPNB_T type.
 */
#define RKH_CFG_MP_SIZEOF_NBLOCK        8u

/**
 *	If the #RKH_CFG_MP_GET_BSIZE_EN is set to 1 then RKH will include the
 *	rkh_mp_get_bsize() function that returns the size of memory block in
 *	bytes. See rkh_mp_get_bsize() function.
 */
#define RKH_CFG_MP_GET_BSIZE_EN         RKH_DISABLED

/**
 *	If the #RKH_CFG_MP_GET_NFREE_EN is set to 1 then RKH will include the
 *	rkh_mp_get_nfree() function that returns the current number of free
 *	memory blocks in the pool.
 *	See rkh_mp_get_nfree() function.
 */
#define RKH_CFG_MP_GET_NFREE_EN         RKH_DISABLED

/**
 *	If the #RKH_CFG_MP_GET_LWM_EN is set to 1 then RKH will include the
 *	rkh_mp_get_low_wmark() function that returns the lowest number of free
 *	blocks ever present in the pool. This number provides valuable empirical
 *	data for proper sizing of the memory pool.
 *	See rkh_mp_get_low_wmark() function.
 */
#define RKH_CFG_MP_GET_LWM_EN           RKH_ENABLED

/**
 *	If the #RKH_CFG_MP_GET_INFO_EN is set to 1 then RKH will include the
 *	rkh_mp_get_info() function that retrieves performance information for
 *	a particular memory pool. See rkh_mp_get_info() function.
 */
#define RKH_CFG_MP_GET_INFO_EN          RKH_DISABLED

/* --- Configuration options related to software timer facility ----------- */

/**
 *	If the #RKH_CFG_QUE_EN is set to 1 then RKH will include the native software
 *	timer facility.
 */
#define RKH_CFG_TMR_EN                  RKH_ENABLED

/**
 *  Specify the dynamic range of the time delays measured in clock ticks
 *  (maximum number of ticks). The valid values [in bits] are 8, 16 or 32.
 *  Default is 8.
 */
#define RKH_CFG_TMR_SIZEOF_NTIMER       16u

/**
 *	If the #RKH_CFG_TMR_HOOK_EN is set to 1 then RKH will invoke a hook
 *	function when a timer expires. When this is set the application must
 *	provide the hook function.
 */
#define RKH_CFG_TMR_HOOK_EN             RKH_DISABLED

/**
 *	If the #RKH_CFG_TMR_GET_INFO_EN is set to 1 then RKH will include the
 *	rkh_tmr_get_info() function that retrieves performance information for
 *	a particular software timer. See rkh_tmr_get_info() function.
 */
#define RKH_CFG_TMR_GET_INFO_EN         RKH_DISABLED

#endif
/* ------------------------------ End of file ------------------------------ */