m2mb API docs  37.00.006.0
m2mb API sets documentation
m2mb_wDog.h File Reference

Watchdog interface. More...

Go to the source code of this file.

Macros

#define M2MB_WDOG_INVALID   0
 
#define M2MB_WDOG_ENABLED   TRUE
 
#define M2MB_WDOG_DISABLED   FALSE
 
#define M2MB_WDOG_GPIO_ISR_ENABLE   TRUE
 
#define M2MB_WDOG_GPIO_ISR_DISABLE   FALSE
 

Typedefs

typedef struct M2MB_WDOG_HANDLE_TAG * M2MB_WDOG_HANDLE
 
typedef void(* M2MB_WDOG_IND_CALLBACK) (M2MB_WDOG_HANDLE h, M2MB_WDOG_IND_E wDog_event, UINT16 resp_size, void *resp_struct, void *userdata)
 

Enumerations

enum  M2MB_WDOG_IND_E { M2MB_WDOG_TIMEOUT_IND }
 
enum  M2MB_WDOG_SELECT_CMD_E {
  M2MB_WDOG_SELECT_CMD_TICKS, M2MB_WDOG_SELECT_CMD_MAX_TICKS_TO_REBOOT, M2MB_WDOG_SELECT_CMD_CNT, M2MB_WDOG_SELECT_CMD_TICKS_WAKEUP,
  M2MB_WDOG_SELECT_CMD_ISR, M2MB_WDOG_SELECT_CMD_STATUS, M2MB_WDOG_SELECT_CMD_TICK_DURATION_MS, M2MB_WDOG_SELECT_CMD_TASK_CNT,
  M2MB_WDOG_SELECT_CMD_TASK_TIMEOUT, M2MB_WDOG_SELECT_CMD_TASK_TIMED_OUT, M2MB_WDOG_SELECT_CMD_NEXT_EXPIRING_TASK
}
 

Functions

M2MB_RESULT_E m2mb_wDog_init (M2MB_WDOG_HANDLE *h, M2MB_WDOG_IND_CALLBACK wDogCallback, void *userdata)
 m2mb_wDog_init More...
 
M2MB_RESULT_E m2mb_wDog_deinit (M2MB_WDOG_HANDLE h)
 m2mb_wDog_deinit More...
 
M2MB_RESULT_E m2mb_wDog_enable (M2MB_WDOG_HANDLE h, MEM_W wDogWakeUpTicks, MEM_W ticksToReboot)
 m2mb_wDog_enable More...
 
M2MB_RESULT_E m2mb_wDog_disable (M2MB_WDOG_HANDLE h)
 m2mb_wDog_disable More...
 
M2MB_RESULT_E m2mb_wDog_reset (M2MB_WDOG_HANDLE h)
 m2mb_wDog_reset More...
 
M2MB_RESULT_E m2mb_wDog_isr (M2MB_WDOG_HANDLE h, const CHAR *gpioPath, M2MB_GPIO_TRIGGER_E edgeTrigger)
 m2mb_wDog_isr More...
 
M2MB_RESULT_E m2mb_wDog_addTask (M2MB_WDOG_HANDLE h, M2MB_OS_TASK_HANDLE hTask, UINT32 wdTimeout)
 m2mb_wDog_addTask More...
 
M2MB_RESULT_E m2mb_wDog_removeTask (M2MB_WDOG_HANDLE h, M2MB_OS_TASK_HANDLE hTask)
 m2mb_wDog_removeTask More...
 
M2MB_RESULT_E m2mb_wDog_kick (M2MB_WDOG_HANDLE h, M2MB_OS_TASK_HANDLE hTask)
 m2mb_wDog_kick More...
 
M2MB_RESULT_E m2mb_wDog_getItem (M2MB_WDOG_HANDLE h, M2MB_WDOG_SELECT_CMD_E wDogCmd, M2MB_OS_TASK_HANDLE hTask, MEM_W *pOut)
 m2mb_wDog_getItem More...
 

