/*
* LPO Clock Example (PSC=0x1)
*
* Test is pre-scaled to wait for 10 seconds. In reality it might be slightly off because
* of the trim values for the LPO clock.
*/
void lptmr_lpo_input()
{
unsigned int compare_value=4000; //4 second delay with the 1khz LPO clock
printf("\n\n****************************\n");
printf("LPO Clock Source Example\n");
//Reset LPTMR module
lptmr_clear_registers();
/* Configure LPTMR */
LPTMR0_CMR=LPTMR_CMR_COMPARE(compare_value); //Set compare value
LPTMR0_PSR=LPTMR_PSR_PCS(0x1)|LPTMR_PSR_PBYP_MASK; //Use LPO clock with bypass enabled
printf("LPTMR using LPO clock with no prescale, and compare value=4000 (4 seconds)\n");
printf("Press a key to start counter\n");
in_char();
LPTMR0_CSR|=LPTMR_CSR_TEN_MASK; //Turn on LPT with default settings
printf("Counting...\n\n");
//Wait for Timer Compare Flag to be set
while((LPTMR0_CSR&LPTMR_CSR_TCF_MASK)==0)
{
//This may not get proper counter data if the CNR is read at the same time it is incremented
//printf("Current value of counter register CNR is %d\n",LPTMR0_CNR);
}
printf("4 seconds should have passed\n");
printf("End of LPO Clock Source Example\n");
printf("****************************\n\n");
}
/*
* Counting example using the LPO clock and the prescale feature
*
* Sets compare value to 250. Thus when using the 1Khz LPO clock with
* LPTMR0_PSR[PRESCALE]=0x4, it will take 8 seconds for Timer Compare Flag
* to be set. (1Khz clock/32=31.25Hz clock)
*
* If prescaler was not used, then timer would only wait .25 seconds.
*
*/
void lptmr_prescale()
{
int compare_value=250; //value must be less than 0xFFFF or 65535
printf("\n\n****************************\n");
printf("LPTMR Time Counting Example with Prescaler\n");
//Reset LPTMR module
lptmr_clear_registers();
/* Configure LPTMR */
LPTMR0_CMR=LPTMR_CMR_COMPARE(compare_value); //Set compare value
LPTMR0_PSR=LPTMR_PSR_PCS(0x1)|LPTMR_PSR_PRESCALE(0x4); //Use LPO clock and divide by 32
printf("LPTMR using LPO clock with PRESCALE=4 and compare value=250 (8 seconds)\n");
printf("Press a key to start counter\n");
in_char(); //wait for keyboard press
LPTMR0_CSR|=LPTMR_CSR_TEN_MASK; //Turn on LPTMR with default settings
//Wait for Timer Compare Flag to be set
while((LPTMR0_CSR & LPTMR_CSR_TCF_MASK)==0)
{
//This may not get proper counter data if the CNR is read at the same time it is incremented
printf("Current value of counter register CNR is %d\n",LPTMR0_CNR);
}
printf("Waited for %d counts\n",compare_value);
printf("End of Time Counting Example with Prescale\n");
printf("****************************\n\n");
}
/*
* Timer will trigger interrupt after 5 seconds
*/
void lptmr_interrupt(void)
{
int compare_value=5000; //value must be less than 0xFFFF
LPTMR_INTERRUPT=0; //Clear global variable
//Reset LPTMR module
lptmr_clear_registers();
printf("\n\n****************************\n");
printf("LPTMR Interrupt Example\n");
/* Enable LPT Interrupt in NVIC*/
enable_irq(85); //LPTMR Vector is 101. IRQ# is 101-16=85
/* Configure LPT */
LPTMR0_CMR=LPTMR_CMR_COMPARE(compare_value); //Set compare value
LPTMR0_PSR=LPTMR_PSR_PCS(0x1)|LPTMR_PSR_PBYP_MASK; //Use LPO clock and bypass prescale
LPTMR0_CSR=LPTMR_CSR_TIE_MASK; //Enable LPT interrupt
printf("LPTMR using LPO clock with no prescale, and compare value=5000 (5 seconds)\n");
printf("Press a key to start counter\n");
in_char(); //wait for keyboard press
LPTMR0_CSR|=LPTMR_CSR_TEN_MASK; //Turn on LPTMR and start counting
printf("Counting...\n\n");
/* Wait for the global variable to be set in LPTMR ISR */
while(LPTMR_INTERRUPT==0)
{}
printf("Timer should have waited for 5 seconds\n");
LPTMR0_CSR&=~LPTMR_CSR_TEN_MASK; //Turn off LPT to avoid more interrupts
printf("End of LPTMR Interrupt Example\n");
printf("****************************\n\n");
//Reset LPTMR module
lptmr_clear_registers();
}
/*
* External Reference Clock Example(PSC=0x3)
*
* TWR-K60N512 uses a 50MHz external clock
* TWR-K40X256 uses a 8MHz external clock
*
* Test is pre-scaled to wait for 10 seconds in both cases by adjusting
* the compare value.
*/
void lptmr_external_clk_input()
{
unsigned int compare_value;
printf("\n\n****************************\n");
printf("External Clock Source Example\n");
//Reset LPTMR module
lptmr_clear_registers();
/* Turn on external reference clock */
MCG_C2&=~MCG_C2_EREFS_MASK; //allow extal to drive
OSC_CR |= OSC_CR_ERCLKEN_MASK; // selects EXTAL to drive XOSCxERCLK
//Determine compare value based on which board is being used
#if (defined(K60_CLK))
compare_value=7630; //~10 seconds with prescale=0xF and 50MHz clock
#else
compare_value=1220; //~10 seconds with prescale=0xF and 8MHz clock
#endif
/* Configure LPTMR */
LPTMR0_CMR=LPTMR_CMR_COMPARE(compare_value); //Set compare value
LPTMR0_PSR=LPTMR_PSR_PCS(0x3)|LPTMR_PSR_PRESCALE(0xF); //Use external clock divided by 65536
printf("LPTMR using external clock with PRESCALE=0xF, and compare value=%d (10 seconds)\n",compare_value);
printf("Press a key to start counter\n");
in_char();
LPTMR0_CSR|=LPTMR_CSR_TEN_MASK; //Turn on LPT with default settings
printf("Counting...\n\n");
//Wait for Timer Compare Flag to be set
while((LPTMR0_CSR&LPTMR_CSR_TCF_MASK)==0)
{
//This may not get proper counter data if the CNR is read at the same time it is incremented
//printf("Current value of counter register CNR is %d\n",LPTMR0_CNR);
}
printf("Timer should have waited for 10 seconds\n");
printf("End of External Clock Example\n");
printf("****************************\n\n");
}
/*
* 32kHz Input Clock Test (PSC=0x2)
* The 32kHz clock (ERCLK32K) can come from two clock sources.
* If SOPT1[OSC32KSEL]=1, then it uses 32kHz RTC crystal connected to XTAL32
* This is what the code below tests
* If SOPT1[OSC32KSEL]=0, then it uses 32kHz System oscillator, and reguires
* that the main system clock be a 32kHz crystal. The tower board does not
* support that feature.
*
* Test is pre-scaled to wait for 8 seconds.
*/
void lptmr_32khz_input()
{
unsigned int compare_value=32768; //4 second delay with prescale=1
printf("\n\n****************************\n");
printf("32 Khz Clock Source Example\n");
//Reset LPTMR module
lptmr_clear_registers();
/*
* Configure to use 32Khz clock from RTC clock
*/
printf("Test using RTC OSC\n");
SIM_SCGC6|=SIM_SCGC6_RTC_MASK; //Enable RTC registers
RTC_CR|=RTC_CR_OSCE_MASK; //Turn on RTC oscillator
SIM_SOPT1|=SIM_SOPT1_OSC32KSEL_MASK; //Select RTC OSC as source for ERCLK32K
/* Configure LPTMR */
LPTMR0_CMR=LPTMR_CMR_COMPARE(compare_value); //Set compare value
LPTMR0_PSR=LPTMR_PSR_PCS(0x2)|LPTMR_PSR_PRESCALE(0x1); //Use 32khz clock (ERCLK32K) and divide source by 4
printf("LPTMR using 32Khz clock with PRESCALE=0x1, and compare value=32768 (4 seconds)\n");
printf("Press a key to start counter\n");
in_char();
LPTMR0_CSR|=LPTMR_CSR_TEN_MASK; //Turn on LPT with default settings
printf("Counting...\n\n");
//Wait for Timer Compare Flag to be set
while((LPTMR0_CSR&LPTMR_CSR_TCF_MASK)==0)
{
//This may not get proper counter data if the CNR is read at the same time it is incremented
//printf("Current value of counter register CNR is %d\n",LPTMR0_CNR);
}
printf("4 seconds should have passed\n");
printf("End of 32 Khz Clock Source Example\n");
printf("****************************\n\n");
}
/*
* Internal Reference Clock (PSC=0x0)
* The Internal Reference Clock can come from two clock sources.
* If MCG_C2[IRCS]=0, then uses slow internal clock (32kHz)
* If MCG_C2[IRCS]=1, then uses fast internal clock (2Mhz)
*
* This example uses fast internal clock. It is pre-scaled to wait for 4 seconds.
* Because of trim values, it may be slightly faster or slower than this.
*/
void lptmr_internal_ref_input()
{
unsigned int compare_value=15625; //4 seconds with prescale=8 and 2Mhz fast clock
printf("\n\n****************************\n");
printf("Internal Reference Clock Example\n");
//Reset LPTMR module
lptmr_clear_registers();
/* Ensure Internal Reference Clock is Enabled */
MCG_C1|=MCG_C1_IRCLKEN_MASK;
//Enable fast internal ref clock by setting MCG_C2[IRCS]=1
//If wanted to use 32Khz slow mode, set MCG_C2[IRCS]=0 instead
MCG_C2|=MCG_C2_IRCS_MASK;
/* Configure LPTMR */
LPTMR0_CMR=LPTMR_CMR_COMPARE(compare_value); //Set compare value
LPTMR0_PSR=LPTMR_PSR_PCS(0x0)|LPTMR_PSR_PRESCALE(0x8); //Use internal clock prescaled by 512
printf("LPTMR using fast internal ref clock with PRESCALE=0x8, and compare value=15625 (4 seconds)\n");
printf("Press a key to start counter\n");
in_char();
LPTMR0_CSR|=LPTMR_CSR_TEN_MASK; //Turn on LPT with default settings
printf("Counting...\n\n");
//Wait for Timer Compare Flag to be set
while((LPTMR0_CSR&LPTMR_CSR_TCF_MASK)==0)
{
//This may not get proper counter data if the CNR is read at the same time it is incremented
//printf("Current value of counter register CNR is %d\n",LPTMR0_CNR);
}
printf("4 seconds should have passed\n");
printf("End of Internal reference Clock Source Example\n");
printf("****************************\n\n");
}
/*
* Counts pulses found on LPTMR0_ALT1 and LPTMR0_ALT2.
* LPTMR0_ALT3 not supported on TWR-K60N512 or TWR-K40X256
*
* LPTMR0_ALT1 is pin PORTA19 (ALT6)
* On TWR-K40X256, PORT19 is connected to XTAL and thus should not be
* driven by an external source, as it will conflict with the crystal clock
* on the board.
* On TWR-K60N512, PORTA19 is conected to pin 18 on J15
*
* LPTMR0_ALT2 is pin PORTC5 (ALT4).
* On TWR-K40X256, PORTC5 is connected to pin 18 on J15
* On TWR-K60N512, PORTC5 is conected A70 on TWR-ELEV
*
*
*
*/
void lptmr_pulse_counter(char pin_select)
{
unsigned int compare_value=1000;
char input;
printf("\n\n****************************\n");
printf("LPTMR Pulse Counting Example on LPTMR_ALT%d\n\n",pin_select);
//Reset LPTMR module
lptmr_clear_registers();
//Set up GPIO
if(pin_select==LPTMR_ALT1)
{
SIM_SCGC5 |= SIM_SCGC5_PORTA_MASK; //Turn on PORTA clock
PORTA_PCR19=PORT_PCR_MUX(0x6); //Use ALT6 on PTA19
printf("Testing ALT1 pin on PORTA19\n");
printf("\tTWR-K40X256: ALT1 is connected to XTAL and should not be driven\n");
printf("\tTWR-K60N512: ALT1 is conected to pin 18 on J15\n");
}
else if(pin_select==LPTMR_ALT2)
{
SIM_SCGC5 |= SIM_SCGC5_PORTC_MASK; //Turn on PORTC clock
PORTC_PCR5=PORT_PCR_MUX(0x4); //Use ALT4 on PTC5
printf("Testing ALT2 pin on PORTC5\n");
printf("\tTWR-K40X256: ALT2 is connected to pin 18 on J15\n");
printf("\tTWR-K60N512: ALT2 is conected A70 on TWR-ELEV\n");
}
else
{
printf("Invalid pin selected\n");
printf("****************************\n");
return;
}
/* Test requires external hardware. Need to confirm if want to run test or not */
printf("\nThis test requires a function generator, or another way of producing a pulse signal on the pin specified above. ");
printf("Please connect that device to the specified pin (Except if using ALT1 on the TWR-K40X256)\n\n");
printf("If you would like to continue with this example, press \"y\". To skip press any other key\n");
input=in_char(); //wait for keyboard press
printf("\n");
if(input!='y' && input!='Y')
{
printf("Exiting LPTMR Pulse Counting Example on LPTMR_ALT%d\n",pin_select);
printf("****************************\n");
return;
}
LPTMR0_PSR=LPTMR_PSR_PCS(0x1)|LPTMR_PSR_PBYP_MASK; //Use LPO clock but bypass glitch filter
LPTMR0_CMR=LPTMR_CMR_COMPARE(compare_value); //Set compare value
LPTMR0_CSR=LPTMR_CSR_TPS(pin_select)|LPTMR_CSR_TMS_MASK; //Set LPT to use the pin selected, and put in pulse count mode, on rising edge (default)
printf("Press any key to start pulse counter\n");
in_char(); //wait for keyboard press
LPTMR0_CSR|=LPTMR_CSR_TEN_MASK; //Turn on LPT
//Wait for compare flag to be set
while((LPTMR0_CSR&LPTMR_CSR_TCF_MASK)==0)
{
//This may not get proper counter data if the CNR is read at the same time it is incremented
printf("Current value of pulse count register CNR is %d\n",LPTMR0_CNR);
}
printf("Detected %d pulses on LPTMR_ALT%d\n",compare_value,pin_select);
printf("End of Pulse Counting Example\n");
printf("****************************\n");
}
