How to use return value from DRV_LOCK function
Not every DRV_STATE_E differing from DRV_OK is an error. A good example might be the DRV_LOCKED state, which might occur because an interrupt interrupted the allocation of the locking mutex. If this has happened one has to try again locking it. However, the API might also be locked and another task is using it. So it is feasible to log the time or count how often this happens and decide at which point this might be an error.
DRV_LOCKED is not an error condition, just the notification that the API was not free at that time or the trylock function was interrupted. Fell free to implement your own mutex in the netx_drv_config.h.
The following code snipped is an example code on how to make use of the returned state.
Can I disable the interrupt and enable it afterward to prevent the DRV_LOCKED?
It is not advisable to deactivate the main interrupt using DRV_IRQ_Disable or __disable_irq. Disabling the interrupts will disturb the program workflow, however will not stop the timers and the pending bits will still be set, so the interrupts won't be lost.
Which procedure is appropriate for DRV_LOCK?
The appropriate approach depends on the Application. The goal is to understand the pros and cons, then determine the correct methods.
As can see in Cortex-M4 instruction the LDREX/STREX require 2 cycles to be executed and to disable/ enable interrupts 1 or 2 cycles. The mentioned disadvantage of disabling interrupts is that the critical interrupts are delayed for that period of time.
A different approach is the use of "DRV_MUTEX_LOCK" function by modifying the existing #define DRV_LOCK(__HANDLE__) (in netx_drv_conf.h file) to #define DRV_LOCK(__HANDLE__) DRV_MUTEX_LOCK(&(__HANDLE__)→tLock). So the system waits until an event occurs by using the following function.
/**
\brief Wait For Event
\details Wait For Event is a hint instruction that permits the processor to enter
a low-power state until one of a number of events occurs.
*/
#define __WFE() __ASM volatile ("wfe")
Depending on the application, DRV_MUTEX can be converted into a simple lock. See the following example:
Note: If a interrupt interrupted this function shortly befor ptMutex->eState = DRV_MUTEX_STATE_LOCKED; and set the eState to LOCKED, the application does not notice this.
#define DRV_LOCK(__HANDLE__) DRV_SIMPLE_LOCK(&(__HANDLE__)→tLock)
__STATIC_FORCEINLINE DRV_STATUS_E DRV_SIMPLE_LOCK(DRV_MUTEX_T* ptMutex)
{
if(ptMutex->eState == DRV_MUTEX_STATE_LOCKED)
{
return DRV_LOCKED;
}
else if(ptMutex->eState == DRV_MUTEX_STATE_UNLOCKED)
{
ptMutex->eState = DRV_MUTEX_STATE_LOCKED;
return DRV_OK;
}
else
{
return DRV_ERROR; /* please check the initialization of ptDriver->tLock = DRV_LOCK_INITIALIZER; */
}
}