Detailed Description

Watchdog interface.

m2m/m2m_generic/common/m2mb_inc/m2mb_wDog.h

Watchdog interface is provided. The module implements a general software watchdog architecture. Watchdog instances (handles) can be added to system watchdog control, using provided watchdog interface. Each handle manages a defined set of tasks accordingly to the configuration provided through defined APIs. Watchdog control can be based on a regular tick of internal task control, or can be based on external signal provided through the selected gpio, (when specified gpio interrupt is set through dedicated API) that triggers the control for any ISR configured instances on the same gpio. Once the tasks are included in the control and the relative deadlines or timeouts are configured, when the control is enabled, kick for each task needs to be provided on regular basis. Each configured task on the handle, is checked periodically against its timeout. Here inactivity of a task, is intended with respect to watchdog control, meaning no kick is provided. In case a timeout or deadline inactivity or missing kicks is reached, the system invokes, whenever is possible, the provided callback if any is set. In the callback, info can be collected and actions performed, like restarting the single application, rebooting the entire system, or resetting the watchdog (not recommended if not really needed). If no action is taken, the system, as a first action, whenever is possible, tries to restart the involved application in the watchdog task timeout; in case it is not possible, as next step, the control reboots the whole system. Task control cannot manage any busy loop, since in this scenario the control itself can no more be scheduled and, at the end, before or later, the invoked hardware watchdog bark reboots the entire system. In an interrupt control mode instead, busy loop could generally be managed (of course depending on system status and configured timeouts values), but an external timing signal needs to be provided and gpio resources reserved. In case a timeout or deadline inactivity or missing kicks is reached in ISR mode, when callback is configured, if system status allows it, the callback can be invoked or not, depending on the priority of the task that is in busy loop status. The higher the priority, the lower the chance the callback to be invoked. Just a reference, priorities lower than the task calling M2MB_main() generally allow watchdog callback to be served (see m2mb_os.h module for priorities and related functions). As pointed out, it is not guaranteed that in ISR mode, the watchdog control can catch any busy loop, since the success of control process, at the end, depends on the system status, timeout parameters set for the watchdog instance, tasks, etc... Too long timeouts set in a busy loop scenario (and/or associated with low periodicity of external signal), can bring the system to automatic watchdog hardware bark without software intervention. Only if watchdog handle belongs to the same application that has a task in the busy loop status, a restart of handle related application is tried before rebooting the entire system, otherwise the system is directly rebooted.

E.g using system watchdog task (no ISR) Scheduler -> wdTask -> check ticks -> control of handles (task: counter vs timeout ) <- if handle is enabled counter=timeout during kick or reset, counter– otherwise if ( counter == 0 ) manages deadline inactivity reached => user callback if configured

ISR HW signal -> check ticks -> control of handles of ISR type ( the same "logic" management )

@notes Dependencies: m2mb_types.h m2mb_gpio.h

Author
Alessandro Papagno
Date
08/03/2021

Function Documentation

◆ m2mb_wDog_addTask()

M2MB_RESULT_E m2mb_wDog_addTask ( M2MB_WDOG_HANDLE  h,
M2MB_OS_TASK_HANDLE  hTask,
UINT32  wdTimeout 
)

m2mb_wDog_addTask

m2mb_wDog_addTask adds a task on instance to control its inactivity deadline on watchdog control. Here inactivity is intended with respect to watchdog control, meaning no kick is provided. The inactivity deadline is reached the next control period after timeout is reached, so after wdTimeout ticks increased by 1. E.g. with wdTimeout=1, first control is allowed and counter is decreased to 0 during control phase; the next control period, if the control finds the counter still at 0, the deadline is considered to be reached (so wdTimeout+1 watchdog controls allowed before deadline is declared)

