Hilscher netX microcontroller driver  V0.0.5.0
Documentation of the netX driver package
netx_drv_tim.c
Go to the documentation of this file.
1 /*!************************************************************************/
24 /* Includes ------------------------------------------------------------------*/
25 #include "netx_drv.h"
26 #ifdef DRV_TIM_MODULE_ENABLED
27 
32 /*lint -save -e685 */
33 /*lint -save -e568 */
34 
39 enum
40 {
41  DRV_TIM_IRQ_GPIOTIM0 = 0x00u,
42  DRV_TIM_IRQ_GPIOTIM1 = 0x01u,
43  DRV_TIM_IRQ_GPIOTIM2 = 0x02u,
44  DRV_TIM_IRQ_TIMER0 = 0x03u,
45  DRV_TIM_IRQ_TIMER1 = 0x04u,
46  DRV_TIM_IRQ_TIMER2 = 0x05u,
47  DRV_TIM_IRQ_SYSTIME_COMPARE = 0x06u,
48  DRV_TIM_IRQ_SYSTICK = 0x07u
49 };
50 
56 static IRQn_Type const aulIRQnTable[DRV_TIM_IRQ_COUNT] = DRV_TIM_IRQ_LIST;
57 
63 static DRV_CALLBACK_F s_apTIMCallbackTable[DRV_TIM_IRQ_COUNT] = { 0 };
64 
68 static void* s_apTIMCallbackHandleTable[DRV_TIM_IRQ_COUNT] = { 0 };
69 
73 static DRV_TIM_HANDLE_T* s_apTIMCallbackDriverHandleTable[DRV_TIM_IRQ_COUNT] = { 0 };
74 
78 static volatile uint32_t s_apTIMIrqCntr[DRV_TIM_IRQ_COUNT] = { 0 };
79 
80 #ifndef DRV_HANDLE_CHECK_INACTIVE
81 
84 #define DRV_HANDLE_CHECK(handle)\
85  if((handle) == 0){ \
86  return DRV_ERROR_PARAM; \
87  } \
88  if((handle)->ptDevice.ptGpio == 0 || \
89  (handle)->tConfiguration.eDeviceID < DRV_TIM_DEVICE_ID_GPIOCNTR_MIN || \
90  (handle)->tConfiguration.eDeviceID > DRV_TIM_DEVICE_ID_SYSTIME_MAX){ \
91  return DRV_ERROR_PARAM; \
92  }
93 #else
94 
97 #define DRV_HANDLE_CHECK(handle)
98 #endif
99 
107 DRV_STATUS_E DRV_TIM_Init(DRV_TIM_HANDLE_T * const ptTim)
108 {
109  /* Check the TIM handle allocation */
110  if(ptTim == NULL)
111  {
112  return DRV_ERROR_PARAM;
113  }
114  ptTim->tLock = DRV_LOCK_INITIALIZER;
115  DRV_LOCK(ptTim);
116  DRV_STATUS_E ret = DRV_ERROR;
117  uint32_t id;
118  if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_DMA)
119  {
120  ret = DRV_NSUPP;
121  }
122  if(ptTim->tConfiguration.eOperationMode > DRV_OPERATION_MODE_DMA)
123  {
124  ret = DRV_ERROR_PARAM;
125  }
126  else if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_GPIOCNTR_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_GPIOCNTR_MAX)
127  {
128  if(ptTim->tConfiguration.eSystimeReference == DRV_TIM_SYSTIME_REFERENCE_DEFAULT)
129  {
130  ptTim->tConfiguration.eSystimeReference = DRV_TIM_SYSTIME_REFERENCE_APP;
131  }
132  if(ptTim->tConfiguration.eSystimeReference != DRV_TIM_SYSTIME_REFERENCE_APP
133  || (ptTim->tConfiguration.eDioMskOutputReference
134  > DRV_DIO_LINE_MSK_GPIO))
135  {
136  return DRV_ERROR_PARAM;
137  }
138  if(ptTim->tConfiguration.eDioIdInputReference < DRV_DIO_ID_GPIO_MIN || ptTim->tConfiguration.eDioIdInputReference > DRV_DIO_ID_GPIO_MAX)
139  {
140  return DRV_ERROR_PARAM;
141  }
142  s_apTIMIrqCntr[DRV_TIM_IRQ_GPIOTIM0 + ptTim->ulSubID] = 0;
143  ptTim->ulSubID = (uint32_t) ptTim->tConfiguration.eDeviceID - (uint32_t) DRV_TIM_DEVICE_ID_GPIOCNTR_MIN;
144  ptTim->ptDevice.ptGpio = DRV_GPIO_DEVICE;
145  ptTim->ptDevice.ptGpio->gpio_app_counter_ctrl_b[ptTim->ulSubID].event_act = ptTim->tConfiguration.eExternalEventMode;
146  ptTim->ptDevice.ptGpio->gpio_app_counter_ctrl_b[ptTim->ulSubID].gpio_ref = ptTim->tConfiguration.eDioIdInputReference;
147  if(ptTim->tConfiguration.eCountingMode == DRV_TIM_COUNTING_MODE_ONCE)
148  {
149  ptTim->ptDevice.ptGpio->gpio_app_counter_ctrl_b[ptTim->ulSubID].once = 0x01u;
150  }
151  else
152  {
153  ptTim->ptDevice.ptGpio->gpio_app_counter_ctrl_b[ptTim->ulSubID].once = 0x00u;
154  }
155  ptTim->ptDevice.ptGpio->gpio_app_counter_ctrl_b[ptTim->ulSubID].run = 0x00u;
156  ptTim->ptDevice.ptGpio->gpio_app_counter_ctrl_b[ptTim->ulSubID].sel_event = ptTim->tConfiguration.eExternalEventTrigger;
157  ptTim->ptDevice.ptGpio->gpio_app_counter_ctrl_b[ptTim->ulSubID].sym_nasym = ptTim->tConfiguration.eSymmetric;
158  ptTim->ptDevice.ptGpio->gpio_app_counter_cnt[ptTim->ulSubID] = 0x00ul;
159  if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
160  {
161  NVIC_DisableIRQ((IRQn_Type) (((IRQn_Type[] ) { DRV_GPIO_COUNTER_IRQs } )[0] + ptTim->ulSubID));
162  DRV_NVIC_ClearPendingIRQ((IRQn_Type) (((IRQn_Type[] ) { DRV_GPIO_COUNTER_IRQs } )[0] + ptTim->ulSubID));
163  ptTim->ptDevice.ptGpio->gpio_app_counter_ctrl_b[ptTim->ulSubID].irq_en = 1u;
164  ptTim->ptDevice.ptGpio->gpio_app_cnt_irq_raw = 0x01ul << ptTim->ulSubID;
165  }
166  else
167  {
168  ptTim->ptDevice.ptGpio->gpio_app_counter_ctrl_b[ptTim->ulSubID].irq_en = 0u;
169  }
170  for(id = 0; id <= DRV_DIO_ID_GPIO_MAX - DRV_DIO_ID_GPIO_MIN; id++)
171  {
172  if(((uint32_t) ptTim->tConfiguration.eDioMskOutputReference & (((uint32_t) DRV_DIO_MSK_GPIO_0 ) << id)) > 0)
173  {
174  ptTim->ptDevice.ptGpio->gpio_app_cfg_b[id].count_ref = ptTim->ulSubID;
175  }
176  }
177  ptTim->eState = DRV_TIM_STATE_STOPPED;
178  ret = DRV_OK;
179  }
180  else if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_TIMER_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_TIMER_MAX)
181  {
182  if(ptTim->tConfiguration.eSymmetric == DRV_TIM_SYMMETRIC_TRIANGLE || ptTim->tConfiguration.eCountingMode >= DRV_TIM_COUNTING_MODE_RESERVED)
183  {
184  return DRV_ERROR_PARAM;
185  }
186  s_apTIMIrqCntr[DRV_TIM_IRQ_TIMER0 + ptTim->ulSubID] = 0;
187  ptTim->ulSubID = (uint32_t) ptTim->tConfiguration.eDeviceID - (uint32_t) DRV_TIM_DEVICE_ID_TIMER_MIN;
188  ptTim->ptDevice.ptTimer = DRV_TIMER_DEVICE;
189  if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_POLL && ptTim->tConfiguration.eCountingMode == DRV_TIM_COUNTING_MODE_CONTINUOUS)
190  {
191  ptTim->ptDevice.ptTimer->timer_config_timer_b[ptTim->ulSubID].mode = DRV_TIM_COUNTING_MODE_ONCE;
192  }
193  else
194  {
195  ptTim->ptDevice.ptTimer->timer_config_timer_b[ptTim->ulSubID].mode = ptTim->tConfiguration.eCountingMode;
196  }
197  if(ptTim->tConfiguration.eSystimeReference == DRV_TIM_SYSTIME_REFERENCE_DEFAULT)
198  {
199  ptTim->tConfiguration.eSystimeReference = DRV_TIM_SYSTIME_REFERENCE_APP;
200  }
201  ptTim->ptDevice.ptTimer->timer_config_timer_b[ptTim->ulSubID].systime_config = (uint32_t) ptTim->tConfiguration.eSystimeReference
202  - (uint32_t) DRV_TIM_SYSTIME_REFERENCE_MIN;
203  ptTim->ptDevice.ptTimer->timer_preload_timer[ptTim->ulSubID] = 0ul;
204  ptTim->ptDevice.ptTimer->timer_timer[ptTim->ulSubID] = 0ul;
205  if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
206  {
207  NVIC_DisableIRQ((IRQn_Type) (((IRQn_Type[] ) { DRV_TIMER_IRQs } )[0] + ptTim->ulSubID));
208  DRV_NVIC_ClearPendingIRQ((IRQn_Type) (((IRQn_Type[] ) { DRV_TIMER_IRQs } )[0] + ptTim->ulSubID));
209  ptTim->ptDevice.ptTimer->timer_irq_raw = 0x01ul << ptTim->ulSubID;
210  }
211  ptTim->eState = DRV_TIM_STATE_STOPPED;
212  ret = DRV_OK;
213  }
214  else if(ptTim->tConfiguration.eDeviceID == DRV_TIM_DEVICE_ID_SYSTIMECOMPARE)
215  {
216  ptTim->ptDevice.ptTimer = DRV_TIMER_DEVICE;
217  if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
218  {
219  NVIC_DisableIRQ(DRV_SYSTIME_COMPARE_IRQ);
220  DRV_NVIC_ClearPendingIRQ(DRV_SYSTIME_COMPARE_IRQ);
221  ptTim->ptDevice.ptTimer->timer_irq_raw_b.systime_s_irq = 1;
222  }
223  ptTim->eState = DRV_TIM_STATE_STOPPED;
224  ret = DRV_OK;
225  }
226  else if(ptTim->tConfiguration.eDeviceID == DRV_TIM_DEVICE_ID_SYSTICK)
227  {
228  s_apTIMIrqCntr[DRV_TIM_IRQ_SYSTICK + ptTim->ulSubID] = 0;
229  if((ptTim->tConfiguration.tPreloadValue - 1UL) > 0x00FFFFFF)
230  {
231  ret = DRV_ERROR_PARAM;
232  }
233  else
234  {
235  ptTim->ptDevice.ptSysTick = (SysTick_Type*) SysTick;
236  ptTim->ptDevice.ptSysTick->LOAD = (uint32_t) 0x00FFFFFF & (ptTim->tConfiguration.tPreloadValue - 1UL); /* set reload register */
237  ptTim->ptDevice.ptSysTick->VAL = 0UL; /* Load the SysTick Counter Value */
238  ptTim->ptDevice.ptSysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk;
239  if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
240  {
241  NVIC_DisableIRQ(SysTick_IRQn);
242  DRV_NVIC_ClearPendingIRQ(SysTick_IRQn);
243  NVIC_SetPriority(SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */
244  ptTim->ptDevice.ptSysTick->CTRL |= SysTick_CTRL_TICKINT_Msk;/* Enable SysTick IRQ */
245  }
246  ret = DRV_OK;
247  }
248  }
249  else if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_SYSTIME_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_SYSTIME_MAX)
250  {
251  s_apTIMIrqCntr[DRV_TIM_IRQ_SYSTICK + ptTim->ulSubID] = 0;
252  ptTim->ptDevice.ptSystimlt = (DRV_SYSTIME_LT_DEVICE_T*) DRV_SYSTIME_LT_DEVICE;
253  ret = DRV_OK;
254  }
255  else
256  {
257  ret = DRV_ERROR_PARAM;
258  }
259  DRV_UNLOCK(ptTim);
260  return ret;
261 }
262 
267 DRV_STATUS_E DRV_TIM_DeInit(DRV_TIM_HANDLE_T * const ptTim)
268 {
269  DRV_HANDLE_CHECK(ptTim);
270  DRV_LOCK(ptTim);
271  /* Check the parameters */
272  DRV_STATUS_E ret = DRV_ERROR;
273  if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_GPIOCNTR_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_GPIOCNTR_MAX)
274  {
275  if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
276  {
277  DRV_NVIC_DisableIRQ(
278  aulIRQnTable[DRV_TIM_IRQ_GPIOTIM0 + (uint32_t) ptTim->tConfiguration.eDeviceID - (uint32_t) DRV_TIM_DEVICE_ID_GPIOCNTR_MIN]);
279  DRV_NVIC_ClearPendingIRQ(
280  aulIRQnTable[DRV_TIM_IRQ_GPIOTIM0 + (uint32_t) ptTim->tConfiguration.eDeviceID - (uint32_t) DRV_TIM_DEVICE_ID_GPIOCNTR_MIN]);
281  }
282  *ptTim = (DRV_TIM_HANDLE_T ) { 0 };
283  ret = DRV_OK;
284  }
285  else if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_TIMER_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_TIMER_MAX)
286  {
287  if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
288  {
289  DRV_NVIC_DisableIRQ(aulIRQnTable[DRV_TIM_IRQ_TIMER0 + (uint32_t) ptTim->tConfiguration.eDeviceID - (uint32_t) DRV_TIM_DEVICE_ID_GPIOCNTR_MIN]);
290  DRV_NVIC_ClearPendingIRQ(
291  aulIRQnTable[DRV_TIM_IRQ_TIMER0 + (uint32_t) ptTim->tConfiguration.eDeviceID - (uint32_t) DRV_TIM_DEVICE_ID_GPIOCNTR_MIN]);
292  }
293  *ptTim = (DRV_TIM_HANDLE_T ) { 0 };
294  ret = DRV_OK;
295  }
296  else if(ptTim->tConfiguration.eDeviceID == DRV_TIM_DEVICE_ID_SYSTIMECOMPARE)
297  {
298  if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
299  {
300  DRV_NVIC_DisableIRQ(aulIRQnTable[DRV_TIM_IRQ_SYSTIME_COMPARE]);
301  DRV_NVIC_ClearPendingIRQ(aulIRQnTable[DRV_TIM_IRQ_SYSTIME_COMPARE]);
302  }
303  *ptTim = (DRV_TIM_HANDLE_T ) { 0 };
304  ret = DRV_OK;
305  }
306  else if(ptTim->tConfiguration.eDeviceID == DRV_TIM_DEVICE_ID_SYSTICK)
307  {
308  if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
309  {
310  DRV_NVIC_DisableIRQ(aulIRQnTable[DRV_TIM_IRQ_SYSTICK]);
311  DRV_NVIC_ClearPendingIRQ(aulIRQnTable[DRV_TIM_IRQ_SYSTICK]);
312  }
313  *ptTim = (DRV_TIM_HANDLE_T ) { 0 };
314  ret = DRV_OK;
315  }
316  else if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_SYSTIME_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_SYSTIME_MAX)
317  {
318  *ptTim = (DRV_TIM_HANDLE_T ) { 0 };
319  ret = DRV_OK;
320  }
321  else
322  {
323  ret = DRV_ERROR_PARAM;
324  }
325 
326  /* Release Lock */
327 
328  return ret;
329 }
330 
338 DRV_STATUS_E DRV_TIM_Start(DRV_TIM_HANDLE_T * const ptTim)
339 {
340  DRV_HANDLE_CHECK(ptTim);
341  DRV_LOCK(ptTim);
342  DRV_STATUS_E ret = DRV_ERROR;
343  if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_GPIOCNTR_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_GPIOCNTR_MAX)
344  {
345  if(ptTim->ulSubID > (uint32_t) DRV_TIM_DEVICE_ID_GPIOCNTR_MAX - (uint32_t) DRV_TIM_DEVICE_ID_GPIOCNTR_MIN)
346  {
347  ret = DRV_ERROR_PARAM;
348  }
349  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_POLL)
350  {
351  ptTim->ptDevice.ptGpio->gpio_app_counter_max[ptTim->ulSubID] = ptTim->tConfiguration.tPreloadValue;
352  ptTim->ptDevice.ptGpio->gpio_app_counter_ctrl_b[ptTim->ulSubID].run = 0x01u;
353  ptTim->eState = DRV_TIM_STATE_RUNNING;
354  ret = DRV_OK;
355  }
356  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
357  {
358  ptTim->ptDevice.ptGpio->gpio_app_counter_max[ptTim->ulSubID] = ptTim->tConfiguration.tPreloadValue;
359  ptTim->ptDevice.ptGpio->gpio_app_counter_ctrl_b[ptTim->ulSubID].run = 0x01u;
360  ptTim->ptDevice.ptGpio->gpio_app_cnt_irq_mask_set = 0x01ul << ptTim->ulSubID;
361  DRV_NVIC_EnableIRQ(aulIRQnTable[DRV_TIM_IRQ_GPIOTIM0 + ptTim->ulSubID]);
362  ptTim->eState = DRV_TIM_STATE_RUNNING;
363  ret = DRV_OK;
364  }
365  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_DMA)
366  {
367  ret = DRV_NSUPP;
368  }
369  else
370  {
371  ret = DRV_ERROR_PARAM;
372  }
373  }
374  else if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_TIMER_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_TIMER_MAX)
375  {
376  if(ptTim->ulSubID > (uint32_t) DRV_TIM_DEVICE_ID_TIMER_MAX - (uint32_t) DRV_TIM_DEVICE_ID_TIMER_MIN)
377  {
378  ret = DRV_ERROR_PARAM;
379  }
380  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_POLL)
381  {
382  ptTim->ptDevice.ptTimer->timer_preload_timer[ptTim->ulSubID] = ptTim->tConfiguration.tPreloadValue;
383  ptTim->ptDevice.ptTimer->timer_timer[ptTim->ulSubID] = ptTim->tConfiguration.tPreloadValue;
384  ptTim->eState = DRV_TIM_STATE_RUNNING;
385  ret = DRV_OK;
386  }
387  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
388  {
389  if(ptTim->tConfiguration.eCountingMode == DRV_TIM_COUNTING_MODE_ONCE)
390  {
391  ptTim->ptDevice.ptTimer->timer_timer[ptTim->ulSubID] = ptTim->tConfiguration.tPreloadValue;
392  }
393  else
394  {
395  ptTim->ptDevice.ptTimer->timer_preload_timer[ptTim->ulSubID] = ptTim->tConfiguration.tPreloadValue;
396  }
397  ptTim->ptDevice.ptTimer->timer_irq_msk_set = 0x01ul << ptTim->ulSubID;
398  DRV_NVIC_EnableIRQ(aulIRQnTable[DRV_TIM_IRQ_TIMER0 + ptTim->ulSubID]);
399  ptTim->eState = DRV_TIM_STATE_RUNNING;
400  ret = DRV_OK;
401  }
402  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_DMA)
403  {
404  ret = DRV_NSUPP;
405  }
406  else
407  {
408  ret = DRV_ERROR_PARAM;
409  }
410  }
411  else if(ptTim->tConfiguration.eDeviceID == DRV_TIM_DEVICE_ID_SYSTIMECOMPARE)
412  {
413  if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_POLL)
414  {
415  ret = DRV_NSUPP;
416  }
417  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
418  {
419  ptTim->ptDevice.ptTimer->timer_irq_msk_set_b.systime_s_irq = 1;
420  DRV_NVIC_EnableIRQ(aulIRQnTable[DRV_SYSTIME_COMPARE_IRQ]);
421  ptTim->eState = DRV_TIM_STATE_RUNNING;
422  ret = DRV_OK;
423  }
424  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_DMA)
425  {
426  ret = DRV_NSUPP;
427  }
428  else
429  {
430  ret = DRV_ERROR_PARAM;
431  }
432  }
433  else if(ptTim->tConfiguration.eDeviceID == DRV_TIM_DEVICE_ID_SYSTICK)
434  {
435  if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_POLL)
436  {
437  ptTim->ptDevice.ptSysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;/* Enable SysTick */
438  ptTim->eState = DRV_TIM_STATE_RUNNING;
439  ret = DRV_OK;
440  }
441  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
442  {
443  NVIC_EnableIRQ(SysTick_IRQn);
444  ptTim->ptDevice.ptSysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;/* Enable SysTick */
445  ptTim->eState = DRV_TIM_STATE_RUNNING;
446  ret = DRV_OK;
447  }
448  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_DMA)
449  {
450  ret = DRV_NSUPP;
451  }
452  else
453  {
454  ret = DRV_ERROR_PARAM;
455  }
456  }
457  else if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_SYSTIME_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_SYSTIME_MAX)
458  {
459  ret = DRV_NSUPP;
460  }
461  else
462  {
463  ret = DRV_ERROR_PARAM;
464  }
465  /* Return function status */
466  DRV_UNLOCK(ptTim);
467  return ret;
468 }
469 
477 DRV_STATUS_E DRV_TIM_Stop(DRV_TIM_HANDLE_T * const ptTim)
478 {
479  DRV_HANDLE_CHECK(ptTim);
480  DRV_LOCK(ptTim);
481  DRV_STATUS_E ret = DRV_ERROR;
482  if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_GPIOCNTR_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_GPIOCNTR_MAX)
483  {
484  if(ptTim->ulSubID > (uint32_t) DRV_TIM_DEVICE_ID_GPIOCNTR_MAX - (uint32_t) DRV_TIM_DEVICE_ID_GPIOCNTR_MIN)
485  {
486  ret = DRV_ERROR_PARAM;
487  }
488  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_POLL)
489  {
490  s_apTIMIrqCntr[DRV_TIM_IRQ_GPIOTIM0 + ptTim->ulSubID] = 0;
491  ptTim->ptDevice.ptGpio->gpio_app_counter_cnt[ptTim->ulSubID] = 0;
492  ptTim->ptDevice.ptGpio->gpio_app_counter_ctrl_b[ptTim->ulSubID].run = 0x00u;
493  ptTim->eState = DRV_TIM_STATE_STOPPED;
494  ret = DRV_OK;
495  }
496  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
497  {
498  s_apTIMIrqCntr[DRV_TIM_IRQ_GPIOTIM0 + ptTim->ulSubID] = 0;
499  DRV_NVIC_DisableIRQ(aulIRQnTable[DRV_TIM_IRQ_GPIOTIM0 + ptTim->ulSubID]);
500  ptTim->ptDevice.ptGpio->gpio_app_counter_ctrl_b[ptTim->ulSubID].run = 0x00u;
501  ptTim->ptDevice.ptGpio->gpio_app_cnt_irq_mask_rst = 0x01ul << ptTim->ulSubID;
502  ptTim->ptDevice.ptGpio->gpio_app_cnt_irq_raw = 0x01ul << ptTim->ulSubID;
503  ptTim->ptDevice.ptGpio->gpio_app_counter_cnt[ptTim->ulSubID] = 0;
504  ptTim->eState = DRV_TIM_STATE_STOPPED;
505  ret = DRV_OK;
506  }
507  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_DMA)
508  {
509  ret = DRV_NSUPP;
510  }
511  else
512  {
513  ret = DRV_ERROR_PARAM;
514  }
515  }
516  else if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_TIMER_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_TIMER_MAX)
517  {
518  if(ptTim->ulSubID > (uint32_t) DRV_TIM_DEVICE_ID_TIMER_MAX - (uint32_t) DRV_TIM_DEVICE_ID_TIMER_MIN)
519  {
520  ret = DRV_ERROR_PARAM;
521  }
522  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_POLL)
523  {
524  s_apTIMIrqCntr[DRV_TIM_IRQ_TIMER0 + ptTim->ulSubID] = 0;
525  ptTim->ptDevice.ptTimer->timer_timer[ptTim->ulSubID] = 0;
526  ptTim->ptDevice.ptTimer->timer_preload_timer[ptTim->ulSubID] = 0;
527  ptTim->eState = DRV_TIM_STATE_STOPPED;
528  ret = DRV_OK;
529  }
530  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
531  {
532  s_apTIMIrqCntr[DRV_TIM_IRQ_TIMER0 + ptTim->ulSubID] = 0;
533  DRV_NVIC_DisableIRQ(aulIRQnTable[DRV_TIM_IRQ_TIMER0 + ptTim->ulSubID]);
534  ptTim->ptDevice.ptTimer->timer_irq_msk_reset = 0x01ul << ptTim->ulSubID;
535  ptTim->ptDevice.ptTimer->timer_irq_raw = 0x01ul << ptTim->ulSubID;
536  ptTim->ptDevice.ptTimer->timer_preload_timer[ptTim->ulSubID] = 0;
537  ptTim->ptDevice.ptTimer->timer_timer[ptTim->ulSubID] = 0;
538  ptTim->eState = DRV_TIM_STATE_STOPPED;
539  ret = DRV_OK;
540  }
541  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_DMA)
542  {
543  ret = DRV_NSUPP;
544  }
545  else
546  {
547  ret = DRV_ERROR_PARAM;
548  }
549  }
550  else if(ptTim->tConfiguration.eDeviceID == DRV_TIM_DEVICE_ID_SYSTIMECOMPARE)
551  {
552  if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_POLL)
553  {
554  ret = DRV_NSUPP;
555  }
556  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
557  {
558  DRV_NVIC_DisableIRQ(aulIRQnTable[DRV_TIM_IRQ_SYSTIME_COMPARE]);
559  ptTim->ptDevice.ptTimer->timer_irq_msk_reset_b.systime_s_irq = 1u;
560  ptTim->ptDevice.ptTimer->timer_irq_raw_b.systime_s_irq = 1u;
561  ptTim->eState = DRV_TIM_STATE_STOPPED;
562  ret = DRV_OK;
563  }
564  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_DMA)
565  {
566  ret = DRV_NSUPP;
567  }
568  else
569  {
570  ret = DRV_ERROR_PARAM;
571  }
572  }
573  else if(ptTim->tConfiguration.eDeviceID == DRV_TIM_DEVICE_ID_SYSTICK)
574  {
575  if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_POLL)
576  {
577  s_apTIMIrqCntr[DRV_TIM_IRQ_SYSTICK] = 0;
578  ptTim->ptDevice.ptSysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;/* Disable SysTick */
579  ptTim->ptDevice.ptSysTick->VAL = 0ul;
580  ptTim->eState = DRV_TIM_STATE_STOPPED;
581  ret = DRV_OK;
582  }
583  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
584  {
585  s_apTIMIrqCntr[DRV_TIM_IRQ_SYSTICK] = 0;
586  DRV_NVIC_DisableIRQ(aulIRQnTable[DRV_TIM_IRQ_SYSTICK]);
587  ptTim->ptDevice.ptSysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;/* Disable SysTick */
588  ptTim->ptDevice.ptSysTick->VAL = 0ul;
589  ptTim->eState = DRV_TIM_STATE_STOPPED;
590  ret = DRV_OK;
591  }
592  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_DMA)
593  {
594  ret = DRV_NSUPP;
595  }
596  else
597  {
598  ret = DRV_ERROR_PARAM;
599  }
600  }
601  else if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_SYSTIME_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_SYSTIME_MAX)
602  {
603  ret = DRV_NSUPP;
604  }
605  else
606  {
607  ret = DRV_ERROR_PARAM;
608  }
609  DRV_UNLOCK(ptTim);
610  /* Return function status */
611  return ret;
612 }
613 
619 DRV_STATUS_E DRV_TIM_Pause(DRV_TIM_HANDLE_T * const ptTim)
620 {
621  DRV_HANDLE_CHECK(ptTim);
622  DRV_LOCK(ptTim);
623  DRV_STATUS_E ret = DRV_ERROR;
624  if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_GPIOCNTR_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_GPIOCNTR_MAX)
625  {
626  if(ptTim->ulSubID > (uint32_t) DRV_TIM_DEVICE_ID_GPIOCNTR_MAX - (uint32_t) DRV_TIM_DEVICE_ID_GPIOCNTR_MIN)
627  {
628  ret = DRV_ERROR_PARAM;
629  }
630  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_POLL)
631  {
632  ptTim->ptDevice.ptGpio->gpio_app_counter_ctrl_b[ptTim->ulSubID].run = 0x00u;
633  ptTim->eState = DRV_TIM_STATE_PAUSED;
634  ret = DRV_OK;
635  }
636  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
637  {
638  DRV_NVIC_DisableIRQ(aulIRQnTable[DRV_TIM_IRQ_GPIOTIM0 + ptTim->ulSubID]);
639  ptTim->ptDevice.ptGpio->gpio_app_counter_ctrl_b[ptTim->ulSubID].run = 0x00u;
640  ptTim->ptDevice.ptGpio->gpio_app_cnt_irq_mask_rst = 0x01ul << ptTim->ulSubID;
641  ptTim->eState = DRV_TIM_STATE_PAUSED;
642  ret = DRV_OK;
643  }
644  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_DMA)
645  {
646  ret = DRV_NSUPP;
647  }
648  else
649  {
650  ret = DRV_ERROR_PARAM;
651  }
652  }
653  else if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_TIMER_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_TIMER_MAX)
654  {
655  if(ptTim->ulSubID > (uint32_t) DRV_TIM_DEVICE_ID_TIMER_MAX - (uint32_t) DRV_TIM_DEVICE_ID_TIMER_MIN)
656  {
657  ret = DRV_ERROR_PARAM;
658  }
659  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_POLL)
660  {
661  ret = DRV_NSUPP;
662  }
663  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
664  {
665  ret = DRV_NSUPP;
666  }
667  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_DMA)
668  {
669  ret = DRV_NSUPP;
670  }
671  else
672  {
673  ret = DRV_ERROR_PARAM;
674  }
675  }
676  else if(ptTim->tConfiguration.eDeviceID == DRV_TIM_DEVICE_ID_SYSTIMECOMPARE)
677  {
678  if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_POLL)
679  {
680  ret = DRV_NSUPP;
681  }
682  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
683  {
684  ret = DRV_NSUPP;
685  }
686  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_DMA)
687  {
688  ret = DRV_NSUPP;
689  }
690  else
691  {
692  ret = DRV_ERROR_PARAM;
693  }
694  }
695  else if(ptTim->tConfiguration.eDeviceID == DRV_TIM_DEVICE_ID_SYSTICK)
696  {
697  if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_POLL)
698  {
699  ptTim->ptDevice.ptSysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;/* Disable SysTick */
700  ptTim->eState = DRV_TIM_STATE_PAUSED;
701  ret = DRV_OK;
702  }
703  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
704  {
705  NVIC_DisableIRQ(SysTick_IRQn);
706  ptTim->ptDevice.ptSysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;/* Disable SysTick */
707  ptTim->eState = DRV_TIM_STATE_PAUSED;
708  ret = DRV_OK;
709  }
710  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_DMA)
711  {
712  ret = DRV_NSUPP;
713  }
714  else
715  {
716  ret = DRV_ERROR_PARAM;
717  }
718  }
719  else if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_SYSTIME_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_SYSTIME_MAX)
720  {
721  ret = DRV_NSUPP;
722  }
723  else
724  {
725  ret = DRV_ERROR_PARAM;
726  }
727  DRV_UNLOCK(ptTim);
728  /* Return function status */
729  return ret;
730 }
731 
747 DRV_STATUS_E DRV_TIM_Wait(DRV_TIM_HANDLE_T * const ptTim, uint32_t ulTickCnt)
748 {
749  DRV_HANDLE_CHECK(ptTim);
750  DRV_LOCK(ptTim);
751  DRV_STATUS_E ret = DRV_ERROR;
752  if(ulTickCnt != 0
753  && (ptTim->tConfiguration.eCountingMode == DRV_TIM_COUNTING_MODE_ONCE || ptTim->tConfiguration.eCountingMode == DRV_TIM_COUNTING_MODE_RESERVED))
754  {
755  DRV_UNLOCK(ptTim);
756  return DRV_ERROR_PARAM;
757  }
758  if(ptTim->eState != DRV_TIM_STATE_RUNNING)
759  {
760  return DRV_ERROR;
761  }
762  if(ulTickCnt == 0)
763  {
764  ret = DRV_OK;
765  }
766  else if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_GPIOCNTR_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_GPIOCNTR_MAX)
767  {
768  if(ptTim->ulSubID > (uint32_t) DRV_TIM_DEVICE_ID_GPIOCNTR_MAX - (uint32_t) DRV_TIM_DEVICE_ID_GPIOCNTR_MIN)
769  {
770  ret = DRV_ERROR_PARAM;
771  }
772  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_POLL)
773  {
774  ptTim->ptDevice.ptGpio->gpio_app_counter_ctrl_b[ptTim->ulSubID].once = 1;
775  for(; ulTickCnt > 0; ulTickCnt--)
776  {
777  ptTim->ptDevice.ptGpio->gpio_app_counter_cnt[ptTim->ulSubID] = 0;
778  while(ptTim->ptDevice.ptTimer->timer_timer[ptTim->ulSubID] != 0)
779  {
780  }
781  if(s_apTIMCallbackTable[DRV_TIM_IRQ_GPIOTIM0 + ptTim->ulSubID] != 0)
782  {
783  s_apTIMCallbackTable[DRV_TIM_IRQ_GPIOTIM0 + ptTim->ulSubID](ptTim, s_apTIMCallbackHandleTable[DRV_TIM_IRQ_GPIOTIM0 + ptTim->ulSubID]);
784  }
785  }
786  ptTim->ptDevice.ptGpio->gpio_app_counter_ctrl_b[ptTim->ulSubID].once =
787  (ptTim->tConfiguration.eCountingMode == DRV_TIM_COUNTING_MODE_ONCE) ? 1 : 0;
788  ret = DRV_OK;
789  }
790  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
791  {
792  uint32_t latch = s_apTIMIrqCntr[DRV_TIM_IRQ_GPIOTIM0 + ptTim->ulSubID];
793  while(s_apTIMIrqCntr[DRV_TIM_IRQ_GPIOTIM0 + ptTim->ulSubID] - latch <= ulTickCnt)
794  {
795  }
796  ret = DRV_OK;
797  }
798  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_DMA)
799  {
800  ret = DRV_NSUPP;
801  }
802  else
803  {
804  ret = DRV_ERROR_PARAM;
805  }
806  }
807  else if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_TIMER_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_TIMER_MAX)
808  {
809  if(ptTim->ulSubID > (uint32_t) DRV_TIM_DEVICE_ID_TIMER_MAX - (uint32_t) DRV_TIM_DEVICE_ID_TIMER_MIN)
810  {
811  ret = DRV_ERROR_PARAM;
812  }
813  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_POLL)
814  {
815  ptTim->ptDevice.ptTimer->timer_config_timer_b[ptTim->ulSubID].mode = DRV_TIM_COUNTING_MODE_ONCE;
816  for(; ulTickCnt > 0; ulTickCnt--)
817  {
818  ptTim->ptDevice.ptTimer->timer_timer[ptTim->ulSubID] = ptTim->tConfiguration.tPreloadValue;
819  while(ptTim->ptDevice.ptTimer->timer_timer[ptTim->ulSubID] != 0)
820  {
821  }
822  if(s_apTIMCallbackTable[DRV_TIM_IRQ_TIMER0 + ptTim->ulSubID] != 0)
823  {
824  s_apTIMCallbackTable[DRV_TIM_IRQ_TIMER0 + ptTim->ulSubID](ptTim, s_apTIMCallbackHandleTable[DRV_TIM_IRQ_TIMER0 + ptTim->ulSubID]);
825  }
826  }
827  ret = DRV_OK;
828  }
829  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
830  {
831  uint32_t latch = s_apTIMIrqCntr[DRV_TIM_IRQ_TIMER0 + ptTim->ulSubID];
832  while(s_apTIMIrqCntr[DRV_TIM_IRQ_TIMER0 + ptTim->ulSubID] - latch <= ulTickCnt)
833  {
834  }
835  ret = DRV_OK;
836  }
837  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_DMA)
838  {
839  ret = DRV_NSUPP;
840  }
841  else
842  {
843  ret = DRV_ERROR_PARAM;
844  }
845  }
846  else if(ptTim->tConfiguration.eDeviceID == DRV_TIM_DEVICE_ID_SYSTIMECOMPARE)
847  {
848  if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_POLL || ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
849  {
850  while(DRV_TIMER_DEVICE->timer_systime_s < ulTickCnt)
851  {
852  }
853  volatile uint32_t ulDummy;
854  ulDummy = DRV_TIMER_DEVICE->timer_systime_ns;
855  UNUSED(ulDummy);
856  if(s_apTIMCallbackTable[DRV_TIM_IRQ_SYSTIME_COMPARE] != 0)
857  {
858  s_apTIMCallbackTable[DRV_TIM_IRQ_SYSTIME_COMPARE](ptTim, s_apTIMCallbackHandleTable[DRV_TIM_IRQ_SYSTIME_COMPARE]);
859  }
860  ret = DRV_OK;
861  }
862  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_DMA)
863  {
864  ret = DRV_NSUPP;
865  }
866  else
867  {
868  ret = DRV_ERROR_PARAM;
869  }
870  }
871  else if(ptTim->tConfiguration.eDeviceID == DRV_TIM_DEVICE_ID_SYSTICK)
872  {
873  if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_POLL)
874  {
875  ptTim->ptDevice.ptSysTick->CTRL &= ~SysTick_CTRL_COUNTFLAG_Msk;
876  for(; ulTickCnt > 0; ulTickCnt--)
877  {
878  while((ptTim->ptDevice.ptSysTick->CTRL & SysTick_CTRL_COUNTFLAG_Msk) == 0)
879  {
880  if(s_apTIMCallbackTable[DRV_TIM_IRQ_SYSTICK] != 0)
881  {
882  s_apTIMCallbackTable[DRV_TIM_IRQ_SYSTICK](ptTim, s_apTIMCallbackHandleTable[DRV_TIM_IRQ_SYSTICK]);
883  }
884  }
885  }
886  ret = DRV_OK;
887  }
888  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_IRQ)
889  {
890  uint32_t latch = s_apTIMIrqCntr[DRV_TIM_IRQ_SYSTICK];
891  while(s_apTIMIrqCntr[DRV_TIM_IRQ_SYSTICK] - latch <= ulTickCnt)
892  {
893  }
894  ret = DRV_OK;
895  }
896  else if(ptTim->tConfiguration.eOperationMode == DRV_OPERATION_MODE_DMA)
897  {
898  ret = DRV_NSUPP;
899  }
900  else
901  {
902  ret = DRV_ERROR_PARAM;
903  }
904  }
905  else if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_SYSTIME_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_SYSTIME_MAX)
906  {
907  ret = DRV_NSUPP;
908  }
909  else
910  {
911  ret = DRV_ERROR_PARAM;
912  }
913  DRV_UNLOCK(ptTim);
914  /* Return function status */
915  return ret;
916 }
917 
933 DRV_STATUS_E DRV_TIM_ChannelSetThreshold(DRV_TIM_HANDLE_T * const ptTim, DRV_DIO_ID_T ulChannelID, uint32_t ulTC)
934 {
935  DRV_HANDLE_CHECK(ptTim);
936  DRV_LOCK(ptTim);
937  DRV_STATUS_E ret = DRV_ERROR;
938  if(ulChannelID <= DRV_DIO_ID_GPIO_MAX && ulChannelID >= DRV_DIO_ID_GPIO_MIN)
939  {
940  if(ptTim->tConfiguration.eDeviceID < DRV_TIM_DEVICE_ID_GPIOCNTR_MIN || ptTim->tConfiguration.eDeviceID > DRV_TIM_DEVICE_ID_GPIOCNTR_MAX)
941  {
942  ret = DRV_ERROR_PARAM;
943  }
944  else if(((uint32_t) ptTim->tConfiguration.eDioMskOutputReference & (0x01ul << ulChannelID)) > 0)
945  {
946  ptTim->ptDevice.ptGpio->gpio_app_tc[ulChannelID - DRV_DIO_ID_GPIO_MIN] = ulTC;
947  ret = DRV_OK;
948  }
949  else
950  {
951  ret = DRV_ERROR_PARAM;
952  }
953  }
954  else
955  {
956  ret = DRV_ERROR_PARAM;
957  }
958  DRV_UNLOCK(ptTim);
959  return ret;
960 }
961 
973 DRV_STATUS_E DRV_TIM_ChannelGetCapture(DRV_TIM_HANDLE_T * const ptTim, DRV_DIO_ID_T ulChannelID, uint32_t * const ulValue)
974 {
975  DRV_HANDLE_CHECK(ptTim);
976  DRV_LOCK(ptTim);
977  if(ulValue == 0)
978  {
979  DRV_UNLOCK(ptTim);
980  return DRV_ERROR_PARAM;
981  }
982  DRV_STATUS_E ret = DRV_ERROR;
983  if(ulChannelID <= DRV_DIO_ID_GPIO_MAX && ulChannelID >= DRV_DIO_ID_GPIO_MIN)
984  {
985  if(ptTim->tConfiguration.eDeviceID < DRV_TIM_DEVICE_ID_GPIOCNTR_MIN || ptTim->tConfiguration.eDeviceID > DRV_TIM_DEVICE_ID_GPIOCNTR_MAX)
986  {
987  ret = DRV_ERROR_PARAM;
988  }
989  else if(((uint32_t) ptTim->tConfiguration.eDioMskOutputReference & (0x01ul << ulChannelID)) > 0)
990  {
991  *ulValue = ptTim->ptDevice.ptGpio->gpio_app_tc[ulChannelID - DRV_DIO_ID_GPIO_MIN];
992  ret = DRV_OK;
993  }
994  else
995  {
996  ret = DRV_ERROR_PARAM;
997  }
998  }
999  else
1000  {
1001  ret = DRV_ERROR_PARAM;
1002  }
1003  DRV_UNLOCK(ptTim);
1004  return ret;
1005 }
1006 
1016 DRV_STATUS_E DRV_TIM_IRQAttach(DRV_TIM_HANDLE_T * const ptTim, DRV_CALLBACK_F pfnUserClb, void* pvUser)
1017 {
1018  DRV_HANDLE_CHECK(ptTim);
1019  DRV_LOCK(ptTim);
1020  DRV_STATUS_E ret = DRV_ERROR;
1021  switch (ptTim->tConfiguration.eDeviceID)
1022  {
1023  case DRV_TIM_DEVICE_ID_GPIOCNTR0:
1024  s_apTIMCallbackHandleTable[DRV_TIM_IRQ_GPIOTIM0] = pvUser;
1025  s_apTIMCallbackDriverHandleTable[DRV_TIM_IRQ_GPIOTIM0] = ptTim;
1026  s_apTIMCallbackTable[DRV_TIM_IRQ_GPIOTIM0] = pfnUserClb;
1027  ret = DRV_OK;
1028  break;
1029  case DRV_TIM_DEVICE_ID_GPIOCNTR1:
1030  s_apTIMCallbackHandleTable[DRV_TIM_IRQ_GPIOTIM1] = pvUser;
1031  s_apTIMCallbackDriverHandleTable[DRV_TIM_IRQ_GPIOTIM1] = ptTim;
1032  s_apTIMCallbackTable[DRV_TIM_IRQ_GPIOTIM1] = pfnUserClb;
1033  ret = DRV_OK;
1034  break;
1035  case DRV_TIM_DEVICE_ID_GPIOCNTR2:
1036  s_apTIMCallbackHandleTable[DRV_TIM_IRQ_GPIOTIM2] = pvUser;
1037  s_apTIMCallbackDriverHandleTable[DRV_TIM_IRQ_GPIOTIM2] = ptTim;
1038  s_apTIMCallbackTable[DRV_TIM_IRQ_GPIOTIM2] = pfnUserClb;
1039  ret = DRV_OK;
1040  break;
1041 
1042  case DRV_TIM_DEVICE_ID_TIMER0:
1043  s_apTIMCallbackHandleTable[DRV_TIM_IRQ_TIMER0] = pvUser;
1044  s_apTIMCallbackDriverHandleTable[DRV_TIM_IRQ_TIMER0] = ptTim;
1045  s_apTIMCallbackTable[DRV_TIM_IRQ_TIMER0] = pfnUserClb;
1046  ret = DRV_OK;
1047  break;
1048  case DRV_TIM_DEVICE_ID_TIMER1:
1049  s_apTIMCallbackHandleTable[DRV_TIM_IRQ_TIMER1] = pvUser;
1050  s_apTIMCallbackDriverHandleTable[DRV_TIM_IRQ_TIMER1] = ptTim;
1051  s_apTIMCallbackTable[DRV_TIM_IRQ_TIMER1] = pfnUserClb;
1052  ret = DRV_OK;
1053  break;
1054  case DRV_TIM_DEVICE_ID_TIMER2:
1055  s_apTIMCallbackHandleTable[DRV_TIM_IRQ_TIMER2] = pvUser;
1056  s_apTIMCallbackDriverHandleTable[DRV_TIM_IRQ_TIMER2] = ptTim;
1057  s_apTIMCallbackTable[DRV_TIM_IRQ_TIMER2] = pfnUserClb;
1058  ret = DRV_OK;
1059  break;
1060 
1061  case DRV_TIM_DEVICE_ID_SYSTIMECOMPARE:
1062  s_apTIMCallbackHandleTable[DRV_TIM_IRQ_SYSTIME_COMPARE] = pvUser;
1063  s_apTIMCallbackDriverHandleTable[DRV_TIM_IRQ_SYSTIME_COMPARE] = ptTim;
1064  s_apTIMCallbackTable[DRV_TIM_IRQ_SYSTIME_COMPARE] = pfnUserClb;
1065  ret = DRV_OK;
1066  break;
1067 
1068  case DRV_TIM_DEVICE_ID_SYSTICK:
1069  s_apTIMCallbackHandleTable[DRV_TIM_IRQ_SYSTICK] = pvUser;
1070  s_apTIMCallbackDriverHandleTable[DRV_TIM_IRQ_SYSTICK] = ptTim;
1071  s_apTIMCallbackTable[DRV_TIM_IRQ_SYSTICK] = pfnUserClb;
1072  ret = DRV_OK;
1073  break;
1074 
1075  case DRV_TIM_DEVICE_ID_SYSTIME_COM:
1076  case DRV_TIM_DEVICE_ID_SYSTIME_COM_UC:
1077  case DRV_TIM_DEVICE_ID_SYSTIME_APP:
1078  ret = DRV_NSUPP;
1079  break;
1080  }
1081  DRV_UNLOCK(ptTim);
1082  return ret;
1083 }
1084 
1091 DRV_STATUS_E DRV_TIM_GetState(DRV_TIM_HANDLE_T * const ptTim, DRV_TIM_STATE_E * const peState)
1092 {
1093  DRV_HANDLE_CHECK(ptTim);
1094  DRV_STATUS_E ret = DRV_OK;
1095  *peState = ptTim->eState;
1096  if(peState == 0)
1097  {
1098  return DRV_ERROR_PARAM;
1099  }
1100  switch (ptTim->eState)
1101  {
1102  case DRV_TIM_STATE_DEFAULT:
1103  ret = DRV_ERROR_PARAM;
1104  break;
1105  case DRV_TIM_STATE_ERROR:
1106  ret = DRV_ERROR;
1107  break;
1108  case DRV_TIM_STATE_RUNNING:
1109  ret = DRV_BUSY;
1110  break;
1111  case DRV_TIM_STATE_STOPPED:
1112  ret = DRV_OK;
1113  break;
1114  case DRV_TIM_STATE_TIMEOUT:
1115  ret = DRV_TOUT;
1116  break;
1117  default:
1118  ret = DRV_ERROR_PARAM;
1119  break;
1120  }
1121  return ret;
1122 }
1123 
1142 DRV_STATUS_E DRV_TIM_GetValue(DRV_TIM_HANDLE_T * const ptTim, uint32_t * const ptSoftwareValue, uint32_t * const ptHardwareValue)
1143 {
1144  DRV_HANDLE_CHECK(ptTim);
1145  DRV_LOCK(ptTim);
1146  DRV_STATUS_E ret = DRV_ERROR;
1147  if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_GPIOCNTR_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_GPIOCNTR_MAX)
1148  {
1149  if(ptTim->ulSubID <= (uint32_t) DRV_TIM_DEVICE_ID_GPIOCNTR_MAX - (uint32_t) DRV_TIM_DEVICE_ID_GPIOCNTR_MIN)
1150  {
1151  if(ptSoftwareValue != NULL)
1152  {
1153  *ptSoftwareValue = s_apTIMIrqCntr[DRV_TIM_IRQ_GPIOTIM0 + ptTim->ulSubID];
1154  ret = DRV_OK;
1155  }
1156  if(ptHardwareValue != NULL)
1157  {
1158  *ptHardwareValue = ptTim->ptDevice.ptGpio->gpio_app_counter_cnt[ptTim->ulSubID];
1159  ret = DRV_OK;
1160  }
1161  else
1162  {
1163  ret = DRV_ERROR_PARAM;
1164  }
1165  }
1166  }
1167  else if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_TIMER_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_TIMER_MAX)
1168  {
1169  if(ptTim->ulSubID > (uint32_t) DRV_TIM_DEVICE_ID_TIMER_MAX - (uint32_t) DRV_TIM_DEVICE_ID_TIMER_MIN)
1170  {
1171  ret = DRV_ERROR_PARAM;
1172  }
1173  else
1174  {
1175  if(ptSoftwareValue != NULL)
1176  {
1177  *ptSoftwareValue = s_apTIMIrqCntr[DRV_TIM_IRQ_TIMER0 + ptTim->ulSubID];
1178  ret = DRV_OK;
1179  }
1180  if(ptHardwareValue != NULL)
1181  {
1182  *ptHardwareValue = ptTim->ptDevice.ptTimer->timer_timer[ptTim->ulSubID];
1183  ret = DRV_OK;
1184  }
1185  else
1186  {
1187  ret = DRV_ERROR_PARAM;
1188  }
1189  }
1190  }
1191  else if(ptTim->tConfiguration.eDeviceID == DRV_TIM_DEVICE_ID_SYSTIMECOMPARE)
1192  {
1193  if(ptSoftwareValue != NULL)
1194  {
1195  *ptSoftwareValue = ptTim->ptDevice.ptTimer->timer_systime_s;
1196  }
1197  if(ptHardwareValue != NULL)
1198  {
1199  *ptHardwareValue = ptTim->ptDevice.ptTimer->timer_systime_ns;
1200  }
1201  else
1202  {
1203  volatile uint32_t ulDummy;
1204  ulDummy = ptTim->ptDevice.ptTimer->timer_systime_ns;
1205  UNUSED(ulDummy);
1206  }
1207  ret = DRV_OK;
1208  }
1209  else if(ptTim->tConfiguration.eDeviceID == DRV_TIM_DEVICE_ID_SYSTICK)
1210  {
1211  if(ptSoftwareValue != NULL)
1212  {
1213  *ptSoftwareValue = s_apTIMIrqCntr[DRV_TIM_IRQ_SYSTICK + ptTim->ulSubID];
1214  ret = DRV_OK;
1215  }
1216  if(ptHardwareValue != NULL)
1217  {
1218  *ptHardwareValue = ptTim->ptDevice.ptSysTick->VAL;
1219  ret = DRV_OK;
1220  }
1221  }
1222  else if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_SYSTIME_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_SYSTIME_MAX)
1223  {
1224 
1225  if(ptTim->tConfiguration.eDeviceID == DRV_TIM_DEVICE_ID_SYSTIME_APP)
1226  {
1227  if(ptSoftwareValue != NULL)
1228  {
1229  *ptSoftwareValue = DRV_SYSTIME_LT_DEVICE->intlogic_lt_systime_app_s;
1230  }
1231  if(ptHardwareValue != NULL)
1232  {
1233  *ptHardwareValue = DRV_SYSTIME_LT_DEVICE->intlogic_lt_systime_app_ns;
1234  }
1235  ret = DRV_OK;
1236  }
1237  else if(ptTim->tConfiguration.eDeviceID == DRV_TIM_DEVICE_ID_SYSTIME_COM)
1238  {
1239  if(ptSoftwareValue != NULL)
1240  {
1241  *ptSoftwareValue = DRV_SYSTIME_LT_DEVICE->intlogic_lt_systime_com_s;
1242  }
1243  if(ptHardwareValue != NULL)
1244  {
1245  *ptHardwareValue = DRV_SYSTIME_LT_DEVICE->intlogic_lt_systime_com_ns;
1246  }
1247  ret = DRV_OK;
1248  }
1249  else if(ptTim->tConfiguration.eDeviceID == DRV_TIM_DEVICE_ID_SYSTIME_COM_UC)
1250  {
1251  if(ptSoftwareValue != NULL)
1252  {
1253  *ptSoftwareValue = DRV_SYSTIME_LT_DEVICE->intlogic_lt_systime_com_uc_s;
1254  }
1255  if(ptHardwareValue != NULL)
1256  {
1257  *ptHardwareValue = DRV_SYSTIME_LT_DEVICE->intlogic_lt_systime_com_uc_ns;
1258  }
1259  ret = DRV_OK;
1260  }
1261  else
1262  {
1263  ret = DRV_ERROR_PARAM;
1264  }
1265  }
1266  else
1267  {
1268  ret = DRV_ERROR_PARAM;
1269  }
1270  DRV_UNLOCK(ptTim);
1271  /* Return function status */
1272  return ret;
1273 }
1274 
1281 DRV_STATUS_E DRV_TIM_SetPreload(DRV_TIM_HANDLE_T * const ptTim, DRV_TIM_PRELOAD_VALUE_E const tCounterValue)
1282 {
1283  DRV_HANDLE_CHECK(ptTim);
1284  DRV_LOCK(ptTim);
1285  DRV_STATUS_E ret = DRV_ERROR;
1286  if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_GPIOCNTR_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_GPIOCNTR_MAX)
1287  {
1288  if(ptTim->ulSubID <= (uint32_t) DRV_TIM_DEVICE_ID_GPIOCNTR_MAX - (uint32_t) DRV_TIM_DEVICE_ID_GPIOCNTR_MIN)
1289  {
1290  ptTim->tConfiguration.tPreloadValue = tCounterValue;
1291  ptTim->ptDevice.ptGpio->gpio_app_counter_max[ptTim->ulSubID] = tCounterValue;
1292  ret = DRV_OK;
1293  }
1294  else
1295  {
1296  ret = DRV_ERROR_PARAM;
1297  };
1298  }
1299  else if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_TIMER_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_TIMER_MAX)
1300  {
1301  if(ptTim->ulSubID > (uint32_t) DRV_TIM_DEVICE_ID_TIMER_MAX - (uint32_t) DRV_TIM_DEVICE_ID_TIMER_MIN)
1302  {
1303  ret = DRV_ERROR_PARAM;
1304  }
1305  else
1306  {
1307  ptTim->tConfiguration.tPreloadValue = tCounterValue;
1308  ptTim->ptDevice.ptTimer->timer_preload_timer[ptTim->ulSubID] = tCounterValue;
1309  ret = DRV_OK;
1310  }
1311  }
1312  else if(ptTim->tConfiguration.eDeviceID == DRV_TIM_DEVICE_ID_SYSTIMECOMPARE)
1313  {
1314  ptTim->tConfiguration.tPreloadValue = tCounterValue;
1315  ptTim->ptDevice.ptTimer->timer_compare_systime_s_value = tCounterValue;
1316  ret = DRV_OK;
1317  }
1318  else if(ptTim->tConfiguration.eDeviceID == DRV_TIM_DEVICE_ID_SYSTICK)
1319  {
1320  ptTim->ptDevice.ptSysTick->LOAD = tCounterValue;
1321  ret = DRV_OK;
1322  }
1323  else if(ptTim->tConfiguration.eDeviceID >= DRV_TIM_DEVICE_ID_SYSTIME_MIN && ptTim->tConfiguration.eDeviceID <= DRV_TIM_DEVICE_ID_SYSTIME_MAX)
1324  {
1325  ret = DRV_NSUPP;
1326  }
1327  else
1328  {
1329  ret = DRV_ERROR_PARAM;
1330  }
1331  DRV_UNLOCK(ptTim);
1332  /* Return function status */
1333  return ret;
1334 }
1335 
1341 void GPIOTIM0_IRQHandler(void)
1342 {
1343  s_apTIMIrqCntr[DRV_TIM_IRQ_GPIOTIM0]++;
1344  DRV_TIM_GPIOTIM0_Callback();
1345  DRV_GPIO_DEVICE->gpio_app_cnt_irq_raw = gpio_xpic_app_gpio_app_cnt_irq_raw_cnt0_Msk;
1346 }
1347 
1354 __WEAK void DRV_TIM_GPIOTIM0_Callback(void)
1355 {
1356  if(s_apTIMCallbackTable[DRV_TIM_IRQ_GPIOTIM0] != 0)
1357  {
1358  s_apTIMCallbackTable[DRV_TIM_IRQ_GPIOTIM0](s_apTIMCallbackDriverHandleTable[DRV_TIM_IRQ_GPIOTIM0],
1359  s_apTIMCallbackHandleTable[DRV_TIM_IRQ_GPIOTIM0]);
1360  }
1361 }
1362 
1368 void GPIOTIM1_IRQHandler(void)
1369 {
1370  s_apTIMIrqCntr[DRV_TIM_IRQ_GPIOTIM1]++;
1371  DRV_TIM_GPIOTIM1_Callback();
1372  DRV_GPIO_DEVICE->gpio_app_cnt_irq_raw = gpio_xpic_app_gpio_app_cnt_irq_raw_cnt1_Msk;
1373 }
1374 
1381 __WEAK void DRV_TIM_GPIOTIM1_Callback(void)
1382 {
1383  if(s_apTIMCallbackTable[DRV_TIM_IRQ_GPIOTIM1] != 0)
1384  {
1385  s_apTIMCallbackTable[DRV_TIM_IRQ_GPIOTIM1](s_apTIMCallbackDriverHandleTable[DRV_TIM_IRQ_GPIOTIM1],
1386  s_apTIMCallbackHandleTable[DRV_TIM_IRQ_GPIOTIM1]);
1387  }
1388 }
1389 
1394 void GPIOTIM2_IRQHandler(void)
1395 {
1396  s_apTIMIrqCntr[DRV_TIM_IRQ_GPIOTIM2]++;
1397  DRV_TIM_GPIOTIM2_Callback();
1398  DRV_GPIO_DEVICE->gpio_app_cnt_irq_raw = gpio_xpic_app_gpio_app_cnt_irq_raw_cnt2_Msk;
1399 }
1400 
1407 __WEAK void DRV_TIM_GPIOTIM2_Callback(void)
1408 {
1409  if(s_apTIMCallbackTable[DRV_TIM_IRQ_GPIOTIM2] != 0)
1410  {
1411  s_apTIMCallbackTable[DRV_TIM_IRQ_GPIOTIM2](s_apTIMCallbackDriverHandleTable[DRV_TIM_IRQ_GPIOTIM2],
1412  s_apTIMCallbackHandleTable[DRV_TIM_IRQ_GPIOTIM2]);
1413  }
1414 }
1415 
1420 void TIM0_IRQHandler(void)
1421 {
1422  s_apTIMIrqCntr[DRV_TIM_IRQ_TIMER0]++;
1423  DRV_TIM_TIMER0_Callback();
1424  DRV_TIMER_DEVICE->timer_irq_raw = timer_app_timer_irq_masked_timer0_irq_Msk;
1425 }
1426 
1433 __WEAK void DRV_TIM_TIMER0_Callback(void)
1434 {
1435  if(s_apTIMCallbackTable[DRV_TIM_IRQ_TIMER0] != 0)
1436  {
1437  s_apTIMCallbackTable[DRV_TIM_IRQ_TIMER0](s_apTIMCallbackDriverHandleTable[DRV_TIM_IRQ_TIMER0], s_apTIMCallbackHandleTable[DRV_TIM_IRQ_TIMER0]);
1438  }
1439 }
1440 
1445 void TIM1_IRQHandler(void)
1446 {
1447  s_apTIMIrqCntr[DRV_TIM_IRQ_TIMER1]++;
1448  DRV_TIM_TIMER1_Callback();
1449  DRV_TIMER_DEVICE->timer_irq_raw = timer_app_timer_irq_masked_timer1_irq_Msk;
1450 }
1451 
1458 __WEAK void DRV_TIM_TIMER1_Callback(void)
1459 {
1460  if(s_apTIMCallbackTable[DRV_TIM_IRQ_TIMER1] != 0)
1461  {
1462  s_apTIMCallbackTable[DRV_TIM_IRQ_TIMER1](s_apTIMCallbackDriverHandleTable[DRV_TIM_IRQ_TIMER1], s_apTIMCallbackHandleTable[DRV_TIM_IRQ_TIMER1]);
1463  }
1464 }
1465 
1470 void TIM2_IRQHandler(void)
1471 {
1472  s_apTIMIrqCntr[DRV_TIM_IRQ_TIMER2]++;
1473  DRV_TIM_TIMER2_Callback();
1474  DRV_TIMER_DEVICE->timer_irq_raw = timer_app_timer_irq_masked_timer2_irq_Msk;
1475 }
1476 
1483 __WEAK void DRV_TIM_TIMER2_Callback(void)
1484 {
1485  if(s_apTIMCallbackTable[DRV_TIM_IRQ_TIMER2] != 0)
1486  {
1487  s_apTIMCallbackTable[DRV_TIM_IRQ_TIMER2](s_apTIMCallbackDriverHandleTable[DRV_TIM_IRQ_TIMER2], s_apTIMCallbackHandleTable[DRV_TIM_IRQ_TIMER2]);
1488  }
1489 }
1490 
1495 void SYSTIME_IRQHandler(void)
1496 {
1497  s_apTIMIrqCntr[DRV_TIM_IRQ_SYSTIME_COMPARE]++;
1498  DRV_TIM_SYSTIME_COMPARE_Callback();
1499  DRV_TIMER_DEVICE->timer_irq_raw = timer_app_timer_irq_masked_systime_s_irq_Msk;
1500 }
1501 
1508 __WEAK void DRV_TIM_SYSTIME_COMPARE_Callback(void)
1509 {
1510  if(s_apTIMCallbackTable[DRV_TIM_IRQ_SYSTIME_COMPARE] != 0)
1511  {
1512  s_apTIMCallbackTable[DRV_TIM_IRQ_SYSTIME_COMPARE](s_apTIMCallbackDriverHandleTable[DRV_TIM_IRQ_SYSTIME_COMPARE],
1513  s_apTIMCallbackHandleTable[DRV_TIM_IRQ_SYSTIME_COMPARE]);
1514  }
1515 }
1516 
1521 void SysTick_Handler(void)
1522 {
1523  s_apTIMIrqCntr[DRV_TIM_IRQ_SYSTICK]++;
1524  DRV_TIM_ARMSYSTICK_Callback();
1525 }
1526 
1533 __WEAK void DRV_TIM_ARMSYSTICK_Callback(void)
1534 {
1535  if(s_apTIMCallbackTable[DRV_TIM_IRQ_SYSTICK] != 0)
1536  {
1537  s_apTIMCallbackTable[DRV_TIM_IRQ_SYSTICK](s_apTIMCallbackDriverHandleTable[DRV_TIM_IRQ_SYSTICK], s_apTIMCallbackHandleTable[DRV_TIM_IRQ_SYSTICK]);
1538  }
1539 }
1540 /* End of group TIM */
1542 
1543 /*lint -restore */
1544 /*lint -restore */
1545 
1546 #endif /* DRV_TIM_MODULE_DISABLED */
DRV_TIM_SYSTIME_REFERENCE_APP
Definition: netx_drv_tim.h:139
gpio_xpic_app_gpio_app_cnt_irq_raw_cnt2_Msk
#define gpio_xpic_app_gpio_app_cnt_irq_raw_cnt2_Msk
Definition: netx90_app.h:50816
DRV_SYSTIME_LT_DEVICE
#define DRV_SYSTIME_LT_DEVICE
Definition: netx_drv_csp_netx90_app.h:367
timer_app_Type::timer_systime_ns
__IM uint32_t timer_systime_ns
Definition: netx90_app.h:25225
DRV_TIM_IRQ_SYSTICK
Definition: netx_drv_tim.c:48
DRV_TIM_HANDLE_T::DRV_TIM_ChannelSetThreshold
DRV_STATUS_E DRV_TIM_ChannelSetThreshold(DRV_TIM_HANDLE_T *const ptTim, DRV_DIO_ID_T ulChannelID, uint32_t ulTC)
This function sets the threshold used for the specified channel.
Definition: netx_drv_tim.c:933
TIM1_IRQHandler
void TIM1_IRQHandler(void)
This function handles interrupts requests.
Definition: netx_drv_tim.c:1445
DRV_TIM_DEVICE_ID_TIMER0
Definition: netx_drv_csp_netx90_app.h:345
DRV_TIM_HANDLE_T::DRV_TIM_GetValue
DRV_STATUS_E DRV_TIM_GetValue(DRV_TIM_HANDLE_T *const ptTim, uint32_t *const ptSoftwareValue, uint32_t *const ptHardwareValue)
Stores the current counter value.
Definition: netx_drv_tim.c:1142
DRV_TIM_STATE_DEFAULT
Definition: netx_drv_tim.h:95
s_apTIMCallbackHandleTable
static void * s_apTIMCallbackHandleTable[DRV_TIM_IRQ_COUNT]
Definition: netx_drv_tim.c:68
DRV_TIM_DEVICE_ID_SYSTIME_COM
Definition: netx_drv_csp_netx90_app.h:354
timer_app_Type::timer_timer
__IOM uint32_t timer_timer[3]
Definition: netx90_app.h:25201
gpio_app_Type::gpio_app_counter_cnt
__IOM uint32_t gpio_app_counter_cnt[3]
Definition: netx90_app.h:24693
DRV_TIMER_DEVICE
#define DRV_TIMER_DEVICE
Definition: netx_drv_csp_netx90_app.h:364
DRV_LOCK_INITIALIZER
#define DRV_LOCK_INITIALIZER
Initializer of the type to be locked as rvalue is in default the mutex initializer.
Definition: netx_drv_conf.h:102
timer_app_Type::timer_irq_msk_set_b
struct timer_app_Type::@5281::@5295 timer_irq_msk_set_b
DRV_TIM_STATE_STOPPED
Definition: netx_drv_tim.h:96
DRV_DIO_MSK_GPIO_0
#define DRV_DIO_MSK_GPIO_0
Definition: netx_drv_csp_netx90_app.h:135
__WEAK
#define __WEAK
Definition: cmsis_armcc.h:71
IRQn_Type
IRQn_Type
Definition: netx90_app.h:57
DRV_NVIC_DisableIRQ
void DRV_NVIC_DisableIRQ(IRQn_Type IRQn)
This method disables a given interrupt.
Definition: netx_drv_cortex.c:73
SysTick_Type::CTRL
__IOM uint32_t CTRL
Definition: core_cm4.h:761
DRV_TIM_DEVICE_U::ptSystimlt
DRV_SYSTIME_LT_DEVICE_T * ptSystimlt
Definition: netx_drv_tim.h:51
DRV_TIM_HANDLE_T::DRV_TIM_SetPreload
DRV_STATUS_E DRV_TIM_SetPreload(DRV_TIM_HANDLE_T *const ptTim, DRV_TIM_PRELOAD_VALUE_E tCounterValue)
Sets a new preload value.
Definition: netx_drv_tim.c:1281
aulIRQnTable
static IRQn_Type const aulIRQnTable[DRV_TIM_IRQ_COUNT]
Table of the IRQ vector numbers.
Definition: netx_drv_tim.c:56
DRV_TIM_HANDLE_T::DRV_TIM_Pause
DRV_STATUS_E DRV_TIM_Pause(DRV_TIM_HANDLE_T *const ptTim)
Pauses the TIM generation.
Definition: netx_drv_tim.c:619
DRV_TIM_IRQ_COUNT
#define DRV_TIM_IRQ_COUNT
Definition: netx_drv_csp_netx90_app.h:375
gpio_app_Type::gpio_app_cfg_b
struct gpio_app_Type::@5163::@5193 gpio_app_cfg_b[8]
DRV_TIM_DEVICE_ID_GPIOCNTR0
Definition: netx_drv_csp_netx90_app.h:339
DRV_TIM_STATE_PAUSED
Definition: netx_drv_tim.h:97
DRV_TIM_HANDLE_T::DRV_TIM_GetState
DRV_STATUS_E DRV_TIM_GetState(DRV_TIM_HANDLE_T *const ptTim, DRV_TIM_STATE_E *const peState)
Stores the state of the given counter.
Definition: netx_drv_tim.c:1091
DRV_TIM_DEVICE_ID_SYSTICK
Definition: netx_drv_csp_netx90_app.h:352
gpio_app_Type::gpio_app_counter_max
__IOM uint32_t gpio_app_counter_max[3]
Definition: netx90_app.h:24682
DRV_TIM_IRQ_GPIOTIM0
Definition: netx_drv_tim.c:41
DRV_TIM_DEVICE_ID_TIMER1
Definition: netx_drv_csp_netx90_app.h:346
DRV_TIM_IRQ_TIMER1
Definition: netx_drv_tim.c:45
timer_app_Type::timer_systime_s
__IM uint32_t timer_systime_s
Definition: netx90_app.h:25209
DRV_TIM_SYSTIME_REFERENCE_MIN
Definition: netx_drv_tim.h:141
timer_app_Type::timer_config_timer_b
struct timer_app_Type::@5265::@5287 timer_config_timer_b[3]
DRV_TIM_STATE_ERROR
Definition: netx_drv_tim.h:100
SysTick_CTRL_COUNTFLAG_Msk
#define SysTick_CTRL_COUNTFLAG_Msk
Definition: core_cm4.h:769
DRV_TIM_HANDLE_T::DRV_TIM_Start
DRV_STATUS_E DRV_TIM_Start(DRV_TIM_HANDLE_T *const ptTim)
Starts the TIM generation.
Definition: netx_drv_tim.c:338
SysTick
#define SysTick
Definition: core_cm4.h:1562
SysTick_Type::VAL
__IOM uint32_t VAL
Definition: core_cm4.h:763
DRV_TIM_CONFIGURATION_T::tPreloadValue
DRV_TIM_PRELOAD_VALUE_E tPreloadValue
Definition: netx_drv_tim.h:178
DRV_NVIC_EnableIRQ
void DRV_NVIC_EnableIRQ(IRQn_Type IRQn)
This method enables a given interrupt.
Definition: netx_drv_cortex.c:64
DRV_TIM_HANDLE_T::DRV_TIM_Init
DRV_STATUS_E DRV_TIM_Init(DRV_TIM_HANDLE_T *const ptTim)
Initializes the TIM Base peripheral.
Definition: netx_drv_tim.c:107
DRV_TIM_DEVICE_U::ptSysTick
SysTick_Type * ptSysTick
Definition: netx_drv_tim.h:50
DRV_TIM_GPIOTIM0_Callback
void DRV_TIM_GPIOTIM0_Callback(void)
This is the callback of the GPIOTIM 0 IRQ.
Definition: netx_drv_tim.c:1354
DRV_TOUT
Definition: netx_drv_def.h:58
SysTick_Handler
void SysTick_Handler(void)
This function handles interrupts requests.
Definition: netx_drv_tim.c:1521
DRV_TIM_HANDLE_T::DRV_TIM_ChannelGetCapture
DRV_STATUS_E DRV_TIM_ChannelGetCapture(DRV_TIM_HANDLE_T *const ptTim, DRV_DIO_ID_T ulChannelID, uint32_t *const ulValue)
This function gets the captured value of the specified channel.
Definition: netx_drv_tim.c:973
DRV_BUSY
Definition: netx_drv_def.h:57
gpio_app_Type::gpio_app_cnt_irq_raw
__IOM uint32_t gpio_app_cnt_irq_raw
Definition: netx90_app.h:24820
DRV_ERROR
Definition: netx_drv_def.h:56
DRV_TIM_CONFIGURATION_T::eDioIdInputReference
DRV_DIO_ID_T eDioIdInputReference
Definition: netx_drv_tim.h:182
NVIC_EnableIRQ
#define NVIC_EnableIRQ
Definition: core_cm4.h:1611
TIM0_IRQHandler
void TIM0_IRQHandler(void)
This function handles interrupts requests.
Definition: netx_drv_tim.c:1420
SysTick_Type::LOAD
__IOM uint32_t LOAD
Definition: core_cm4.h:762
DRV_DIO_LINE_MSK_GPIO
#define DRV_DIO_LINE_MSK_GPIO
Definition: netx_drv_csp_netx90_app.h:127
GPIOTIM0_IRQHandler
void GPIOTIM0_IRQHandler(void)
This function handles interrupts requests.
Definition: netx_drv_tim.c:1341
NVIC_DisableIRQ
#define NVIC_DisableIRQ
Definition: core_cm4.h:1613
DRV_TIM_DEVICE_ID_TIMER2
Definition: netx_drv_csp_netx90_app.h:347
DRV_TIM_IRQ_SYSTIME_COMPARE
Definition: netx_drv_tim.c:47
s_apTIMCallbackTable
static DRV_CALLBACK_F s_apTIMCallbackTable[DRV_TIM_IRQ_COUNT]
Used for mapping the handle to an interrupt.
Definition: netx_drv_tim.c:63
DRV_TIM_TIMER1_Callback
void DRV_TIM_TIMER1_Callback(void)
This is the callback of the TIMER 1 IRQ.
Definition: netx_drv_tim.c:1458
timer_app_timer_irq_masked_timer1_irq_Msk
#define timer_app_timer_irq_masked_timer1_irq_Msk
Definition: netx90_app.h:47528
DRV_TIM_CONFIGURATION_T::eExternalEventTrigger
DRV_TIM_EXTERNAL_EVENT_TRIGGER_E eExternalEventTrigger
Definition: netx_drv_tim.h:180
DRV_OPERATION_MODE_POLL
Definition: netx_drv_def.h:71
DRV_TIM_HANDLE_T::DRV_TIM_Stop
DRV_STATUS_E DRV_TIM_Stop(DRV_TIM_HANDLE_T *const ptTim)
Stops the TIM generation.
Definition: netx_drv_tim.c:477
DRV_OPERATION_MODE_DMA
Definition: netx_drv_def.h:73
DRV_LOCK
#define DRV_LOCK(__HANDLE__)
A function calling the trylock of the mutex and returning locked in case it is blocked.
Definition: netx_drv_conf.h:107
DRV_TIMER_IRQs
#define DRV_TIMER_IRQs
Definition: netx_drv_csp_netx90_app.h:372
DRV_DIO_ID_GPIO_MIN
#define DRV_DIO_ID_GPIO_MIN
Definition: netx_drv_csp_netx90_app.h:231
gpio_xpic_app_gpio_app_cnt_irq_raw_cnt1_Msk
#define gpio_xpic_app_gpio_app_cnt_irq_raw_cnt1_Msk
Definition: netx90_app.h:50818
gpio_xpic_app_gpio_app_cnt_irq_raw_cnt0_Msk
#define gpio_xpic_app_gpio_app_cnt_irq_raw_cnt0_Msk
Definition: netx90_app.h:50820
DRV_TIM_TIMER2_Callback
void DRV_TIM_TIMER2_Callback(void)
This is the callback of the TIMER 2 IRQ.
Definition: netx_drv_tim.c:1483
DRV_TIM_IRQ_GPIOTIM2
Definition: netx_drv_tim.c:43
DRV_TIM_HANDLE_T::DRV_TIM_Wait
DRV_STATUS_E DRV_TIM_Wait(DRV_TIM_HANDLE_T *const ptTim, uint32_t ulTickCnt)
Waits at least until uSkipCnt events have occurred.
Definition: netx_drv_tim.c:747
DRV_TIM_HANDLE_T::DRV_TIM_DeInit
DRV_STATUS_E DRV_TIM_DeInit(DRV_TIM_HANDLE_T *const ptTim)
DeInitializes the TIM Base peripheral.
Definition: netx_drv_tim.c:267
DRV_TIM_GPIOTIM1_Callback
void DRV_TIM_GPIOTIM1_Callback(void)
This is the callback of the GPIOTIM 1 IRQ.
Definition: netx_drv_tim.c:1381
DRV_TIM_COUNTING_MODE_CONTINUOUS
Definition: netx_drv_tim.h:152
DRV_TIM_HANDLE_T::eState
DRV_TIM_STATE_E eState
Definition: netx_drv_tim.h:202
DRV_TIM_SYSTIME_REFERENCE_DEFAULT
Definition: netx_drv_tim.h:136
DRV_TIM_IRQ_GPIOTIM1
Definition: netx_drv_tim.c:42
DRV_TIM_STATE_TIMEOUT
Definition: netx_drv_tim.h:99
DRV_TIM_CONFIGURATION_T::eCountingMode
DRV_TIM_COUNTING_MODE_E eCountingMode
Definition: netx_drv_tim.h:184
DRV_TIM_HANDLE_T::DRV_TIM_IRQAttach
DRV_STATUS_E DRV_TIM_IRQAttach(DRV_TIM_HANDLE_T *const ptTim, DRV_CALLBACK_F pfnUserClb, void *pvUser)
Attaches a given callback to the counter.
Definition: netx_drv_tim.c:1016
DRV_TIM_PRELOAD_VALUE_E
DRV_TIM_PRELOAD_VALUE_E
Time structure of the timer driver.
Definition: netx_drv_tim.h:61
DRV_TIM_DEVICE_U::ptGpio
DRV_GPIO_DEVICE_T * ptGpio
Definition: netx_drv_tim.h:47
timer_app_timer_irq_masked_systime_s_irq_Msk
#define timer_app_timer_irq_masked_systime_s_irq_Msk
Definition: netx90_app.h:47524
systime_lt_app_Type
systime_lt_app (systime_lt_app)
Definition: netx90_app.h:25347
timer_app_Type::timer_irq_msk_reset_b
struct timer_app_Type::@5283::@5296 timer_irq_msk_reset_b
netx_drv.h
This file contains all the functions prototypes for the peripheral module driver. ...
timer_app_timer_irq_masked_timer0_irq_Msk
#define timer_app_timer_irq_masked_timer0_irq_Msk
Definition: netx90_app.h:47530
DRV_OPERATION_MODE_IRQ
Definition: netx_drv_def.h:72
DRV_ERROR_PARAM
Definition: netx_drv_def.h:61
DRV_TIM_COUNTING_MODE_RESERVED
Definition: netx_drv_tim.h:154
DRV_TIM_HANDLE_T
Timer Base Handle Structure definition.
Definition: netx_drv_tim.h:196
DRV_TIM_HANDLE_T::tLock
DRV_LOCK_T tLock
Definition: netx_drv_tim.h:201
SysTick_IRQn
Definition: netx90_app.h:70
DRV_SYSTIME_COMPARE_IRQ
#define DRV_SYSTIME_COMPARE_IRQ
Definition: netx_drv_csp_netx90_app.h:373
gpio_app_Type::gpio_app_cnt_irq_mask_set
__IOM uint32_t gpio_app_cnt_irq_mask_set
Definition: netx90_app.h:24854
timer_app_Type::timer_irq_raw
__IOM uint32_t timer_irq_raw
Definition: netx90_app.h:25254
DRV_TIM_IRQ_TIMER0
Definition: netx_drv_tim.c:44
GPIOTIM1_IRQHandler
void GPIOTIM1_IRQHandler(void)
This function handles interrupts requests.
Definition: netx_drv_tim.c:1368
UNUSED
#define UNUSED(x)
If there is the need to outsmart the compiler or linter.
Definition: netx_drv_def.h:40
DRV_TIM_CONFIGURATION_T::eDeviceID
DRV_TIM_DEVICE_ID_E eDeviceID
Definition: netx_drv_tim.h:176
DRV_TIM_DEVICE_ID_SYSTIME_APP
Definition: netx_drv_csp_netx90_app.h:356
gpio_app_Type::gpio_app_tc
__IOM uint32_t gpio_app_tc[8]
Definition: netx90_app.h:24636
DRV_TIM_SYSTIME_COMPARE_Callback
void DRV_TIM_SYSTIME_COMPARE_Callback(void)
This is the callback of the SYSTIME COMPARE IRQ.
Definition: netx_drv_tim.c:1508
DRV_DIO_ID_GPIO_MAX
#define DRV_DIO_ID_GPIO_MAX
Definition: netx_drv_csp_netx90_app.h:240
DRV_GPIO_DEVICE
#define DRV_GPIO_DEVICE
Definition: netx_drv_csp_netx90_app.h:105
DRV_TIM_HANDLE_T::tConfiguration
DRV_TIM_CONFIGURATION_T tConfiguration
Definition: netx_drv_tim.h:200
DRV_TIM_DEVICE_ID_TIMER_MIN
Definition: netx_drv_csp_netx90_app.h:348
DRV_TIM_DEVICE_ID_SYSTIMECOMPARE
Definition: netx_drv_csp_netx90_app.h:351
SysTick_Type
Structure type to access the System Timer (SysTick).
Definition: core_cm4.h:759
DRV_TIM_DEVICE_ID_TIMER_MAX
Definition: netx_drv_csp_netx90_app.h:349
DRV_DIO_ID_T
uint32_t DRV_DIO_ID_T
Type definition for the driver io channel ids.
Definition: netx_drv_dio.h:73
DRV_CALLBACK_F
void(* DRV_CALLBACK_F)(void *pvDriverHandle, void *pvUserHandle)
The definition of callbacks used in the driver.
Definition: netx_drv_def.h:48
GPIOTIM2_IRQHandler
void GPIOTIM2_IRQHandler(void)
This function handles interrupts requests.
Definition: netx_drv_tim.c:1394
DRV_STATUS_E
DRV_STATUS_E
DRV Status structures definition.
Definition: netx_drv_def.h:53
DRV_TIM_DEVICE_ID_GPIOCNTR2
Definition: netx_drv_csp_netx90_app.h:341
DRV_TIM_DEVICE_ID_SYSTIME_MAX
Definition: netx_drv_csp_netx90_app.h:358
NVIC_SetPriority
#define NVIC_SetPriority
Definition: core_cm4.h:1618
DRV_TIM_CONFIGURATION_T::eSymmetric
DRV_TIM_SYMMETRIC_E eSymmetric
Definition: netx_drv_tim.h:185
DRV_TIM_HANDLE_T::ulSubID
uint32_t ulSubID
Definition: netx_drv_tim.h:198
DRV_HANDLE_CHECK
#define DRV_HANDLE_CHECK(handle)
Definition: netx_drv_tim.c:84
TIM2_IRQHandler
void TIM2_IRQHandler(void)
This function handles interrupts requests.
Definition: netx_drv_tim.c:1470
DRV_TIM_DEVICE_ID_SYSTIME_COM_UC
Definition: netx_drv_csp_netx90_app.h:355
DRV_TIM_ARMSYSTICK_Callback
void DRV_TIM_ARMSYSTICK_Callback(void)
This is the callback of the SYSTEM TICK IRQ.
Definition: netx_drv_tim.c:1533
DRV_NVIC_ClearPendingIRQ
void DRV_NVIC_ClearPendingIRQ(IRQn_Type IRQn)
This method clears the pending state of a given interrupt.
Definition: netx_drv_cortex.c:143
SYSTIME_IRQHandler
void SYSTIME_IRQHandler(void)
This function handles interrupts requests.
Definition: netx_drv_tim.c:1495
DRV_TIM_CONFIGURATION_T::eDioMskOutputReference
DRV_DIO_MSK_T eDioMskOutputReference
Definition: netx_drv_tim.h:183
gpio_app_Type::gpio_app_counter_ctrl_b
struct gpio_app_Type::@5167::@5195 gpio_app_counter_ctrl_b[3]
DRV_TIM_GPIOTIM2_Callback
void DRV_TIM_GPIOTIM2_Callback(void)
This is the callback of the GPIOTIM 2 IRQ.
Definition: netx_drv_tim.c:1407
DRV_TIM_DEVICE_ID_GPIOCNTR_MIN
Definition: netx_drv_csp_netx90_app.h:342
DRV_TIM_SYMMETRIC_TRIANGLE
Definition: netx_drv_tim.h:165
DRV_UNLOCK
#define DRV_UNLOCK(__HANDLE__)
The release function used.
Definition: netx_drv_conf.h:112
DRV_TIM_IRQ_TIMER2
Definition: netx_drv_tim.c:46
SysTick_CTRL_CLKSOURCE_Msk
#define SysTick_CTRL_CLKSOURCE_Msk
Definition: core_cm4.h:772
DRV_TIM_DEVICE_ID_SYSTIME_MIN
Definition: netx_drv_csp_netx90_app.h:357
SysTick_CTRL_ENABLE_Msk
#define SysTick_CTRL_ENABLE_Msk
Definition: core_cm4.h:778
DRV_TIM_DEVICE_ID_GPIOCNTR_MAX
Definition: netx_drv_csp_netx90_app.h:343
DRV_OK
Definition: netx_drv_def.h:55
DRV_GPIO_COUNTER_IRQs
#define DRV_GPIO_COUNTER_IRQs
Definition: netx_drv_csp_netx90_app.h:371
timer_app_Type::timer_irq_raw_b
struct timer_app_Type::@5277::@5293 timer_irq_raw_b
DRV_TIM_COUNTING_MODE_ONCE
Definition: netx_drv_tim.h:151
timer_app_Type::timer_irq_msk_set
__IOM uint32_t timer_irq_msk_set
Definition: netx90_app.h:25284
DRV_TIM_STATE_RUNNING
Definition: netx_drv_tim.h:98
DRV_TIM_IRQ_LIST
#define DRV_TIM_IRQ_LIST
Definition: netx_drv_csp_netx90_app.h:376
DRV_TIM_DEVICE_ID_GPIOCNTR1
Definition: netx_drv_csp_netx90_app.h:340
DRV_TIM_STATE_E
DRV_TIM_STATE_E
Enumeration of the timer State.
Definition: netx_drv_tim.h:93
s_apTIMIrqCntr
static volatile uint32_t s_apTIMIrqCntr[DRV_TIM_IRQ_COUNT]
Definition: netx_drv_tim.c:78
timer_app_Type::timer_compare_systime_s_value
__IOM uint32_t timer_compare_systime_s_value
Definition: netx90_app.h:25245
gpio_app_Type::gpio_app_cnt_irq_mask_rst
__IOM uint32_t gpio_app_cnt_irq_mask_rst
Definition: netx90_app.h:24876
DRV_TIM_TIMER0_Callback
void DRV_TIM_TIMER0_Callback(void)
This is the callback of the TIMER 0 IRQ.
Definition: netx_drv_tim.c:1433
DRV_TIM_CONFIGURATION_T::eOperationMode
DRV_OPERATION_MODE_E eOperationMode
Definition: netx_drv_tim.h:186
timer_app_Type::timer_preload_timer
__IOM uint32_t timer_preload_timer[3]
Definition: netx90_app.h:25193
__NVIC_PRIO_BITS
#define __NVIC_PRIO_BITS
Definition: netx90_app.h:157
DRV_TIM_CONFIGURATION_T::eExternalEventMode
DRV_TIM_EXTERNAL_EVENT_MODE_E eExternalEventMode
Definition: netx_drv_tim.h:179
timer_app_timer_irq_masked_timer2_irq_Msk
#define timer_app_timer_irq_masked_timer2_irq_Msk
Definition: netx90_app.h:47526
SysTick_CTRL_TICKINT_Msk
#define SysTick_CTRL_TICKINT_Msk
Definition: core_cm4.h:775
timer_app_Type::timer_irq_msk_reset
__IOM uint32_t timer_irq_msk_reset
Definition: netx90_app.h:25307
DRV_TIM_HANDLE_T::ptDevice
DRV_TIM_DEVICE_U ptDevice
Definition: netx_drv_tim.h:199
DRV_NSUPP
Definition: netx_drv_def.h:59
DRV_TIM_DEVICE_U::ptTimer
DRV_TIMER_DEVICE_T * ptTimer
Definition: netx_drv_tim.h:48
s_apTIMCallbackDriverHandleTable
static DRV_TIM_HANDLE_T * s_apTIMCallbackDriverHandleTable[DRV_TIM_IRQ_COUNT]
Definition: netx_drv_tim.c:73
DRV_TIM_CONFIGURATION_T::eSystimeReference
DRV_TIM_SYSTIME_REFERENCE_E eSystimeReference
Definition: netx_drv_tim.h:181