Merge PCB updates
[SCSI2SD.git] / software / SCSI2SD / v4 / SCSI2SD.cydsn / Generated_Source / PSoC5 / Debug_Timer.c
1 /*******************************************************************************
2 * File Name: Debug_Timer.c
3 * Version 2.50
4 *
5 * Description:
6 *  The Timer component consists of a 8, 16, 24 or 32-bit timer with
7 *  a selectable period between 2 and 2^Width - 1.  The timer may free run
8 *  or be used as a capture timer as well.  The capture can be initiated
9 *  by a positive or negative edge signal as well as via software.
10 *  A trigger input can be programmed to enable the timer on rising edge
11 *  falling edge, either edge or continous run.
12 *  Interrupts may be generated due to a terminal count condition
13 *  or a capture event.
14 *
15 * Note:
16 *
17 ********************************************************************************
18 * Copyright 2008-2012, Cypress Semiconductor Corporation.  All rights reserved.
19 * You may use this file only in accordance with the license, terms, conditions,
20 * disclaimers, and limitations in the end user license agreement accompanying
21 * the software package with which this file was provided.
22 ********************************************************************************/
23
24 #include "Debug_Timer.h"
25
26 uint8 Debug_Timer_initVar = 0u;
27
28
29 /*******************************************************************************
30 * Function Name: Debug_Timer_Init
31 ********************************************************************************
32 *
33 * Summary:
34 *  Initialize to the schematic state
35 *
36 * Parameters:
37 *  void
38 *
39 * Return:
40 *  void
41 *
42 *******************************************************************************/
43 void Debug_Timer_Init(void) 
44 {
45     #if(!Debug_Timer_UsingFixedFunction)
46             /* Interrupt State Backup for Critical Region*/
47             uint8 Debug_Timer_interruptState;
48     #endif /* Interrupt state back up for Fixed Function only */
49
50     #if (Debug_Timer_UsingFixedFunction)
51         /* Clear all bits but the enable bit (if it's already set) for Timer operation */
52         Debug_Timer_CONTROL &= Debug_Timer_CTRL_ENABLE;
53
54         /* Clear the mode bits for continuous run mode */
55         #if (CY_PSOC5A)
56             Debug_Timer_CONTROL2 &= ((uint8)(~Debug_Timer_CTRL_MODE_MASK));
57         #endif /* Clear bits in CONTROL2 only in PSOC5A */
58
59         #if (CY_PSOC3 || CY_PSOC5LP)
60             Debug_Timer_CONTROL3 &= ((uint8)(~Debug_Timer_CTRL_MODE_MASK));
61         #endif /* CONTROL3 register exists only in PSoC3 OR PSoC5LP */
62
63         /* Check if One Shot mode is enabled i.e. RunMode !=0*/
64         #if (Debug_Timer_RunModeUsed != 0x0u)
65             /* Set 3rd bit of Control register to enable one shot mode */
66             Debug_Timer_CONTROL |= 0x04u;
67         #endif /* One Shot enabled only when RunModeUsed is not Continuous*/
68
69         #if (Debug_Timer_RunModeUsed == 2)
70             #if (CY_PSOC5A)
71                 /* Set last 2 bits of control2 register if one shot(halt on
72                 interrupt) is enabled*/
73                 Debug_Timer_CONTROL2 |= 0x03u;
74             #endif /* Set One-Shot Halt on Interrupt bit in CONTROL2 for PSoC5A */
75
76             #if (CY_PSOC3 || CY_PSOC5LP)
77                 /* Set last 2 bits of control3 register if one shot(halt on
78                 interrupt) is enabled*/
79                 Debug_Timer_CONTROL3 |= 0x03u;
80             #endif /* Set One-Shot Halt on Interrupt bit in CONTROL3 for PSoC3 or PSoC5LP */
81
82         #endif /* Remove section if One Shot Halt on Interrupt is not enabled */
83
84         #if (Debug_Timer_UsingHWEnable != 0)
85             #if (CY_PSOC5A)
86                 /* Set the default Run Mode of the Timer to Continuous */
87                 Debug_Timer_CONTROL2 |= Debug_Timer_CTRL_MODE_PULSEWIDTH;
88             #endif /* Set Continuous Run Mode in CONTROL2 for PSoC5A */
89
90             #if (CY_PSOC3 || CY_PSOC5LP)
91                 /* Clear and Set ROD and COD bits of CFG2 register */
92                 Debug_Timer_CONTROL3 &= ((uint8)(~Debug_Timer_CTRL_RCOD_MASK));
93                 Debug_Timer_CONTROL3 |= Debug_Timer_CTRL_RCOD;
94
95                 /* Clear and Enable the HW enable bit in CFG2 register */
96                 Debug_Timer_CONTROL3 &= ((uint8)(~Debug_Timer_CTRL_ENBL_MASK));
97                 Debug_Timer_CONTROL3 |= Debug_Timer_CTRL_ENBL;
98
99                 /* Set the default Run Mode of the Timer to Continuous */
100                 Debug_Timer_CONTROL3 |= Debug_Timer_CTRL_MODE_CONTINUOUS;
101             #endif /* Set Continuous Run Mode in CONTROL3 for PSoC3ES3 or PSoC5A */
102
103         #endif /* Configure Run Mode with hardware enable */
104
105         /* Clear and Set SYNCTC and SYNCCMP bits of RT1 register */
106         Debug_Timer_RT1 &= ((uint8)(~Debug_Timer_RT1_MASK));
107         Debug_Timer_RT1 |= Debug_Timer_SYNC;
108
109         /*Enable DSI Sync all all inputs of the Timer*/
110         Debug_Timer_RT1 &= ((uint8)(~Debug_Timer_SYNCDSI_MASK));
111         Debug_Timer_RT1 |= Debug_Timer_SYNCDSI_EN;
112
113         /* Set the IRQ to use the status register interrupts */
114         Debug_Timer_CONTROL2 |= Debug_Timer_CTRL2_IRQ_SEL;
115     #endif /* Configuring registers of fixed function implementation */
116
117     /* Set Initial values from Configuration */
118     Debug_Timer_WritePeriod(Debug_Timer_INIT_PERIOD);
119     Debug_Timer_WriteCounter(Debug_Timer_INIT_PERIOD);
120
121     #if (Debug_Timer_UsingHWCaptureCounter)/* Capture counter is enabled */
122         Debug_Timer_CAPTURE_COUNT_CTRL |= Debug_Timer_CNTR_ENABLE;
123         Debug_Timer_SetCaptureCount(Debug_Timer_INIT_CAPTURE_COUNT);
124     #endif /* Configure capture counter value */
125
126     #if (!Debug_Timer_UsingFixedFunction)
127         #if (Debug_Timer_SoftwareCaptureMode)
128             Debug_Timer_SetCaptureMode(Debug_Timer_INIT_CAPTURE_MODE);
129         #endif /* Set Capture Mode for UDB implementation if capture mode is software controlled */
130
131         #if (Debug_Timer_SoftwareTriggerMode)
132             if (0u == (Debug_Timer_CONTROL & Debug_Timer__B_TIMER__TM_SOFTWARE))
133             {
134                 Debug_Timer_SetTriggerMode(Debug_Timer_INIT_TRIGGER_MODE);
135             }
136         #endif /* Set trigger mode for UDB Implementation if trigger mode is software controlled */
137
138         /* CyEnterCriticalRegion and CyExitCriticalRegion are used to mark following region critical*/
139         /* Enter Critical Region*/
140         Debug_Timer_interruptState = CyEnterCriticalSection();
141
142         /* Use the interrupt output of the status register for IRQ output */
143         Debug_Timer_STATUS_AUX_CTRL |= Debug_Timer_STATUS_ACTL_INT_EN_MASK;
144
145         /* Exit Critical Region*/
146         CyExitCriticalSection(Debug_Timer_interruptState);
147
148         #if (Debug_Timer_EnableTriggerMode)
149             Debug_Timer_EnableTrigger();
150         #endif /* Set Trigger enable bit for UDB implementation in the control register*/
151
152         #if (Debug_Timer_InterruptOnCaptureCount)
153              #if (!Debug_Timer_ControlRegRemoved)
154                 Debug_Timer_SetInterruptCount(Debug_Timer_INIT_INT_CAPTURE_COUNT);
155             #endif /* Set interrupt count in control register if control register is not removed */
156         #endif /*Set interrupt count in UDB implementation if interrupt count feature is checked.*/
157
158         Debug_Timer_ClearFIFO();
159     #endif /* Configure additional features of UDB implementation */
160
161     Debug_Timer_SetInterruptMode(Debug_Timer_INIT_INTERRUPT_MODE);
162 }
163
164
165 /*******************************************************************************
166 * Function Name: Debug_Timer_Enable
167 ********************************************************************************
168 *
169 * Summary:
170 *  Enable the Timer
171 *
172 * Parameters:
173 *  void
174 *
175 * Return:
176 *  void
177 *
178 *******************************************************************************/
179 void Debug_Timer_Enable(void) 
180 {
181     /* Globally Enable the Fixed Function Block chosen */
182     #if (Debug_Timer_UsingFixedFunction)
183         Debug_Timer_GLOBAL_ENABLE |= Debug_Timer_BLOCK_EN_MASK;
184         Debug_Timer_GLOBAL_STBY_ENABLE |= Debug_Timer_BLOCK_STBY_EN_MASK;
185     #endif /* Set Enable bit for enabling Fixed function timer*/
186
187     /* Remove assignment if control register is removed */
188     #if (!Debug_Timer_ControlRegRemoved || Debug_Timer_UsingFixedFunction)
189         Debug_Timer_CONTROL |= Debug_Timer_CTRL_ENABLE;
190     #endif /* Remove assignment if control register is removed */
191 }
192
193
194 /*******************************************************************************
195 * Function Name: Debug_Timer_Start
196 ********************************************************************************
197 *
198 * Summary:
199 *  The start function initializes the timer with the default values, the
200 *  enables the timerto begin counting.  It does not enable interrupts,
201 *  the EnableInt command should be called if interrupt generation is required.
202 *
203 * Parameters:
204 *  void
205 *
206 * Return:
207 *  void
208 *
209 * Global variables:
210 *  Debug_Timer_initVar: Is modified when this function is called for the
211 *   first time. Is used to ensure that initialization happens only once.
212 *
213 *******************************************************************************/
214 void Debug_Timer_Start(void) 
215 {
216     if(Debug_Timer_initVar == 0u)
217     {
218         Debug_Timer_Init();
219
220         Debug_Timer_initVar = 1u;   /* Clear this bit for Initialization */
221     }
222
223     /* Enable the Timer */
224     Debug_Timer_Enable();
225 }
226
227
228 /*******************************************************************************
229 * Function Name: Debug_Timer_Stop
230 ********************************************************************************
231 *
232 * Summary:
233 *  The stop function halts the timer, but does not change any modes or disable
234 *  interrupts.
235 *
236 * Parameters:
237 *  void
238 *
239 * Return:
240 *  void
241 *
242 * Side Effects: If the Enable mode is set to Hardware only then this function
243 *               has no effect on the operation of the timer.
244 *
245 *******************************************************************************/
246 void Debug_Timer_Stop(void) 
247 {
248     /* Disable Timer */
249     #if(!Debug_Timer_ControlRegRemoved || Debug_Timer_UsingFixedFunction)
250         Debug_Timer_CONTROL &= ((uint8)(~Debug_Timer_CTRL_ENABLE));
251     #endif /* Remove assignment if control register is removed */
252
253     /* Globally disable the Fixed Function Block chosen */
254     #if (Debug_Timer_UsingFixedFunction)
255         Debug_Timer_GLOBAL_ENABLE &= ((uint8)(~Debug_Timer_BLOCK_EN_MASK));
256         Debug_Timer_GLOBAL_STBY_ENABLE &= ((uint8)(~Debug_Timer_BLOCK_STBY_EN_MASK));
257     #endif /* Disable global enable for the Timer Fixed function block to stop the Timer*/
258 }
259
260
261 /*******************************************************************************
262 * Function Name: Debug_Timer_SetInterruptMode
263 ********************************************************************************
264 *
265 * Summary:
266 *  This function selects which of the interrupt inputs may cause an interrupt.
267 *  The twosources are caputure and terminal.  One, both or neither may
268 *  be selected.
269 *
270 * Parameters:
271 *  interruptMode:   This parameter is used to enable interrups on either/or
272 *                   terminal count or capture.
273 *
274 * Return:
275 *  void
276 *
277 *******************************************************************************/
278 void Debug_Timer_SetInterruptMode(uint8 interruptMode) 
279 {
280     Debug_Timer_STATUS_MASK = interruptMode;
281 }
282
283
284 /*******************************************************************************
285 * Function Name: Debug_Timer_SoftwareCapture
286 ********************************************************************************
287 *
288 * Summary:
289 *  This function forces a capture independent of the capture signal.
290 *
291 * Parameters:
292 *  void
293 *
294 * Return:
295 *  void
296 *
297 * Side Effects:
298 *  An existing hardware capture could be overwritten.
299 *
300 *******************************************************************************/
301 void Debug_Timer_SoftwareCapture(void) 
302 {
303     /* Generate a software capture by reading the counter register */
304     (void)Debug_Timer_COUNTER_LSB;
305     /* Capture Data is now in the FIFO */
306 }
307
308
309 /*******************************************************************************
310 * Function Name: Debug_Timer_ReadStatusRegister
311 ********************************************************************************
312 *
313 * Summary:
314 *  Reads the status register and returns it's state. This function should use
315 *  defined types for the bit-field information as the bits in this register may
316 *  be permuteable.
317 *
318 * Parameters:
319 *  void
320 *
321 * Return:
322 *  The contents of the status register
323 *
324 * Side Effects:
325 *  Status register bits may be clear on read.
326 *
327 *******************************************************************************/
328 uint8   Debug_Timer_ReadStatusRegister(void) 
329 {
330     return (Debug_Timer_STATUS);
331 }
332
333
334 #if (!Debug_Timer_ControlRegRemoved) /* Remove API if control register is removed */
335
336
337 /*******************************************************************************
338 * Function Name: Debug_Timer_ReadControlRegister
339 ********************************************************************************
340 *
341 * Summary:
342 *  Reads the control register and returns it's value.
343 *
344 * Parameters:
345 *  void
346 *
347 * Return:
348 *  The contents of the control register
349 *
350 *******************************************************************************/
351 uint8 Debug_Timer_ReadControlRegister(void) 
352 {
353     return ((uint8)Debug_Timer_CONTROL);
354 }
355
356
357 /*******************************************************************************
358 * Function Name: Debug_Timer_WriteControlRegister
359 ********************************************************************************
360 *
361 * Summary:
362 *  Sets the bit-field of the control register.
363 *
364 * Parameters:
365 *  control: The contents of the control register
366 *
367 * Return:
368 *
369 *******************************************************************************/
370 void Debug_Timer_WriteControlRegister(uint8 control) 
371 {
372     Debug_Timer_CONTROL = control;
373 }
374 #endif /* Remove API if control register is removed */
375
376
377 /*******************************************************************************
378 * Function Name: Debug_Timer_ReadPeriod
379 ********************************************************************************
380 *
381 * Summary:
382 *  This function returns the current value of the Period.
383 *
384 * Parameters:
385 *  void
386 *
387 * Return:
388 *  The present value of the counter.
389 *
390 *******************************************************************************/
391 uint16 Debug_Timer_ReadPeriod(void) 
392 {
393    #if(Debug_Timer_UsingFixedFunction)
394        return ((uint16)CY_GET_REG16(Debug_Timer_PERIOD_LSB_PTR));
395    #else
396        return (CY_GET_REG16(Debug_Timer_PERIOD_LSB_PTR));
397    #endif /* (Debug_Timer_UsingFixedFunction) */
398 }
399
400
401 /*******************************************************************************
402 * Function Name: Debug_Timer_WritePeriod
403 ********************************************************************************
404 *
405 * Summary:
406 *  This function is used to change the period of the counter.  The new period
407 *  will be loaded the next time terminal count is detected.
408 *
409 * Parameters:
410 *  period: This value may be between 1 and (2^Resolution)-1.  A value of 0 will
411 *          result in the counter remaining at zero.
412 *
413 * Return:
414 *  void
415 *
416 *******************************************************************************/
417 void Debug_Timer_WritePeriod(uint16 period) 
418 {
419     #if(Debug_Timer_UsingFixedFunction)
420         uint16 period_temp = (uint16)period;
421         CY_SET_REG16(Debug_Timer_PERIOD_LSB_PTR, period_temp);
422     #else
423         CY_SET_REG16(Debug_Timer_PERIOD_LSB_PTR, period);
424     #endif /*Write Period value with appropriate resolution suffix depending on UDB or fixed function implementation */
425 }
426
427
428 /*******************************************************************************
429 * Function Name: Debug_Timer_ReadCapture
430 ********************************************************************************
431 *
432 * Summary:
433 *  This function returns the last value captured.
434 *
435 * Parameters:
436 *  void
437 *
438 * Return:
439 *  Present Capture value.
440 *
441 *******************************************************************************/
442 uint16 Debug_Timer_ReadCapture(void) 
443 {
444    #if(Debug_Timer_UsingFixedFunction)
445        return ((uint16)CY_GET_REG16(Debug_Timer_CAPTURE_LSB_PTR));
446    #else
447        return (CY_GET_REG16(Debug_Timer_CAPTURE_LSB_PTR));
448    #endif /* (Debug_Timer_UsingFixedFunction) */
449 }
450
451
452 /*******************************************************************************
453 * Function Name: Debug_Timer_WriteCounter
454 ********************************************************************************
455 *
456 * Summary:
457 *  This funtion is used to set the counter to a specific value
458 *
459 * Parameters:
460 *  counter:  New counter value.
461 *
462 * Return:
463 *  void
464 *
465 *******************************************************************************/
466 void Debug_Timer_WriteCounter(uint16 counter) \
467                                    
468 {
469    #if(Debug_Timer_UsingFixedFunction)
470         /* This functionality is removed until a FixedFunction HW update to
471          * allow this register to be written
472          */
473         CY_SET_REG16(Debug_Timer_COUNTER_LSB_PTR, (uint16)counter);
474         
475     #else
476         CY_SET_REG16(Debug_Timer_COUNTER_LSB_PTR, counter);
477     #endif /* Set Write Counter only for the UDB implementation (Write Counter not available in fixed function Timer */
478 }
479
480
481 /*******************************************************************************
482 * Function Name: Debug_Timer_ReadCounter
483 ********************************************************************************
484 *
485 * Summary:
486 *  This function returns the current counter value.
487 *
488 * Parameters:
489 *  void
490 *
491 * Return:
492 *  Present compare value.
493 *
494 *******************************************************************************/
495 uint16 Debug_Timer_ReadCounter(void) 
496 {
497
498     /* Force capture by reading Accumulator */
499     /* Must first do a software capture to be able to read the counter */
500     /* It is up to the user code to make sure there isn't already captured data in the FIFO */
501     (void)Debug_Timer_COUNTER_LSB;
502
503     /* Read the data from the FIFO (or capture register for Fixed Function)*/
504     #if(Debug_Timer_UsingFixedFunction)
505         return ((uint16)CY_GET_REG16(Debug_Timer_CAPTURE_LSB_PTR));
506     #else
507         return (CY_GET_REG16(Debug_Timer_CAPTURE_LSB_PTR));
508     #endif /* (Debug_Timer_UsingFixedFunction) */
509 }
510
511
512 #if(!Debug_Timer_UsingFixedFunction) /* UDB Specific Functions */
513
514 /*******************************************************************************
515  * The functions below this point are only available using the UDB
516  * implementation.  If a feature is selected, then the API is enabled.
517  ******************************************************************************/
518
519
520 #if (Debug_Timer_SoftwareCaptureMode)
521
522
523 /*******************************************************************************
524 * Function Name: Debug_Timer_SetCaptureMode
525 ********************************************************************************
526 *
527 * Summary:
528 *  This function sets the capture mode to either rising or falling edge.
529 *
530 * Parameters:
531 *  captureMode: This parameter sets the capture mode of the UDB capture feature
532 *  The parameter values are defined using the
533 *  #define Debug_Timer__B_TIMER__CM_NONE 0
534 #define Debug_Timer__B_TIMER__CM_RISINGEDGE 1
535 #define Debug_Timer__B_TIMER__CM_FALLINGEDGE 2
536 #define Debug_Timer__B_TIMER__CM_EITHEREDGE 3
537 #define Debug_Timer__B_TIMER__CM_SOFTWARE 4
538  identifiers
539 *  The following are the possible values of the parameter
540 *  Debug_Timer__B_TIMER__CM_NONE        - Set Capture mode to None
541 *  Debug_Timer__B_TIMER__CM_RISINGEDGE  - Rising edge of Capture input
542 *  Debug_Timer__B_TIMER__CM_FALLINGEDGE - Falling edge of Capture input
543 *  Debug_Timer__B_TIMER__CM_EITHEREDGE  - Either edge of Capture input
544 *
545 * Return:
546 *  void
547 *
548 *******************************************************************************/
549 void Debug_Timer_SetCaptureMode(uint8 captureMode) 
550 {
551     /* This must only set to two bits of the control register associated */
552     captureMode = ((uint8)((uint8)captureMode << Debug_Timer_CTRL_CAP_MODE_SHIFT));
553     captureMode &= (Debug_Timer_CTRL_CAP_MODE_MASK);
554
555     /* Clear the Current Setting */
556     Debug_Timer_CONTROL &= ((uint8)(~Debug_Timer_CTRL_CAP_MODE_MASK));
557
558     /* Write The New Setting */
559     Debug_Timer_CONTROL |= captureMode;
560 }
561 #endif /* Remove API if Capture Mode is not Software Controlled */
562
563
564 #if (Debug_Timer_SoftwareTriggerMode)
565
566
567 /*******************************************************************************
568 * Function Name: Debug_Timer_SetTriggerMode
569 ********************************************************************************
570 *
571 * Summary:
572 *  This function sets the trigger input mode
573 *
574 * Parameters:
575 *  triggerMode: Pass one of the pre-defined Trigger Modes (except Software)
576     #define Debug_Timer__B_TIMER__TM_NONE 0x00u
577     #define Debug_Timer__B_TIMER__TM_RISINGEDGE 0x04u
578     #define Debug_Timer__B_TIMER__TM_FALLINGEDGE 0x08u
579     #define Debug_Timer__B_TIMER__TM_EITHEREDGE 0x0Cu
580     #define Debug_Timer__B_TIMER__TM_SOFTWARE 0x10u
581 *
582 * Return:
583 *  void
584 *
585 *******************************************************************************/
586 void Debug_Timer_SetTriggerMode(uint8 triggerMode) 
587 {
588     /* This must only set to two bits of the control register associated */
589     triggerMode &= Debug_Timer_CTRL_TRIG_MODE_MASK;
590
591     /* Clear the Current Setting */
592     Debug_Timer_CONTROL &= ((uint8)(~Debug_Timer_CTRL_TRIG_MODE_MASK));
593
594     /* Write The New Setting */
595     Debug_Timer_CONTROL |= (triggerMode | Debug_Timer__B_TIMER__TM_SOFTWARE);
596
597 }
598 #endif /* Remove API if Trigger Mode is not Software Controlled */
599
600 #if (Debug_Timer_EnableTriggerMode)
601
602
603 /*******************************************************************************
604 * Function Name: Debug_Timer_EnableTrigger
605 ********************************************************************************
606 *
607 * Summary:
608 *  Sets the control bit enabling Hardware Trigger mode
609 *
610 * Parameters:
611 *  void
612 *
613 * Return:
614 *  void
615 *
616 *******************************************************************************/
617 void Debug_Timer_EnableTrigger(void) 
618 {
619     #if (!Debug_Timer_ControlRegRemoved)   /* Remove assignment if control register is removed */
620         Debug_Timer_CONTROL |= Debug_Timer_CTRL_TRIG_EN;
621     #endif /* Remove code section if control register is not used */
622 }
623
624
625 /*******************************************************************************
626 * Function Name: Debug_Timer_DisableTrigger
627 ********************************************************************************
628 *
629 * Summary:
630 *  Clears the control bit enabling Hardware Trigger mode
631 *
632 * Parameters:
633 *  void
634 *
635 * Return:
636 *  void
637 *
638 *******************************************************************************/
639 void Debug_Timer_DisableTrigger(void) 
640 {
641     #if (!Debug_Timer_ControlRegRemoved)   /* Remove assignment if control register is removed */
642         Debug_Timer_CONTROL &= ((uint8)(~Debug_Timer_CTRL_TRIG_EN));
643     #endif /* Remove code section if control register is not used */
644 }
645 #endif /* Remove API is Trigger Mode is set to None */
646
647
648 #if(Debug_Timer_InterruptOnCaptureCount)
649 #if (!Debug_Timer_ControlRegRemoved)   /* Remove API if control register is removed */
650
651
652 /*******************************************************************************
653 * Function Name: Debug_Timer_SetInterruptCount
654 ********************************************************************************
655 *
656 * Summary:
657 *  This function sets the capture count before an interrupt is triggered.
658 *
659 * Parameters:
660 *  interruptCount:  A value between 0 and 3 is valid.  If the value is 0, then
661 *                   an interrupt will occur each time a capture occurs.
662 *                   A value of 1 to 3 will cause the interrupt
663 *                   to delay by the same number of captures.
664 *
665 * Return:
666 *  void
667 *
668 *******************************************************************************/
669 void Debug_Timer_SetInterruptCount(uint8 interruptCount) 
670 {
671     /* This must only set to two bits of the control register associated */
672     interruptCount &= Debug_Timer_CTRL_INTCNT_MASK;
673
674     /* Clear the Current Setting */
675     Debug_Timer_CONTROL &= ((uint8)(~Debug_Timer_CTRL_INTCNT_MASK));
676     /* Write The New Setting */
677     Debug_Timer_CONTROL |= interruptCount;
678 }
679 #endif /* Remove API if control register is removed */
680 #endif /* Debug_Timer_InterruptOnCaptureCount */
681
682
683 #if (Debug_Timer_UsingHWCaptureCounter)
684
685
686 /*******************************************************************************
687 * Function Name: Debug_Timer_SetCaptureCount
688 ********************************************************************************
689 *
690 * Summary:
691 *  This function sets the capture count
692 *
693 * Parameters:
694 *  captureCount: A value between 2 and 127 inclusive is valid.  A value of 1
695 *                to 127 will cause the interrupt to delay by the same number of
696 *                captures.
697 *
698 * Return:
699 *  void
700 *
701 *******************************************************************************/
702 void Debug_Timer_SetCaptureCount(uint8 captureCount) 
703 {
704     Debug_Timer_CAP_COUNT = captureCount;
705 }
706
707
708 /*******************************************************************************
709 * Function Name: Debug_Timer_ReadCaptureCount
710 ********************************************************************************
711 *
712 * Summary:
713 *  This function reads the capture count setting
714 *
715 * Parameters:
716 *  void
717 *
718 * Return:
719 *  Returns the Capture Count Setting
720 *
721 *******************************************************************************/
722 uint8 Debug_Timer_ReadCaptureCount(void) 
723 {
724     return ((uint8)Debug_Timer_CAP_COUNT);
725 }
726 #endif /* Debug_Timer_UsingHWCaptureCounter */
727
728
729 /*******************************************************************************
730 * Function Name: Debug_Timer_ClearFIFO
731 ********************************************************************************
732 *
733 * Summary:
734 *  This function clears all capture data from the capture FIFO
735 *
736 * Parameters:
737 *  void
738 *
739 * Return:
740 *  void
741 *
742 *******************************************************************************/
743 void Debug_Timer_ClearFIFO(void) 
744 {
745     while(0u != (Debug_Timer_ReadStatusRegister() & Debug_Timer_STATUS_FIFONEMP))
746     {
747         (void)Debug_Timer_ReadCapture();
748     }
749 }
750
751 #endif /* UDB Specific Functions */
752
753
754 /* [] END OF FILE */