Parameters
[in]hhandle of the watchdog instance to add task control on
[in]hTaskhandle of task to be added on control
[in]wdTimeouttimeout of the deadline for task inactivity
Returns
M2MB_RESULT_SUCCESS if task is correctly added to the instance
M2MB_RESULT_INVALID_ARG if any handle are not valid, or timeout is 0
see M2MB_RESULT_E in case of any fail
Note
Task can be added on instance already enabled, but as normal and good practice, it is suggested to add any task before enabling watchdog control on specified instance. Only for dedicated and very specific dynamically created task, dynamic add and remove could be needed. When task is added, its task control counter is in a reset state, meaning counter is the same as its wdTimeout value

Adding task to watchdog instance

// here for example
#define printf( arg... ) m2mb_trace_printf( M2MB_TC_GENERIC, M2MB_TL_LOG, arg )
M2MB_WDOG_HANDLE h_wDog;
M2MB_OS_TASK_HANDLE hTask;
M2MB_RESULT_E m2mbRes;
m2mbRes = m2mb_wDog_init( &h_wDog, MyWatchdogCallback, 0 );
if( m2mbRes == M2MB_RESULT_SUCCESS )
{
// just add current task or use handle of another created task
hTask = m2mb_os_taskGetId();
// set inactivity deadline of 25 for watchdog control
m2mbRes = m2mb_wDog_addTask( h_wDog, hTask, 25 );
if( m2mbRes == M2MB_RESULT_SUCCESS )
{
// test every 10 ticks of system watchdog control, refer to M2MB_WDOG_SELECT_CMD_TICK_DURATION_MS
m2mb_wDog_enable( h_wDog, 10, 4 );
}
else
{
printf( "not able to add task on watchdog instance" );
m2mb_wDog_deinit( h_wDog );
}
}

◆ m2mb_wDog_deinit()

M2MB_RESULT_E m2mb_wDog_deinit ( M2MB_WDOG_HANDLE  h)

m2mb_wDog_deinit

The function de-initializes the handle, releasing the associated resources. If a control ISR is associated to the handle, gpio resources are released. gpio resources are actually released only if they are not used by other handles

Parameters
[in]hhandle of watchdog instance to be de-initialized
Returns
M2MB_RESULT_SUCCESS if de-initialization is correctly performed
see M2MB_RESULT_E in case of any fail
Note
In case the instance is configured to be controlled by gpio ISR and no other instances use the same gpio ISR, gpio is automatically closed and can be used for other purposes

◆ m2mb_wDog_disable()

M2MB_RESULT_E m2mb_wDog_disable ( M2MB_WDOG_HANDLE  h)

m2mb_wDog_disable

The function disables the watchdog instance, so it is no more evaluated by the system watchdog control. Instance can be later re-enabled or reset until it is not de-initialized

Parameters
[in]hhandle of the watchdog instance to be disabled
Returns
M2MB_RESULT_SUCCESS if disabling is correctly performed
M2MB_RESULT_FAIL if instance is already disabled or cannot be performed
see M2MB_RESULT_E in case of any other fail
Note

◆ m2mb_wDog_enable()

M2MB_RESULT_E m2mb_wDog_enable ( M2MB_WDOG_HANDLE  h,
MEM_W  wDogWakeUpTicks,
MEM_W  ticksToReboot 
)

m2mb_wDog_enable

The function enables the management of the specified watchdog instance inside the watchdog control. Instance is evaluated after the specified wDogWakeUpTicks has been elapsed inside control. It means that each control is performed at any wDogWakeUpTicks for the instance indicated. If the instance is managed by the default task control, handle is evaluated after every wDogWakeUpTicks calls of the internal system watchdog thread (see M2MB_WDOG_SELECT_CMD_TICK_DURATION_MS). If the instance is managed through ISR, it is evaluated every wDogWakeUpTicks of ISR, being ISR timing depending on user hardware design (signal timing provided on selected gpio)

