//========================================================================= //----- (00007CD4) -------------------------------------------------------- __myevic__ void InitTimers() { TIMER_Open( TIMER0, TIMER_PERIODIC_MODE, 100000 ); TIMER_EnableInt( TIMER0 ); TIMER_Open( TIMER1, TIMER_PERIODIC_MODE, 5000 ); TIMER_EnableInt( TIMER1 ); TIMER_Open( TIMER2, TIMER_PERIODIC_MODE, 1000 ); TIMER_EnableInt( TIMER2 ); TIMER_Open( TIMER3, TIMER_PERIODIC_MODE, 10 ); TIMER_EnableInt( TIMER3 ); NVIC_EnableIRQ( TMR0_IRQn ); NVIC_EnableIRQ( TMR1_IRQn ); NVIC_EnableIRQ( TMR2_IRQn ); NVIC_EnableIRQ( TMR3_IRQn ); TMR3Counter = 0; TMR2Counter = 0; TMR1Counter = 0; TMR0Counter = 0; TIMER_Start( TIMER0 ); TIMER_Start( TIMER1 ); TIMER_Start( TIMER2 ); TIMER_Start( TIMER3 ); }
/*---------------------------------------------------------------------------------------------------------*/ void TMR3_IRQHandler(void) { // clear Timer0 interrupt flag TIMER_ClearIntFlag(TIMER3); if(IR_Tx_stage==TRANSFER_START) { if(IR_bit_state==1) { // Enable PWM0 CH2 output PWM_DisableOutput(PWM0, PWM_CH_3_MASK); //Initial Timer0 to periodic mode with 222Hz(4.5ms) TIMER_Open(TIMER3, TIMER_ONESHOT_MODE, START_TRAN_SECOND); TIMER_EnableInt(TIMER3); TIMER_Start(TIMER3); IR_bit_state=0; IR_Tx_stage=TRANSFER_CONT; } } else if(IR_Tx_stage==TRANSFER_CONT) { if(IR_TX_Byten<4) { IR_TranDATA(); } else { if(IRTx_StopFlag==0) { PWM_EnableOutput(PWM0, PWM_CH_3_MASK); //Initial Timer0 to periodic mode with 1786Hz(560us) TIMER_Open(TIMER3, TIMER_ONESHOT_MODE, TRAN_BIT_ZERO); TIMER_EnableInt(TIMER3); TIMER_Start(TIMER3); IRTx_StopFlag=1; } else if(IRTx_StopFlag==1) { PWM_DisableOutput(PWM0, PWM_CH_3_MASK); IR_TX_Bitn=0; IR_TX_Byten=0; IR_Tx_stage=TRANSFER_START; IRTx_StopFlag = 0; IR_TxExecuteFLAG=0; } } } }
int main(void) { int i = 0; /* Init System, IP clock and multi-function I/O In the end of SYS_Init() will issue SYS_LockReg() to lock protected register. If user want to write protected register, please issue SYS_UnlockReg() to unlock protected register if necessary */ SYS_Init(); /* Init UART to 115200-8n1 for print message */ UART_Open(UART0, 115200); /*Initial Timer0 to periodic mode with 1Hz */ TIMER_Open(TIMER0, TIMER_PERIODIC_MODE, 1); /* Enable timer wake up system */ TIMER_EnableWakeup(TIMER0); /* Enable Timer0 interrupt */ TIMER_EnableInt(TIMER0); NVIC_EnableIRQ(TMR0_IRQn); /* Start Timer0 counting */ TIMER_Start(TIMER0); /* Unlock protected registers */ SYS_UnlockReg(); while(1) { CLK_PowerDown(); printf("Wake %d\n", i++); } }
/*---------------------------------------------------------------------------------------------------------*/ int main(void) { //Initial System SYS_Init(); //Enable Timer0 clock and select Timer0 clock source CLK_EnableModuleClock(TMR0_MODULE); CLK_SetModuleClock(TMR0_MODULE, CLK_CLKSEL1_TMR0SEL_HXT, 0); //Initial Timer0 to periodic mode with 2Hz TIMER_Open(TIMER0, TIMER_PERIODIC_MODE, 2); //Enable Timer0 interrupt TIMER_EnableInt(TIMER0); NVIC_EnableIRQ(TMR0_IRQn); //Initial 7-Segment Open_Seven_Segment(); //Start Timer0 TIMER_Start(TIMER0); while(1) { Show_Seven_Segment(TimerCounter / 10, 1); CLK_SysTickDelay(200); Show_Seven_Segment(TimerCounter % 10, 2); CLK_SysTickDelay(200); } }
/******************************************************************************* * Description : PLC configuration * Syntax : * Parameters I: * Parameters O: * return : *******************************************************************************/ void PLC_setup(void) { /* PLC Tx Pin set */ // pinMode_ALL(P0, 0, OUTPUT); //SCC // pinMode_ALL(P0, 1, OUTPUT); //SCCOUT pinMode_ALL(P3, 6, OUTPUT); //SCCOUT /* PLC Tx Timer default setting */ TIMER_Open(TIMER1, TIMER_PERIODIC_MODE, 1); //中心频率 270KHz // TIMER_SET_PRESCALE_VALUE(TIMER1, 0); // TIMER_SET_CMP_VALUE(TIMER1, 88); /* PLC Tx Timer IE enable */ TIMER_EnableInt(TIMER1); /* Enable Timer1 NVIC */ NVIC_EnableIRQ(TMR1_IRQn); //中断优先级缺 /* Clear Timer1 interrupt counts to 0 */ TimerIntCnt[1] = 0u; /* Start Timer1 counting */ // TIMER_Start(TIMER1); }
/*---------------------------------------------------------------------------------------------------------*/ void IR_TranDATA(void) { if(IR_bit_state==0) { // Stop PWM0 CH3 output PWM_EnableOutput(PWM0, PWM_CH_3_MASK); //Initial Timer0 to periodic mode with 1786Hz(560us) TIMER_Open(TIMER3, TIMER_ONESHOT_MODE, TRAN_BIT_FIRST); TIMER_EnableInt(TIMER3); TIMER_Start(TIMER3); IR_bit_state=1; } else if (IR_bit_state==1) { if(TxIR_CODE[IR_TX_Byten] & (1 << (IR_DATA_BIT_NUMBER-IR_TX_Bitn-1))) { // Stop PWM0 CH3 output PWM_DisableOutput(PWM0, PWM_CH_3_MASK); //Initial Timer0 to periodic mode with 595Hz(1680us) TIMER_Open(TIMER3, TIMER_ONESHOT_MODE, TRAN_BIT_ONE); TIMER_EnableInt(TIMER3); TIMER_Start(TIMER3); } else { // Enable PWM0 CH3 output PWM_DisableOutput(PWM0, PWM_CH_3_MASK); //Initial Timer0 to periodic mode with 1786Hz(560us) TIMER_Open(TIMER3, TIMER_ONESHOT_MODE, TRAN_BIT_ZERO); TIMER_EnableInt(TIMER3); TIMER_Start(TIMER3); } if(IR_TX_Bitn<7) { IR_TX_Bitn++; } else { IR_TX_Bitn=0; IR_TX_Byten++; } IR_bit_state=0; } }
void Time::initialize() { CLK_EnableModuleClock(TMR0_MODULE); CLK_SetModuleClock(TMR0_MODULE,CLK_CLKSEL1_TMR0_S_HCLK,CLK_CLKDIV_UART(1)); TIMER_Open(TIMER0, TIMER_PERIODIC_MODE, 1000000/TIMER_INTERRUPT_PERIOD_MICROSECONDS); TIMER_EnableInt(TIMER0); NVIC_EnableIRQ(TMR0_IRQn); NVIC_SetPriority(TMR0_IRQn, TIMER_IRQ_PRIORITY); TIMER_Start(TIMER0); /* Start counting */ }
void Tim_Config(void) //定时器配置 用于测量红外高电平的时间 { /* Open Timer0 frequency to 50k Hz in periodic mode, and enable interrupt */ TIMER_Open(TIMER0, TIMER_PERIODIC_MODE, 50000); TIMER_EnableInt(TIMER0); /* Open Timer1 frequency to 10k Hz in periodic mode, and enable interrupt */ TIMER_Open(TIMER1, TIMER_PERIODIC_MODE, 10000); TIMER_EnableInt(TIMER1); /* Open Timer2 frequency to 10 Hz in periodic mode, and enable interrupt */ //用于按键长按休眠 TIMER_Open(TIMER2, TIMER_PERIODIC_MODE, 10); TIMER_EnableInt(TIMER2); /* Enable Timer0、1 NVIC */ NVIC_EnableIRQ(TMR0_IRQn); NVIC_EnableIRQ(TMR1_IRQn); NVIC_EnableIRQ(TMR2_IRQn); // /* Start Timer0、1counting */ // TIMER_Start(TIMER0); // TIMER_Start(TIMER1); TIMER_Start(TIMER2); }
void initialize() { IO::pinMode(MUX_ADR0_PIN, OUTPUT); IO::pinMode(MUX_ADR1_PIN, OUTPUT); IO::pinMode(MUX_ADR2_PIN, OUTPUT); IO::pinMode(V_IN_PIN, ANALOG_INPUT); IO::pinMode(OUTPUT_VOLTAGE_MINUS_PIN, ANALOG_INPUT); IO::pinMode(SMPS_CURRENT_PIN, ANALOG_INPUT); IO::pinMode(OUTPUT_VOLTAGE_PLUS_PIN, ANALOG_INPUT); IO::pinMode(DISCHARGE_CURRENT_PIN, ANALOG_INPUT); IO::pinMode(MUX0_Z_D_PIN, ANALOG_INPUT_DISCHARGE); IO::digitalWrite(MUX0_Z_D_PIN, 0); //initialize internal temperature sensor SYS->TEMPCR |= 1; //initialize TIMER 1 (mux ADC capacitor discharge) CLK_EnableModuleClock(TMR1_MODULE); CLK_SetModuleClock(TMR1_MODULE,CLK_CLKSEL1_TMR1_S_HCLK,CLK_CLKDIV_UART(1)); //TODO: 50kHz ?? TIMER_Open(TIMER1, TIMER_ONESHOT_MODE, 1000000 / ADC_CAPACITOR_DISCHARGE_DELAY_US); TIMER_EnableInt(TIMER1); NVIC_EnableIRQ(TMR1_IRQn); NVIC_SetPriority(TMR1_IRQn, ADC_C_DISCHARGE_IRQ_PRIORITY); //initialize ADC //init clock CLK_EnableModuleClock(ADC_MODULE); CLK_SetModuleClock(ADC_MODULE, CLK_CLKSEL1_ADC_S_HCLK, CLK_CLKDIV_ADC(CLK_GetHCLKFreq()/ADC_CLOCK_FREQUENCY)); //__HXT/ADC_CLOCK_FREQUENCY)); /* Set the ADC operation mode as burst, input mode as single-end and enable the analog input channel 2 */ ADC_Open(ADC, ADC_ADCR_DIFFEN_SINGLE_END, ADC_ADCR_ADMD_BURST, 0x1 << 2); ADC_SET_DMOF(ADC, ADC_ADCR_DMOF_UNSIGNED_OUTPUT); /* Power on ADC module */ ADC_POWER_ON(ADC); /* clear the A/D interrupt flag for safe */ ADC_CLR_INT_FLAG(ADC, ADC_ADF_INT); /* Enable the ADC interrupt */ ADC_EnableInt(ADC, ADC_ADF_INT); NVIC_EnableIRQ(ADC_IRQn); NVIC_SetPriority(ADC_IRQn, ADC_IRQ_PRIORITY); current_input_ = 0; startConversion(); }
void TIMER_Init() { /* Enable peripheral clock */ CLK_EnableModuleClock(TMR2_MODULE); CLK_SetModuleClock(TMR2_MODULE, CLK_CLKSEL1_TMR2SEL_HIRC, 0); TIMER_Open(TIMER2, TIMER_PERIODIC_MODE, 100000); TIMER_EnableInt(TIMER2); NVIC_SetPriority (TMR2_IRQn, (1<<__NVIC_PRIO_BITS) - 1); /* Enable Timer2 NVIC */ NVIC_EnableIRQ(TMR2_IRQn); /* Start Time2 counting */ TIMER_Start(TIMER2); }
void TMR0_Init(uint32_t u32Freq) { /* Configure timer to operate in periodic mode and frequency = 1000Hz*/ TIMER_Open(TIMER0, TIMER_PERIODIC_MODE, u32Freq); /* Enable the Timer time-out interrupt */ TIMER_EnableInt(TIMER0); /* Start Timer counting */ TIMER_Start(TIMER0); /* Enable TMR0 Interrupt */ NVIC_EnableIRQ(TMR0_IRQn); }
/** * @brief Main routine. * @param None. * @return None. */ int32_t main(void) { SYS_UnlockReg(); SYS->P5_MFP = (SYS->P5_MFP & 0x00FFFCFC) | 0x03; /* P5.1 -> XTAL2, P5.0 -> XTAL1 */ CLK->PWRCON = CLK_PWRCON_XTL12M | 4 | 8 ; SYS_Init(); /* SPI test */ LCD_Init(); LCD_EnableBackLight(); LCD_ClearScreen(); LCD_Print(0, "Welcome! Nuvoton"); LCD_Print(1, "This is LB board"); LCD_Print(2, "Mini51"); LCD_Print(3, "TEST"); // backlight control pin P5.4 GPIO_SetMode(P5,1<<4,GPIO_PMD_OUTPUT); /* INT button triggers P3.2 */ GPIO_SetMode(P3,(1<<2),GPIO_PMD_OPEN_DRAIN); GPIO_EnableInt(P3, 2, GPIO_INT_FALLING); NVIC_EnableIRQ(EINT0_IRQn); /* Enable interrupt de-bounce function and select de-bounce sampling cycle time */ GPIO_SET_DEBOUNCE_TIME(GPIO_DBNCECON_DBCLKSRC_HCLK,GPIO_DBNCECON_DBCLKSEL_16); GPIO_ENABLE_DEBOUNCE(P3,1<<2); /* Reset and stop TIMER0, TIMER1 counting first */ TIMER1->TCSR = TIMER_TCSR_CRST_Msk; /* Enable TIMER0, TIMER1, NVIC */ NVIC_EnableIRQ(TMR1_IRQn); /* To Configure TCMPR values based on Timer clock source and pre-scale value */ TIMER_SET_PRESCALE_VALUE(TIMER1,0); /* Start TIMER1 counting and setting*/ TIMER_Open(TIMER1,TIMER_PERIODIC_MODE,SystemCoreClock/1000); TIMER_EnableInt(TIMER1); while(1) ; // loop forever }
int Timer_InterTimerTriggerMode(void) { int volatile i; /* Init System, IP clock and multi-function I/O In the end of SYS_Init() will issue SYS_LockReg() to lock protected register. If user want to write protected register, please issue SYS_UnlockReg() to unlock protected register if necessary */ SysInit(); /* Init UART to 115200-8n1 for print message */ UART_Open(UART0, 115200); /* This sample code demonstrate inter timer trigger mode using Timer0 and Timer1 * In this mode, Timer0 is working as counter, and triggers Timer1. Using Timer1 * to calculate the amount of time used by Timer0 to count specified amount of events. * By dividing the time period recorded in Timer1 by the event counts, we get * the event frequency. */ printf("Inter timer trigger mode demo code\n"); printf("Please connect input source with Timer 0 counter pin PB.8, press any key to continue\n"); UART_GetChar(); // Give a dummy target frequency here. Will over write prescale and compare value with macro TIMER_Open(TIMER0, TIMER_ONESHOT_MODE, 100); // Update prescale and compare value. Calculate average frequency every 1000 events TIMER_SET_PRESCALE_VALUE(TIMER0, 0); TIMER_SET_CMP_VALUE(TIMER0, 1000); // Update Timer 1 prescale value. So Timer 1 clock is 1MHz TIMER_SET_PRESCALE_VALUE(TIMER1, 11); // We need capture interrupt NVIC_EnableIRQ(TMR1_IRQn); while(1) { complete = 0; // Count event by timer 0, disable drop count (set to 0), disable timeout (set to 0). Enable interrupt after complete TIMER_EnableFreqCounter(TIMER0, 0, 0, TRUE); while(complete == 0); } }
int Timer_FreeCountingMode(void) { int volatile i; /* Init System, IP clock and multi-function I/O In the end of SYS_Init() will issue SYS_LockReg() to lock protected register. If user want to write protected register, please issue SYS_UnlockReg() to unlock protected register if necessary */ SysInit(); /* Init UART to 115200-8n1 for print message */ UART_Open(UART0, 115200); printf("\nThis sample code demonstrate timer free counting mode.\n"); printf("Please connect input source with Timer 0 capture pin PD.11, press any key to continue\n"); UART_GeyChar(); // Give a dummy target frequency here. Will over write capture resolution with macro TIMER_Open(TIMER0, TIMER_PERIODIC_MODE, 1000000); // Update prescale to set proper resolution. // Timer 0 clock source is 12MHz, to set resolution to 1us, we need to // set clock divider to 12. e.g. set prescale to 12 - 1 = 11 TIMER_SET_PRESCALE_VALUE(TIMER0, 11); // Set compare value as large as possible, so don't need to worry about counter overrun too frequently. TIMER_SET_CMP_VALUE(TIMER0, 0xFFFFFF); // Configure Timer 0 free counting mode, capture TDR value on rising edge TIMER_EnableCapture(TIMER0, TIMER_CAPTURE_FREE_COUNTING_MODE, TIMER_CAPTURE_RISING_EDGE); // Start Timer 0 TIMER_Start(TIMER0); // Enable timer interrupt TIMER_EnableCaptureInt(TIMER0); NVIC_EnableIRQ(TMR0_IRQn); while(1); }
int32_t main (void) { /* Init System, IP clock and multi-function I/O In the end of SYS_Init() will issue SYS_LockReg() to lock protected register. If user want to write protected register, please issue SYS_UnlockReg() to unlock protected register if necessary */ SYS_Init(); /* Init UART0 for printf */ UART_Open(UART0, 115200); printf("\nThis sample code demonstrate Timer 0 trigger DAC channel 0 function.\n"); // Enable DAC channel 0, trigger by Timer 0. DAC_Open(DAC, 0, DAC_TIMER0_TRIGGER); // Enable DAC0 interrupt. Enable interrupt for one channel is sufficient in group mode. DAC_ENABLE_INT(DAC, 0); NVIC_EnableIRQ(DAC_IRQn); // Wait 'til both channels are ready while(DAC_IS_BUSY(DAC, 0) == 1); // Set timer frequency TIMER_Open(TIMER0, TIMER_PERIODIC_MODE, 100); // Enable Timer timeout event trigger DAC TIMER_SetTriggerTarget(TIMER0, TIMER_CTL_DAC_TEEN_Msk); // Write first data out. timer will 0 will trigger DAC update DAC_WRITE_DATA(DAC, 0, a16Sine[index0]); index0 = (index0 + 1) % SINE_ARRAY_SIZE; // Start Timer 0 TIMER_Start(TIMER0); while(1); }
void Timer1Init(uint16_t freq) { /* Enable peripheral clock */ CLK_EnableModuleClock(TMR1_MODULE); /* Peripheral clock source */ CLK_SetModuleClock(TMR1_MODULE, CLK_CLKSEL1_TMR1SEL_LIRC, 0); /* Enable Timer0 NVIC */ NVIC_EnableIRQ(TMR1_IRQn); /* Open Timer0 time-out frequency to (freq) Hz in periodic mode */ TIMER_Open(TIMER1, TIMER_PERIODIC_MODE, freq); /* Enable Timer0 time-out interrupt and wake-up function */ TIMER_EnableInt(TIMER1); TIMER_EnableWakeup(TIMER1); /* Start Timer0 counting */ TIMER_Start(TIMER1); }
/* ----------------------- Start implementation -----------------------------*/ BOOL xMBPortTimersInit(USHORT usTim1Timerout50us) { uint16_t PrescalerValue = 0; CLK_EnableModuleClock(TMR0_MODULE); CLK_SetModuleClock(TMR0_MODULE, CLK_CLKSEL1_TMR0SEL_PCLK, 0); // Set timer frequency to 20KHZ (50us) TIMER_Open(TIMER0, TIMER_PERIODIC_MODE, usTim1Timerout50us); // Enable timer interrupt TIMER_EnableInt(TIMER0); NVIC_SetPriority(TMR0_IRQn, 10 ); //定时器的中断优先级应该比串口的低 NVIC_EnableIRQ(TMR0_IRQn); TIMER_SET_PRESCALE_VALUE(TIMER0, 0); // Stop Timer 0 TIMER_Stop(TIMER0); return TRUE; }
int main(void) { /* Init System, IP clock and multi-function I/O In the end of SYS_Init() will issue SYS_LockReg() to lock protected register. If user want to write protected register, please issue SYS_UnlockReg() to unlock protected register if necessary */ SYS_Init(); /* Init UART to 115200-8n1 for print message */ UART_Open(UART0, 115200); printf("\nThis sample code use timer to wake up system every 1 second \n"); /*Initial Timer0 to periodic mode with 1Hz */ TIMER_Open(TIMER0, TIMER_PERIODIC_MODE, 1); /* Enable timer wake up system */ TIMER_EnableWakeup(TIMER0); /* Enable Timer0 interrupt */ TIMER_EnableInt(TIMER0); NVIC_EnableIRQ(TMR0_IRQn); /* Start Timer0 counting */ TIMER_Start(TIMER0); /* Unlock protected registers to let CPU enter power down mode */ SYS_UnlockReg(); while(1) { printf("Sleep 1 second\n"); // Wait 'til UART FIFO empty to get a cleaner console out while(!UART_IS_TX_EMPTY(UART0)); CLK_PowerDown(); } }
/*---------------------------------------------------------------------------------------------------------*/ void TMR3_IRQHandler(void) { uint8_t LearnedDataByten; //LearnedDataByten transfered from IR_Tx_LearnedDataByten // clear Timer0 interrupt flag TIMER_ClearIntFlag(TIMER3); if(IR_Tx_stage==TRANSFER_START && IR_bit_state==1) { // Enable PWM0 CH2 output PWM_DisableOutput(PWM0, PWM_CH_3_MASK); //Initial Timer0 to periodic mode with 222Hz(4.5ms) TIMER_Open(TIMER3, TIMER_ONESHOT_MODE, START_TRAN_SECOND); TIMER_EnableInt(TIMER3); TIMER_Start(TIMER3); IR_bit_state=0; IR_Tx_stage=TRANSFER_CONT; } else if(IR_Tx_stage==TRANSFER_CONT) { if(IR_LearnedFlag==0) { if(IR_TX_Byten<4) { IR_TranDATA(); } else { if(IRTx_StopFlag==0) { PWM_EnableOutput(PWM0, PWM_CH_3_MASK); //Initial Timer0 to periodic mode with 1786Hz(560us) TIMER_Open(TIMER3, TIMER_ONESHOT_MODE, TRAN_BIT_ZERO); TIMER_EnableInt(TIMER3); TIMER_Start(TIMER3); IRTx_StopFlag=1; } else if(IRTx_StopFlag==1) { PWM_DisableOutput(PWM0, PWM_CH_3_MASK); IR_TX_Bitn = 0; IR_TX_Byten = 0; IR_Tx_stage=TRANSFER_START; IRTx_StopFlag = 0; IR_TxExecuteFLAG = 0; } } } else if(IR_LearnedFlag==1) { if(IRTx_StopFlag==1) { PWM_DisableOutput(PWM0, PWM_CH_3_MASK); IR_Tx_stage=TRANSFER_START; IR_TX_Bitn=0; IR_byte_state = 0; IRTx_StopFlag = 0; IR_TxExecuteFLAG = 0; } else if(IR_TX_Bitn%2==0) { LearnedDataByten = IR_Tx_LearnedDataByten*2+IR_byte_state; PWM_EnableOutput(PWM0, PWM_CH_3_MASK); if(IR_LearnedData[LearnedDataByten] & (1 << (IR_LearnedDataLeng[IR_Tx_LearnedDataByten]/2 - IR_TX_Bitn - 1)))//IR_TX_Bitn*2 //Initial Timer0 to periodic mode with 1786Hz(560us) TIMER_Open(TIMER3, TIMER_ONESHOT_MODE, IR_FallingMaxFreq); else TIMER_Open(TIMER3, TIMER_ONESHOT_MODE, IR_FallingMinFreq); TIMER_EnableInt(TIMER3); TIMER_Start(TIMER3); IR_TX_Bitn++; } else if(IR_TX_Bitn%2==1) { LearnedDataByten = IR_Tx_LearnedDataByten*2+IR_byte_state; PWM_DisableOutput(PWM0, PWM_CH_3_MASK); if(IR_LearnedData[LearnedDataByten] & (1 << (IR_LearnedDataLeng[IR_Tx_LearnedDataByten]/2-IR_TX_Bitn-1)))//IR_TX_Bitn*2 //Initial Timer0 to periodic mode with 1786Hz(560us) TIMER_Open(TIMER3, TIMER_ONESHOT_MODE, IR_RisingMaxFreq); else TIMER_Open(TIMER3, TIMER_ONESHOT_MODE, IR_RisingMinFreq); TIMER_EnableInt(TIMER3); TIMER_Start(TIMER3); IR_TX_Bitn++; } if(IR_TX_Bitn==32 && IR_byte_state == 0) { IR_TX_Bitn=0; IR_byte_state=1; } else if((IR_TX_Bitn+31==IR_LearnedDataLeng[IR_Tx_LearnedDataByten]) && (IR_byte_state == 1)) { IRTx_StopFlag = 1; } } } }
/*---------------------------------------------------------------------------------------------------------*/ int main(void) { volatile uint32_t u32InitCount; /* Unlock protected registers */ SYS_UnlockReg(); /* Init System, peripheral clock and multi-function I/O */ SYS_Init(); /* Lock protected registers */ SYS_LockReg(); /* Init UART0 for printf */ UART0_Init(); printf("\n\nCPU @ %d Hz\n", SystemCoreClock); printf("+-------------------------------------------------+\n"); printf("| Timer0 Power-down and Wake-up Sample Code |\n"); printf("+-------------------------------------------------+\n\n"); printf("# Timer Settings:\n"); printf(" Timer0: Clock source is LIRC(10 kHz); Toggle-output mode and frequency is 1 Hz; Enable interrupt and wake-up.\n"); printf("# System will enter to Power-down mode while Timer0 interrupt count is reaching 3;\n"); printf(" And be waken-up while Timer0 interrupt count is reaching 4.\n\n"); /* To program PWRCON register, it needs to disable register protection first. */ SYS_UnlockReg(); /* Open Timer0 frequency to 1 Hz in toggle-output mode */ TIMER_Open(TIMER0, TIMER_TOGGLE_MODE, 1); /* Enable Timer0 interrupt and wake-up function */ TIMER_EnableInt(TIMER0); TIMER_EnableWakeup(TIMER0); /* Enable Timer0 NVIC */ NVIC_EnableIRQ(TMR0_IRQn); /* Start Timer0 counting */ TIMER_Start(TIMER0); u32InitCount = g_u8IsTMR0WakeupFlag = g_au32TMRINTCount[0] = 0; while(g_au32TMRINTCount[0] < 10) { if(g_au32TMRINTCount[0] != u32InitCount) { printf("Timer0 interrupt count - %d\n", g_au32TMRINTCount[0]); if(g_au32TMRINTCount[0] == 3) { PowerDownFunction(); /* Check if Timer0 time-out interrupt and wake-up flag occurred */ while(1) { if(((CLK->PWRCON & CLK_PWRCON_PD_WU_STS_Msk) == CLK_PWRCON_PD_WU_STS_Msk) && (g_u8IsTMR0WakeupFlag == 1)) break; } printf("System has been waken-up done. (Timer0 interrupt count is %d)\n\n", g_au32TMRINTCount[0]); } u32InitCount = g_au32TMRINTCount[0]; } } /* Stop Timer0 counting */ TIMER_Stop(TIMER0); printf("*** PASS ***\n"); while(1); }
/*---------------------------------------------------------------------------------------------------------*/ int main(void) { volatile uint32_t u32InitCount; uint32_t au32CAPValus[10]; /* Unlock protected registers */ SYS_UnlockReg(); /* Init System, peripheral clock and multi-function I/O */ SYS_Init(); /* Lock protected registers */ SYS_LockReg(); /* Init UART0 for printf */ UART0_Init(); printf("\n\nCPU @ %d Hz\n", SystemCoreClock); printf("+---------------------------------------------------+\n"); printf("| Timer External Capture Function Sample Code |\n"); printf("+---------------------------------------------------+\n\n"); printf("# Timer Settings:\n"); printf(" Timer0: Clock source is 12 MHz; Toggle-output mode and frequency is 500 Hz.\n"); printf(" Timer3: Clock source is 12 MHz; Toggle-output mode and frequency is 1 Hz.\n"); printf(" Timer2: Clock source is HCLK(72 MHz); Continuous counting mode; TCMP is 0xFFFFFF;\n"); printf(" Counter pin enable; Capture pin and capture interrupt enable;\n"); printf("# Generate 500 Hz frequency from TM0 and connect TM0 pin to Timer2 counter pin.\n"); printf("# Generate 1 Hz frequency from TM3 and connect TM3 pin to TM2_EXT capture pin.\n"); printf("# Get 500 event counts from Timer2 counter pin when each TM2_EXT pin interrupt occurred.\n\n"); /* Initial Timer0 and Timer3 default setting */ TIMER_Open(TIMER0, TIMER_TOGGLE_MODE, 1000); TIMER_Open(TIMER3, TIMER_TOGGLE_MODE, 2); /* Initial Timer2 default setting */ TIMER_Open(TIMER2, TIMER_CONTINUOUS_MODE, 1); /* Configure Timer2 setting for external counter input and capture function */ TIMER_SET_PRESCALE_VALUE(TIMER2, 0); TIMER_SET_CMP_VALUE(TIMER2, 0xFFFFFF); TIMER_EnableEventCounter(TIMER2, TIMER_COUNTER_FALLING_EDGE); TIMER_EnableCapture(TIMER2, TIMER_CAPTURE_FREE_COUNTING_MODE, TIMER_CAPTURE_FALLING_EDGE); TIMER_EnableCaptureInt(TIMER2); /* Enable Timer2 NVIC */ NVIC_EnableIRQ(TMR2_IRQn); /* Clear Timer2 interrupt counts to 0 */ u32InitCount = g_au32TMRINTCount[2] = 0; /* Start Timer0, Timer2 and Timer3 counting */ TIMER_Start(TIMER0); TIMER_Start(TIMER2); TIMER_Start(TIMER3); /* Check TM2_EXT interrupt counts */ while(1) { if(g_au32TMRINTCount[2] != u32InitCount) { au32CAPValus[u32InitCount] = TIMER_GetCaptureData(TIMER2); printf("[%2d] - %4d\n", g_au32TMRINTCount[2], au32CAPValus[u32InitCount]); if(u32InitCount > 1) { if((au32CAPValus[u32InitCount] - au32CAPValus[u32InitCount - 1]) != 500) { printf("*** FAIL ***\n"); while(1); } } u32InitCount = g_au32TMRINTCount[2]; } if(u32InitCount == 10) break; } /* Stop Timer0, Timer2 and Timer3 counting */ TIMER_Close(TIMER0); TIMER_Close(TIMER2); TIMER_Close(TIMER3); printf("*** PASS ***\n"); while(1); }
int main() { CLEAR_WRITE(); SET_STOPMOTOR(); CLEAR_SCANMEDIA(); CLEAR_MEDIASET(); CLEAR_READY(); //setup led and button gpio GPIO_SetMode(LED_G_PORT, LED_G_PIN, GPIO_PMD_OUTPUT); GPIO_SetMode(LED_R_PORT, LED_R_PIN, GPIO_PMD_OUTPUT); GPIO_SetMode(SWITCH_PORT, SWITCH_PIN, GPIO_PMD_INPUT); GPIO_SetMode(IRDATA_PORT, IRDATA_PIN, GPIO_PMD_INPUT); LED_GREEN(0); LED_RED(1); detect_board_version(); /* Unlock protected registers */ SYS_UnlockReg(); SYS_Init(); /* Lock protected registers */ SYS_LockReg(); UART0_Init(); SPI_Init(); TIMER_Open(TIMER0, TIMER_CONTINUOUS_MODE, 6000000); TIMER_Open(TIMER1, TIMER_PERIODIC_MODE, TRANSFER_RATE * 2); TIMER_Open(TIMER3, TIMER_PERIODIC_MODE, TRANSFER_RATE * 2); TIMER_EnableInt(TIMER1); TIMER_EnableInt(TIMER3); /* Open USB controller */ USBD_Open(&gsInfo, HID_ClassRequest, NULL); /* Init Endpoint configuration for HID */ HID_Init(); /* Start USB device */ USBD_Start(); /* Enable USB device interrupt */ NVIC_EnableIRQ(USBD_IRQn); LED_GREEN(1); LED_RED(0); printf("\n\nnuc123-fdsemu v%d.%02d build %d started. Compiled on "__DATE__" at "__TIME__"\n",version / 100,version % 100,BUILDNUM); printf("--CPU @ %0.3f MHz\n", (double)SystemCoreClock / 1000000.0f); printf("--SPI0 @ %0.3f MHz\n", (double)SPI_GetBusClock(SPI0) / 1000000.0f); printf("--SPI1 @ %0.3f MHz\n", (double)SPI_GetBusClock(SPI1) / 1000000.0f); printf("--Detected board version: %d (config = %d %d %d)\n", boardver,PA12,PA13,PA14); NVIC_SetPriority(USBD_IRQn,2); NVIC_SetPriority(TMR1_IRQn,1); NVIC_SetPriority(TMR2_IRQn,0); NVIC_SetPriority(TMR3_IRQn,0); NVIC_SetPriority(GPAB_IRQn,0); NVIC_SetPriority(EINT0_IRQn,0); flash_init(); sram_init(); fds_init(); print_block_info(0); while(1) { if(havepacket) { havepacket = 0; // process_send_feature(epdata,64); } console_tick(); fds_tick(); } }
/*---------------------------------------------------------------------------------------------------------*/ int main(void) { volatile uint32_t u32InitCount; /* Unlock protected registers */ SYS_UnlockReg(); /* Init System, peripheral clock and multi-function I/O */ SYS_Init(); /* Lock protected registers */ SYS_LockReg(); /* Init UART0 for printf */ UART0_Init(); printf("\n\nCPU @ %d Hz\n", SystemCoreClock); printf("+-------------------------------------------------+\n"); printf("| Timer1 External Counter Input Sample Code |\n"); printf("+-------------------------------------------------+\n\n"); printf("# Timer Settings:\n"); printf(" Timer1: Clock source is HCLK(50 MHz); Continuous counting mode; Interrupt enable;\n"); printf(" External counter input enable; TCMP is 56789.\n"); printf("# Connect P2.0 to T1 pin and pull P2.0 High/Low as T1 counter input source.\n\n"); /* Configure P2.0 as GPIO output pin and pull pin status to Low first */ GPIO_SetMode(P2, 0, GPIO_PMD_OUTPUT); P20 = 0; /* Initial Timer1 default setting */ TIMER_Open(TIMER1, TIMER_CONTINUOUS_MODE, 1); /* Configure Timer1 setting for external counter input function */ TIMER_SELECT_TOUT_PIN(TIMER1, TIMER_TOUT_PIN_FROM_TX_PIN); TIMER_SET_PRESCALE_VALUE(TIMER1, 0); TIMER_SET_CMP_VALUE(TIMER1, 56789); TIMER_EnableEventCounter(TIMER1, TIMER_COUNTER_FALLING_EDGE); TIMER_EnableInt(TIMER1); /* Enable Timer1 NVIC */ NVIC_EnableIRQ(TMR1_IRQn); /* Clear Timer1 interrupt counts to 0 */ g_au32TMRINTCount[1] = 0; /* Start Timer1 counting */ TIMER_Start(TIMER1); /* To check if TDR of Timer1 must be 0 as default value */ if(TIMER_GetCounter(TIMER1) != 0) { printf("Default counter value is not 0. (%d)\n", TIMER_GetCounter(TIMER1)); /* Stop Timer1 counting */ TIMER_Close(TIMER1); while(1); } /* To generate one counter event to T1 pin */ GeneratePORT2Counter(0, 1); /* To check if TDR of Timer1 must be 1 */ while(TIMER_GetCounter(TIMER1) == 0); if(TIMER_GetCounter(TIMER1) != 1) { printf("Get unexpected counter value. (%d)\n", TIMER_GetCounter(TIMER1)); /* Stop Timer1 counting */ TIMER_Close(TIMER1); while(1); } /* To generate remains counts to T1 pin */ GeneratePORT2Counter(0, (56789 - 1)); while(1) { if((g_au32TMRINTCount[1] == 1) && (TIMER_GetCounter(TIMER1) == 56789)) { printf("Timer1 external counter input function ... PASS.\n"); break; } } /* Stop Timer1 counting */ TIMER_Close(TIMER1); while(1); }
void HardwareTimer::open(uint32_t mode, uint32_t freq) { TIMER_Open(dev, mode, freq); }
//========================================================================= // Additional initialisations //------------------------------------------------------------------------- __myevic__ void CustomStartup() { //------------------------------------------------------------------------- // EADC test if ( 0 ) { uint32_t s1, s2, s3; SetADCState( 0, 1 ); SetADCState( 4, 1 ); do { ClearScreenBuffer(); CLK_SysTickDelay( 10 ); s3 = ADC_Read( 4 ); CLK_SysTickDelay( 10 ); s1 = ADC_Read( 18 ); CLK_SysTickDelay( 10 ); s2 = ADC_Read( 0 ); DrawValue( 8, 0, s1, 0, 0x29, 4 ); DrawValue( 8, 20, s2, 0, 0x29, 4 ); DrawValue( 8, 40, s3, 0, 0x29, 4 ); DisplayRefresh(); WaitOnTMR2( 1000 ); } while ( PD3 ); } //------------------------------------------------------------------------- // Timer test 1 if ( 0 ) { TIMER_Stop( TIMER3 ); TIMER_Close( TIMER3 ); MemClear( gPlayfield.uc, 256 ); CLK_SetModuleClock( TMR3_MODULE, CLK_CLKSEL1_TMR3SEL_LIRC, 0 ); gPlayfield.ul[1] = TIMER_Open( TIMER3, TIMER_PERIODIC_MODE, 10 ); TIMER_EnableInt( TIMER3 ); TIMER_Start( TIMER3 ); } //------------------------------------------------------------------------- // Timer test 2 if ( 0 ) { TIMER_Close( TIMER2 ); TIMER_Close( TIMER3 ); MemClear( gPlayfield.uc, 256 ); CLK_SetModuleClock( TMR2_MODULE, CLK_CLKSEL1_TMR2SEL_HXT, 0 ); CLK_SetModuleClock( TMR3_MODULE, CLK_CLKSEL1_TMR3SEL_LIRC, 0 ); CLK_EnableModuleClock( TMR2_MODULE ); CLK_EnableModuleClock( TMR3_MODULE ); __set_PRIMASK(1); TIMER3->CTL |= TIMER_CTL_RSTCNT_Msk; TIMER2->CTL |= TIMER_CTL_RSTCNT_Msk; TIMER3->CMP = 1000; TIMER3->CTL = TIMER_CTL_CNTEN_Msk | TIMER_ONESHOT_MODE; TIMER2->CTL = TIMER_CTL_CNTEN_Msk | TIMER_CONTINUOUS_MODE; while(!(TIMER3->INTSTS & TIMER_INTSTS_TIF_Msk)); TIMER2->CTL = 0; gPlayfield.ul[0] = TIMER2->CNT; __set_PRIMASK(0); TIMER_Close( TIMER2 ); TIMER_Close( TIMER3 ); CLK_SetModuleClock( TMR2_MODULE, CLK_CLKSEL1_TMR2SEL_HIRC, 0 ); CLK_EnableModuleClock( TMR2_MODULE ); TIMER_Open( TIMER2, TIMER_PERIODIC_MODE, 1000 ); TIMER_EnableInt( TIMER2 ); TIMER_Start( TIMER2 ); CLK_SetModuleClock( TMR3_MODULE, CLK_CLKSEL1_TMR3SEL_HXT, 0 ); CLK_EnableModuleClock( TMR3_MODULE ); TIMER_Open( TIMER3, TIMER_PERIODIC_MODE, 10 ); TIMER_EnableInt( TIMER3 ); TIMER_Start( TIMER3 ); } return; }