Parameters
[in]hhandle of the watchdog instance to be enabled
[in]wDogWakeUpTickstick repetition rate for watchdog instance evaluation. Cannot be 0.
[in]ticksToRebootin case no action is performed on timeout in callback (if system has chance to call it) the maximum number of ticks of control allowed in watchdog control (every wDogWakeUpTicks) after deadline timeout, before invoking the procedure to auto restart the application or rebooting the system. Parameter must be provided but it is not used in case callback is not provided. Cannot be 0
Returns
M2MB_RESULT_SUCCESS if initialization is correctly performed
M2MB_RESULT_FAIL if instance is already enabled or cannot be performed
see M2MB_RESULT_E in case of any fail
Note
The enabling functionality by itself, keeps as it is any previous state associated with handle (tasks, timeout, etc...) In case enable is performed after disable, m2mb_wDog_reset can be used to reset the counter of each task, to its initial values. E.g. If an instance is temporary disabled, the counter of each task and status are kept frozen; when enabled again, it starts counting from previous values

◆ m2mb_wDog_getItem()

M2MB_RESULT_E m2mb_wDog_getItem ( M2MB_WDOG_HANDLE  h,
M2MB_WDOG_SELECT_CMD_E  wDogCmd,
M2MB_OS_TASK_HANDLE  hTask,
MEM_W *  pOut 
)

m2mb_wDog_getItem

m2mb_wDog_getItem retrieves item value from watchdog instance. See M2MB_WDOG_SELECT_CMD_E on the item that can be retrieved, some belonging to watchdog instance, others to task owned by the watchdog instance. So depending on the type of request, hTask needs to be provided or it is ignored

Parameters
[in]hhandle of the watchdog instance to retrieve an item from
[in]wDogCmdselect the command to specify the item to retrieve
[in]hTaskdepending on the wDogCmd, it is the handle of task to be provided or it is ignored. E.g. if wDogCmd is related to specific task added to the watchdog instance, task handle of that task has to be provided (for instance M2MB_WDOG_SELECT_CMD_TASK_CNT requires task handle to be provided: see M2MB_WDOG_SELECT_CMD_E)
[out]pOutaddress of the output to get
Returns
M2MB_RESULT_SUCCESS in case of success in retrieving item
see M2MB_RESULT_E in case of any fail
Note
M2MB_WDOG_SELECT_CMD_TASK_CNT, M2MB_WDOG_SELECT_CMD_TASK_TIMEOUT need hTask to be provided, for other selection hTask is ignored. For M2MB_WDOG_SELECT_CMD_TASK_TIMED_OUT and M2MB_WDOG_SELECT_CMD_NEXT_EXPIRING_TASK pOut is a task handle

MEM_W out;
M2MB_OS_TASK_HANDLE hNextTask;
M2MB_RESULT_E m2mbRes;
// task handle not needed for this command, it is ignored
m2mb_wDog_getItem( h_wDog, M2MB_WDOG_SELECT_CMD_CNT, 0, &out );
// here out is the watchdog instance counter, when 0, next time control is evaluated
// get next expiring task
m2mbRes = m2mb_wDog_getItem( h_wDog, M2MB_WDOG_SELECT_CMD_NEXT_EXPIRING_TASK, 0, &out );
if( m2mbRes == M2MB_RESULT_SUCCESS )
{
hNextTask = ( M2MB_OS_TASK_HANDLE )out;
}
// see how many ticks are missing to deadline: counter proceed toward 0
m2mbRes = m2mb_wDog_getItem( h_wDog, M2MB_WDOG_SELECT_CMD_TASK_CNT, hNextTask, &out );
if( m2mbRes == M2MB_RESULT_SUCCESS )
{
printf( "missing %d for task timeout", out );
}
// set again counter to timeout value
m2mb_wDog_kick( h_wDog, hNextTask );

◆ m2mb_wDog_init()

M2MB_RESULT_E m2mb_wDog_init ( M2MB_WDOG_HANDLE *  h,
M2MB_WDOG_IND_CALLBACK  wDogCallback,
void *  userdata 
)

m2mb_wDog_init

The function performs initialization of application handle of watchdog instance to be manage in system watchdog

Parameters
[out]haddress of the watchdog instance handle to be initialized
[in]wDogCallbackit is the watchdog callback that is invoked in case of watchdog event. If NULL is set, no callback is invoked
[in]userdatasome specific userdata that the callback provides when triggered
Returns
M2MB_RESULT_SUCCESS if init is correctly performed
see M2MB_RESULT_E in case of any fail
Note
In case no callback is provided, in case of watchdog timeout hit, the system restarts the application whenever is possible, otherwise reboots the whole system

◆ m2mb_wDog_isr()

M2MB_RESULT_E m2mb_wDog_isr ( M2MB_WDOG_HANDLE  h,
const CHAR *  gpioPath,
M2MB_GPIO_TRIGGER_E  edgeTrigger 
)

m2mb_wDog_isr

m2mb_wDog_isr allows to set a gpio as interrupt driven by an hardware signal and triggered by its selected edge or front. If watchdog control is enabled, the specified instance is under watchdog control on each ISR event; in case wDogWakeUpTicks is elapsed, tasks timeouts of the handle are evaluated. Related Gpio is configured internally as input pull down

Parameters
[in]hhandle of the watchdog instance to set the ISR on
[in]gpioPathstring path of the gpio in the form /dev/GPIOx where "x" is in decimal format. See m2mb_gpio.h module
[in]edgeTriggerdefine the edge of the hardware signal that triggers the interrupt. See m2mb_gpio module
Returns
M2MB_RESULT_SUCCESS if ISR is correctly set
M2MB_RESULT_FAIL in case gpio is already used but not like an ISR dedicated to watchdog control, or edge does not match with existing watchdog control dedicated ISR. Briefly, in this case it is not possible to use it for this scope. Moreover instance needs to be disabled to allow gpio ISR set.
see M2MB_RESULT_E in case of any fail
Note
Gpio is set by default as input pull down after applying m2mb_wDog_isr. In case it is the first ISR set, ISR is not physically enabled until m2mb_wDog_enable() is set for the watchdog instance. Please note that watchdog instance needs to be in disable state before calling m2mb_wDog_isr set

Example to set gpio as ISR sources for watchdog instance control

// here for example
#define printf( arg... ) m2mb_trace_printf( M2MB_TC_GENERIC, M2MB_TL_LOG, arg )
M2MB_WDOG_HANDLE h_wDog;
M2MB_RESULT_E m2mbRes;
m2mbRes = m2mb_wDog_init( &h_wDog, NULL, 0 );
if( m2mbRes == M2MB_RESULT_SUCCESS )
{
m2mbRes = m2mb_wDog_isr( h_wDog, "/dev/GPIO2", M2MB_GPIO_INTR_POSEDGE );
if( m2mbRes == M2MB_RESULT_SUCCESS )
{
// performs all tasks to be added on handle:
// m2mb_wDog_addTask( h_wDog, h_task, timeoutTask )
m2mbRes = m2mb_wDog_enable( h_wDog, 1, 5 );
}
if( m2mbRes != M2MB_RESULT_SUCCESS )
{
m2mb_wDog_deinit( h_wDog );
printf( "error setting wDog ISR")
}
}
else
{
printf( "error init wDog handle")
}
//watchdog control on each ISR event

◆ m2mb_wDog_kick()

M2MB_RESULT_E m2mb_wDog_kick ( M2MB_WDOG_HANDLE  h,
M2MB_OS_TASK_HANDLE  hTask 
)

m2mb_wDog_kick

m2mb_wDog_kick performs watchdog kick for selected task inside watchdog instance. It means the counter for task is reset to its initially set wdTimeout value

Parameters
[in]hhandle of the watchdog instance the task belong to
[in]hTasktask handle to kick the watchdog on. It resets the counter of inactivity task
Returns
M2MB_RESULT_SUCCESS if kick is rightly performed
M2MB_RESULT_INVALID_ARG if handle is not valid, or hTask is not present on specified instance
see M2MB_RESULT_E in case of any fail
Note

Example using m2mb_wDog_kick inside a generic task

// here for example
#define printf( arg... ) m2mb_trace_printf( M2MB_TC_GENERIC, M2MB_TL_LOG, arg )
M2MB_HWTMR_ATTR_HANDLE tmrHwAttrHandle;
M2MB_HWTMR_HANDLE tmrHwHandle;
M2MB_OS_Q_HANDLE q; //queue where task gets message
typedef struct
{
UINT32 primitive;
void *data;
}MY_MSG_T;
// q and task is created using m2mb_os modules
// ...
// here a callback for a timer that invoke the kick... very simple case, same tick for all
static void TimerCb( M2MB_HWTMR_HANDLE hwTmrHandle, void *argCb )
{
UINT32 index;
MY_MSG_T myMsg = { WD_KICK, 0 };
M2MB_OS_Q_HANDLE locQ;
// using the same timer, lot of tasks can be kicked or one at the time
// avoid too many instructions inside callback
for( index=0; index<MAX_TASK; ind++ )
{
locQ = arrayQ[index];
//message to task for kick
m2mb_os_q_tx( locQ, myMsg, M2MB_OS_NO_WAIT, 0 );
}
}
// generate a timer to provide trigger to performs kicks
hwRes = m2mb_hwTmr_setAttrItem_( &tmrHwAttrHandle,
M2MB_HWTMR_SEL_CMD_CB_FUNC, &TimerCb,
M2MB_HWTMR_SEL_CMD_ARG_CB, 0,
M2MB_HWTMR_SEL_CMD_TIME_DURATION, M2MB_HWTMR_TIME_S( 2 ),
M2MB_HWTMR_SEL_CMD_PERIODIC, M2MB_HWTMR_PERIODIC_TMR,
M2MB_HWTMR_SEL_CMD_AUTOSTART, M2MB_HWTMR_AUTOSTART
);
hwRes = m2mb_hwTmr_init( &tmrHwHandle, &tmrHwAttrHandle );
// here the entry of generic task, created with m2mb_os APIs waiting for messages on queue q
void genericTask( void *arg )
{
MY_MSG_T myMsg;
M2MB_OS_RESULT_E osRes;
M2MB_OS_TASK_HANDLE hTask;
//...
hTask = m2mb_os_taskGetId();
while(1)
{
osRes = m2mb_os_q_rx( q, &myMsg, M2MB_OS_WAIT_FOREVER );
if( osRes == M2MB_OS_RESULT_SUCCESS )
{
switch( myMsg.primitive )
{
case WD_KICK:
// time to provide the kick
m2mb_wDog_kick( h_wDog, hTask );
break;
case PERFORM_TASK:
// others
break;
//manage other primitives
}
}
else
{
//manage error on queue
}
}
}

◆ m2mb_wDog_removeTask()

M2MB_RESULT_E m2mb_wDog_removeTask ( M2MB_WDOG_HANDLE  h,
M2MB_OS_TASK_HANDLE  hTask 
)

m2mb_wDog_removeTask

m2mb_wDog_removeTask removes a task under the provided watchdog instance

Parameters
[in]hhandle of the watchdog instance to remove task control on
[in]hTaskhandle of task to be removed from watchdog instance
Returns
M2MB_RESULT_SUCCESS if task is correctly removed from instance
M2MB_RESULT_INVALID_ARG if any handle is not valid, or hTask is not present on specified instance
see M2MB_RESULT_E in case of any fail
Note

Removing task from watchdog instance

// here for example
#define printf( arg... ) m2mb_trace_printf( M2MB_TC_GENERIC, M2MB_TL_LOG, arg )
M2MB_RESULT_E m2mbRes;
M2MB_OS_TASK_HANDLE hTask;
// ...
// remove this task from watchdog control
m2mbRes = m2mb_wDog_removeTask( h_wDog, hTask );
if( m2mbRes == M2MB_RESULT_SUCCESS )
{
printf( "task removed" );
}

◆ m2mb_wDog_reset()

M2MB_RESULT_E m2mb_wDog_reset ( M2MB_WDOG_HANDLE  h)

m2mb_wDog_reset

The function resets the watchdog timeout counter for each task included in watchdog instance. In this way, if the watchdog instance is enabled, the counting and control process of the associated tasks, can restart from the beginning at the same way if the tasks were just added. It has the same effect of performing m2mb_wDog_kick() for each task included in the instance. m2mb_wDog_reset can be performed on running with instance enabled

Parameters
[in]hhandle of the watchdog instance to be reset
Returns
M2MB_RESULT_SUCCESS if reset operation is correctly performed
see M2MB_RESULT_E in case of any fail
Note

m2mb_hwTmr_init
M2MB_HWTMR_RESULT_E m2mb_hwTmr_init(M2MB_HWTMR_HANDLE *pTmrHwHandle, M2MB_HWTMR_ATTR_HANDLE *pTmrHwAttr)
Application timer Creation.
m2mb_os_q_tx
M2MB_OS_RESULT_E m2mb_os_q_tx(M2MB_OS_Q_HANDLE qHandle, void *pSource, UINT32 timeoutTicks, UINT8 priority)
Send message to the queue.
m2mb_os_q_rx
M2MB_OS_RESULT_E m2mb_os_q_rx(M2MB_OS_Q_HANDLE qHandle, void *pDest, UINT32 timeoutTicks)
Receive message from the queue.
m2mb_wDog_removeTask
M2MB_RESULT_E m2mb_wDog_removeTask(M2MB_WDOG_HANDLE h, M2MB_OS_TASK_HANDLE hTask)
m2mb_wDog_removeTask
m2mb_wDog_init
M2MB_RESULT_E m2mb_wDog_init(M2MB_WDOG_HANDLE *h, M2MB_WDOG_IND_CALLBACK wDogCallback, void *userdata)
m2mb_wDog_init
m2mb_os_taskGetId
M2MB_OS_TASK_HANDLE m2mb_os_taskGetId(void)
Retrieves handle to the currently executing task.
m2mb_wDog_enable
M2MB_RESULT_E m2mb_wDog_enable(M2MB_WDOG_HANDLE h, MEM_W wDogWakeUpTicks, MEM_W ticksToReboot)
m2mb_wDog_enable
m2mb_wDog_getItem
M2MB_RESULT_E m2mb_wDog_getItem(M2MB_WDOG_HANDLE h, M2MB_WDOG_SELECT_CMD_E wDogCmd, M2MB_OS_TASK_HANDLE hTask, MEM_W *pOut)
m2mb_wDog_getItem
m2mb_wDog_deinit
M2MB_RESULT_E m2mb_wDog_deinit(M2MB_WDOG_HANDLE h)
m2mb_wDog_deinit
m2mb_wDog_kick
M2MB_RESULT_E m2mb_wDog_kick(M2MB_WDOG_HANDLE h, M2MB_OS_TASK_HANDLE hTask)
m2mb_wDog_kick
m2mb_wDog_addTask
M2MB_RESULT_E m2mb_wDog_addTask(M2MB_WDOG_HANDLE h, M2MB_OS_TASK_HANDLE hTask, UINT32 wdTimeout)
m2mb_wDog_addTask
m2mb_wDog_isr
M2MB_RESULT_E m2mb_wDog_isr(M2MB_WDOG_HANDLE h, const CHAR *gpioPath, M2MB_GPIO_TRIGGER_E edgeTrigger)
m2mb_wDog_isr
M2MB_GPIO_INTR_POSEDGE
Definition: m2mb_gpio.h:109