void GoToSleep() { gFlags.light_sleep = !( gFlags.has_x32 || dfStatus.lsloff || gFlags.noclock ); ScreenOff(); LEDOff(); gFlags.firing = 0; BatReadTimer = 50; RTCSleep(); DevicesOnOff( 1 ); CLK_SysTickDelay( 250 ); CLK_SysTickDelay( 250 ); CLK_SysTickDelay( 250 ); if ( dfStatus.off || PE0 || KeyPressTime == 1100 ) { SYS_UnlockReg(); WDT_Close(); FlushAndSleep(); PreheatDelay = 0; } WDT_Open( WDT_TIMEOUT_2POW14, WDT_RESET_DELAY_18CLK, TRUE, FALSE ); SYS_LockReg(); gFlags.refresh_battery = 1; DevicesOnOff( 0 ); RTCWakeUp(); InitDisplay(); }
/*---------------------------------------------------------------------------------------------------------*/ 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); } }
__myevic__ void Plantouille( int xpsr, int* stack ) { int i, k; k = 0; SYS_UnlockReg(); WDT_Close(); SYS_LockReg(); InitDisplay(); while ( 1 ) { ClearScreenBuffer(); DrawImage( 0, 0, 'X'+0x27 ); DrawHexLong( 16, 0, xpsr, 0 ); DrawHexDigit( 0, 16, k ); for ( i = 0; i < 14 ; ++i ) { DrawHexLong( 16, 16+i*8, stack[i+k*14], 0 ); } DisplayRefresh(); while ( !PE0 || !PD2 || !PD3 ) CLK_SysTickDelay( 10000 ); while ( PE0 && PD2 && PD3 ) CLK_SysTickDelay( 10000 ); if ( !PE0 ) { SYS_UnlockReg(); SYS_ResetChip(); while ( 1 ) ; } if ( !PD2 ) ++k; if ( !PD3 ) --k; if ( k < 0 ) k = 0; else if ( k > 15 ) k = 15; } }
void textticker(char *string, uint32_t delayus) { char showstring[7], tmpstring[7]; int showidx, textidx, storeshowidx, storetextidx; int textlen; uint32_t i; strcpy(&showstring[0], " "); textlen = strlen(string); showidx = 6; for(textidx=0; textidx<textlen; textidx++) { // clear showstring for(storetextidx=0; storetextidx<=6; storetextidx++) showstring[storetextidx] = ' '; storetextidx = textidx; if((6-showidx) > 0) { storetextidx -= (6-showidx); } for(storeshowidx=showidx; storeshowidx<=6; storeshowidx++) { showstring[storeshowidx] = string[storetextidx++]; } if(showidx!=0) showidx--; //printf("%s \r\n", showstring); LCDLIB_Printf(0, &showstring[0]); CLK_SysTickDelay(delayus); } for(showidx=0; showidx<=6; showidx++) { strcpy(tmpstring, showstring); for(storeshowidx=0; storeshowidx<=6; storeshowidx++) { for(i = 0; i < 10000; i++); if((storeshowidx+1) <= 6) showstring[storeshowidx] = tmpstring[storeshowidx+1]; else showstring[storeshowidx] = ' '; } LCDLIB_Printf(0, &showstring[0]); CLK_SysTickDelay(delayus); } }
/*---------------------------------------------------------------------------------------------------------*/ int32_t main(void) { uint32_t u32TrimInit; uint8_t Str[9]; /* Unlock protected registers */ SYS_UnlockReg(); SYS_Init(); UART0_Init(); printf("\n"); printf("+--------------------------------------------------------+\n"); printf("| NuMicro USB Micro Printer Sample Code |\n"); printf("+--------------------------------------------------------+\n"); USBD_Open(&gsInfo, PTR_ClassRequest, NULL); /* Endpoint configuration */ PTR_Init(); USBD_Start(); #if CRYSTAL_LESS /* Backup init trim */ u32TrimInit = M32(TRIM_INIT); /* Enable USB crystal-less */ SYS->HIRCTCTL = 0x201 | (31 << SYS_HIRCTCTL_BOUNDARY_Pos); #endif NVIC_EnableIRQ(USBD_IRQn); PB->PMD = 0x5000; // PB.6, PB.7 output mode while(1) { #if CRYSTAL_LESS /* Re-start crystal-less when any error found */ if (SYS->HIRCTSTS & (SYS_HIRCTSTS_CLKERIF_Msk | SYS_HIRCTSTS_TFAILIF_Msk)) { SYS->HIRCTSTS = SYS_HIRCTSTS_CLKERIF_Msk | SYS_HIRCTSTS_TFAILIF_Msk; if((u32TrimInit < 0x1E6) || (u32TrimInit > 0x253)) /* Re-enable crystal-less */ SYS->HIRCTCTL = 0x201 | (1 << SYS_HIRCTCTL_BOUNDARY_Pos); else /* Re-enable crystal-less */ SYS->HIRCTCTL = 0x201 | (31 << SYS_HIRCTCTL_BOUNDARY_Pos); //printf("USB trim fail. Just retry. SYS->HIRCTSTS = 0x%x, SYS->HIRCTCTL = 0x%x\n", SYS->HIRCTSTS, SYS->HIRCTCTL); } #endif CLK_SysTickDelay(2000); // delay if(++Str[1] > 0x39) Str[1] = 0x30; // increase 1 to 10 than reset to 0 PB->DOUT ^= 0x40; // PB.6 } }
/** * @brief Get ID of NOR Flash * * @param[in] None * * @return Return Manufacture ID and Device ID * * @details Return the ID of W39L040P and Manufacture ID should be 0xDA, Device ID should be 0x31. */ uint32_t NOR_GetID(void) { uint8_t u8ManuFactureID, u8DeviceID; *(g_pu8NorBaseAddr + 0x5555) = 0xAA; *(g_pu8NorBaseAddr + 0x2AAA) = 0x55; *(g_pu8NorBaseAddr + 0x5555) = 0x90; CLK_SysTickDelay(10); u8ManuFactureID = *(g_pu8NorBaseAddr + 0x0); u8DeviceID = *(g_pu8NorBaseAddr + 0x1); *(g_pu8NorBaseAddr + 0x5555) = 0xAA; *(g_pu8NorBaseAddr + 0x2AAA) = 0x55; *(g_pu8NorBaseAddr + 0x5555) = 0xF0; CLK_SysTickDelay(10); return ((u8ManuFactureID << 8) | u8DeviceID); }
/** * @brief This function makes USB host to recognize the device * * @param None * * @return None * * @details Enable WAKEUP, FLDET, USB and BUS interrupts. Disable software-disconnect function after 100ms delay with SysTick timer. */ void USBD_Start(void) { CLK_SysTickDelay(100000); /* Disable software-disconnect function */ USBD_CLR_SE0(); /* Clear USB-related interrupts before enable interrupt */ USBD_CLR_INT_FLAG(USBD_INT_BUS | USBD_INT_USB | USBD_INT_FLDET | USBD_INT_WAKEUP); /* Enable USB-related interrupts. */ USBD_ENABLE_INT(USBD_INT_BUS | USBD_INT_USB | USBD_INT_FLDET | USBD_INT_WAKEUP); }
//========================================================================= //----- (00003564) -------------------------------------------------------- __myevic__ void ReadAtoCurrent() { unsigned int adcShunt1, adcShunt2; unsigned int adcAtoVolts; unsigned int arez; unsigned int current1, current2; int s; if ( gFlags.firing || gFlags.probing_ato ) { if ( ISCUBO200 || ISRX200S || ISRX23 || ISRX300 ) { CLK_SysTickDelay( 10 ); adcShunt2 = ADC_Read( 15 ); if ( gFlags.firing && BuckDuty <= 25 && adcShunt2 > 200 ) adcShunt2 = 0; CLK_SysTickDelay( 10 ); } else { adcShunt2 = 0; } adcShunt1 = ADC_Read( 2 ); CLK_SysTickDelay( 10 ); adcAtoVolts = ADC_Read( 1 ); if ( ISCUBO200 || ISRX200S || ISRX23 || ISRX300 ) { current1 = ( ( 10 * 2560 * adcShunt2 ) >> 12 ) / AtoShuntRez; if ( gFlags.firing ) { current2 = ( ( 10 * 2560 * adcShunt1 ) >> 12 ) / AtoShuntRez; AtoCurrent = current1 + current2; } else {
int32_t main (void) { uint8_t Tx_Data[6]; uint8_t Rx_Data[6]; /* Init System, IP clock and multi-function I/O */ SYS_Init(); /* Init UART for printf */ UART_Init(); printf("+-------------------------------------------------------+\n"); printf("| Software I2C sample code |\n"); printf("| SW Master |\n"); printf("| HW Slave |\n"); printf("+-------------------------------------------------------+\n"); printf("Initiate I2C for slave\n"); InitI2C_HW(); printf("Initiate software I2C for Master\n"); I2C_SW_Open(100000); printf("Please connect:\n"); printf("SW SDA - P1.4 (PIN47) <-> HW SDA - P3.4 (PIN9) \n"); printf("SW SCL - P1.5 (PIN2) <-> HW SCL - P3.5 (PIN10) \n"); Tx_Data[0]=0; Tx_Data[1]=0; Tx_Data[2]=0xA5; Tx_Data[3]=0xcc; Tx_Data[4]=0xbb; Tx_Data[5]=0xdd; printf("Access I2C slave:\n"); I2C_SW_Send(0x15,Tx_Data,6); CLK_SysTickDelay(5000); I2C_SW_Get(0x15,Rx_Data,4); if((Rx_Data[0] != 0xaa) || (Rx_Data[1] != 0x22) || (Rx_Data[2] != 0x33) || (Rx_Data[3] != 0x44)) printf("Data Error!!\n"); else printf("Pass!!\n"); return 0; }
int32_t main (void) { uint8_t Tx_Data[6]; /* Init System, IP clock and multi-function I/O */ SYS_Init(); /* Init UART for printf */ UART_Init(); printf("+-------------------------------------------------------+\n"); printf("| Software I2C sample code |\n"); printf("| SW Master -> I2C EEPROM |\n"); printf("+-------------------------------------------------------+\n"); I2C_SW_I_Open(50000); Tx_Data[0]=0; Tx_Data[1]=0; Tx_Data[2]=0xAA; Tx_Data[3]=0xBB; Tx_Data[4]=0x55; Tx_Data[5]=0xCC; printf("Write data into EEPROM\n"); printf("Data:0x%x,0x%x,0x%x,0x%x\n",Tx_Data[2],Tx_Data[3],Tx_Data[4],Tx_Data[5] ); I2C_SW_I_Send(0x50,Tx_Data,6); while(I2C_SW_I_IsBZ()); if(I2C_SW_I_Count()!=6) while(1); CLK_SysTickDelay(5000); printf("Write address into EEPROM\n"); I2C_SW_I_Send(0x50,Tx_Data,2); while(I2C_SW_I_IsBZ()); if(I2C_SW_I_Count()!=2) while(1); printf("Read data form EEPROM\n"); I2C_SW_I_Get(0x50,Tx_Data,4); while(I2C_SW_I_IsBZ()); printf("Data:0x%x,0x%x,0x%x,0x%x\n",Tx_Data[0],Tx_Data[1],Tx_Data[2],Tx_Data[3] ); if(I2C_SW_I_Count()!=4) while(1); while(1); }
/** * @brief NOR Flash Chip Erase * * @param[in] None * * @retval FALSE Erase command fail * @retval TRUE Erase command pass * * @details W39L040P whole chip erase. */ uint8_t NOR_Erase(void) { uint8_t u8Status; *(g_pu8NorBaseAddr + 0x5555) = 0xAA; *(g_pu8NorBaseAddr + 0x2AAA) = 0x55; *(g_pu8NorBaseAddr + 0x5555) = 0x80; *(g_pu8NorBaseAddr + 0x5555) = 0xAA; *(g_pu8NorBaseAddr + 0x2AAA) = 0x55; *(g_pu8NorBaseAddr + 0x5555) = 0x10; u8Status = NOR_CheckCMDComplete(0x0, 0x0); if(u8Status == FALSE) return FALSE; CLK_SysTickDelay(200000); return TRUE; }
void SYS_Init(void) { /* Unlock protected registers */ SYS_UnlockReg(); /* Enable Internal RC clock */ CLK->PWRCON |= CLK_PWRCON_XTL12M | CLK_PWRCON_OSC10K_EN_Msk | CLK_PWRCON_IRC22M_EN_Msk; CLK_SysTickDelay(1200); /* Waiting for IRC22M clock ready */ CLK_WaitClockReady(CLK_CLKSTATUS_XTL_STB_Msk | CLK_CLKSTATUS_IRC22M_STB_Msk); /* IP clock divider */ CLK_SetSysTickClockSrc(CLK_CLKSEL0_STCLK_S_XTAL); /* Switch HCLK clock source to XTL */ CLK_SetHCLK(CLK_CLKSEL0_HCLK_S_XTAL,CLK_CLKDIV_HCLK(1)); /* Enable IP clock */ CLK_EnableModuleClock(UART_MODULE); CLK_EnableModuleClock(TMR1_MODULE); /* IP clock source */ CLK->CLKSEL1 = ( CLK->CLKSEL1 & (~CLK_CLKSEL1_UART_S_Msk) ) | CLK_CLKSEL1_UART_S_XTAL | CLK_CLKSEL1_TMR1_S_HCLK; /*---------------------------------------------------------------------------------------------------------*/ /* Init I/O Multi-function */ /*---------------------------------------------------------------------------------------------------------*/ /* Set P0 multi-function pins for UART RXD and TXD */ SYS->P0_MFP &= ~(SYS_MFP_P01_Msk | SYS_MFP_P00_Msk); SYS->P0_MFP |= (SYS_MFP_P01_RXD | SYS_MFP_P00_TXD); /* To update the variable SystemCoreClock */ SystemCoreClockUpdate(); /* Lock protected registers */ SYS_LockReg(); }
/** * @brief Check Command Complete * * @param[in] u32Addr The address to read out data to check if command complete * @param[in] u8Data The data to be compared with the read out data * * @retval FALSE Command fail * @retval TRUE Command complete * * @details Check if the specified command is complete or not. */ uint8_t NOR_CheckCMDComplete(uint32_t u32Addr, uint8_t u8Data) { /* Using Data Polling Algorithm to check if command is complete or not */ uint8_t u8CurData; volatile uint32_t u32TimeOutCnts = 0; /* Command timeout period is 200 ms */ u8Data = u8Data & (1 << 7); // read D7 while(u32TimeOutCnts < 200000) { u8CurData = NOR_ReadData(u32Addr); u8CurData = u8CurData & (1 << 7); // read DQ7 if(u8Data == u8CurData) { return TRUE; } CLK_SysTickDelay(1); u32TimeOutCnts++; } return FALSE; }
/*---------------------------------------------------------------------------------------------------------*/ int32_t main(void) { unsigned int u32ByteCount; unsigned int u32PageNumber; unsigned int u32ProgramFlashAddress = 0; unsigned int u32VerifyFlashAddress = 0; unsigned int MidDid; /* 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("Hello World.\n"); printf("PLL Clock = %d Hz\n", CLK_GetPLLClockFreq()); printf("Core Clock = %d Hz\n\n", CLK_GetHCLKFreq()); printf("+-------------------------------------------------------+\n"); printf("| M451 Series SPI_Flash Sample Code |\n"); printf("+-------------------------------------------------------+\n"); /* Open 7-Seg */ Open_Seven_Segment(); /* Open SPI for Serial Flash */ Open_SPI_Flash(); /* Read MID & DID */ MidDid = SpiFlash_ReadMidDid(); printf("\nMID and DID = %x", MidDid); /* Erase SPI Flash */ SpiFlash_ChipErase(); printf("\nFlash Erasing... "); /* Wait ready */ SpiFlash_WaitReady(); printf("Done!"); /* Fill the Source Data and clear Destination Data Buffer */ for(u32ByteCount = 0; u32ByteCount < 256; u32ByteCount++) { SrcArray[u32ByteCount] = u32ByteCount; DestArray[u32ByteCount] = 0; } u32ProgramFlashAddress = 0; u32VerifyFlashAddress = 0; for(u32PageNumber = 0; u32PageNumber < TEST_NUMBER; u32PageNumber++) { printf("\n\nTest Page Number = %d", u32PageNumber); Show_Seven_Segment(u32PageNumber, 1); CLK_SysTickDelay(200000); /*=== Program SPI Flash ===*/ printf("\n Flash Programming... "); /* Page Program */ SpiFlash_PageProgram(SrcArray, u32ProgramFlashAddress, 256); SpiFlash_WaitReady(); u32ProgramFlashAddress += 0x100; printf("Done!"); /*=== Read Back and Compare Data ===*/ printf("\n Flash Verifying... "); /* Page Read */ SpiFlash_ReadData(DestArray, u32VerifyFlashAddress, 256); u32VerifyFlashAddress += 0x100; for(u32ByteCount = 0; u32ByteCount < 256; u32ByteCount++) { if(DestArray[u32ByteCount] != u32ByteCount) { /* Error */ printf("SPI Flash R/W Fail!"); while(1); } } /* Clear Destination Data Buffer */ for(u32ByteCount = 0; u32ByteCount < 256; u32ByteCount++) DestArray[u32ByteCount] = 0; printf("Done!"); } printf("\n\nSPI Flash Test Ok!"); printf("\n\n"); while(1); }
/** * @brief Main routine. * @param None. * @return None. */ int32_t main(void) { S_RTC_TIME_DATA_T sCurTime; SYS_Init(); UART0_Init(); DEBUG_MSG("\nNANO130 NuTiny EVB Demo Program V1.0.0\n"); DEBUG_MSG("[Power Down Demo]\n"); /* Unlock protected registers */ SYS_UnlockReg(); /* Time Setting */ sCurTime.u32Year = 2013; sCurTime.u32Month = 10; sCurTime.u32Day = 15; sCurTime.u32Hour = 0; sCurTime.u32Minute = 0; sCurTime.u32Second = 0; sCurTime.u32DayOfWeek = RTC_TUESDAY; sCurTime.u32TimeScale = RTC_CLOCK_24; RTC_Open(&sCurTime); DEBUG_MSG("RTC Init. complete!\n"); /* Do LCD Initializaton */ LCD_Open(LCD_C_TYPE, 4, LCD_BIAS_THIRD, LCD_FREQ_DIV64, LCD_CPVOl_3V); LCD_EnableDisplay(); DEBUG_MSG("LCD Init. complete!\n"); /* Start displaying on LCD */ LCDLIB_SetSymbol(2, 27, 1); CLK_SysTickDelay(335000); textticker("*** NUVOTON NANO130 ***", 335000); CLK_SysTickDelay(335000); LCDLIB_Printf(0, "NUVOTON"); LCD_EnableBlink(250); CLK_SysTickDelay(335000); CLK_SysTickDelay(335000); CLK_SysTickDelay(335000); CLK_SysTickDelay(335000); CLK_SysTickDelay(335000); LCD_DisableBlink(); /* Read curent RTC time */ RTC_GetDateAndTime(&sCurTime); DEBUG_MSG("Current Time:%d/%02d/%02d %02d:%02d:%02d\n",sCurTime.u32Year,sCurTime.u32Month,sCurTime.u32Day,sCurTime.u32Hour,sCurTime.u32Minute,sCurTime.u32Second); /* Display RTC time */ showTime(sCurTime.u32Hour, sCurTime.u32Minute); DEBUG_MSG("Start MAIN loop.\n"); while(1) { textticker("*** GOING TO POWER DOWN ***", 335000); DEBUG_MSG("Going to Power Down...\n"); #ifdef __DEBUG_MSG while(!(UART1->FSR & UART_FSR_TE_F)) ; /* waits for message send out */ #endif /* Enter power down mode */ /* This sample will not wake up*/ Enter_PowerDown(); DEBUG_MSG("Program resume...\n"); if (_Wakeup_Flag == 1) { _Wakeup_Flag = 0; textticker("*** WAKE UP ***", 335000); CLK_SysTickDelay(335000); CLK_SysTickDelay(335000); CLK_SysTickDelay(335000); } }; }
/*---------------------------------------------------------------------------------------------------------*/ int main() { unsigned int u32ByteCount; unsigned int u32PageNumber; unsigned int u32ProgramFlashAddress = 0; unsigned int u32VerifyFlashAddress = 0; unsigned int MidDid; PDMA_T *PDMA_CH1, *PDMA_CH2; // PDMA Channel 1/2 control registers PDMA_CH1 = (PDMA_T *)((uint32_t) PDMA1_BASE + (0x100 * (CH1-1))); PDMA_CH2 = (PDMA_T *)((uint32_t) PDMA1_BASE + (0x100 * (CH2-1))); /* Initial system */ SYS_Init(); /* Initial UART1 to 115200-8n1 for print message */ UART1_Init(); printf("Hello World.\n"); printf("PLL Clock = %d Hz\n", CLK_GetPLLClockFreq()); printf("Core Clock = %d Hz\n\n", CLK_GetHCLKFreq()); printf("+-------------------------------------------------------+\n"); printf("| Nano100 Series SPI_Flash Sample Code with PDMA |\n"); printf("+-------------------------------------------------------+\n"); /* Open 7-Seg */ Open_Seven_Segment(); /* Open SPI for Serial Flash */ Open_SPI_Flash(); /* Initial PDMA Channels */ Init_PDMA_CH1_for_SPI0_TX((uint32_t)SrcArray); Init_PDMA_CH2_for_SPI0_RX((uint32_t)DestArray); /* Enable PDMA IRQ */ NVIC_EnableIRQ(PDMA_IRQn); /* Read MID & DID */ MidDid = SpiFlash_w_PDMA_ReadMidDid(); printf("\nMID and DID = %x", MidDid); /* Erase SPI Flash */ SpiFlash_w_PDMA_ChipErase(); printf("\nFlash Erasing... "); /* Wait ready */ SpiFlash_w_PDMA_WaitReady(); printf("Done!"); /* Fill the Source Data and clear Destination Data Buffer */ for(u32ByteCount=0; u32ByteCount<256; u32ByteCount++) { SrcArray[u32ByteCount] = u32ByteCount; DestArray[u32ByteCount] = 0; } u32ProgramFlashAddress = 0; u32VerifyFlashAddress = 0; for(u32PageNumber=0; u32PageNumber<TEST_NUMBER; u32PageNumber++) { printf("\n\nTest Page Number = %d", u32PageNumber); Show_Seven_Segment(u32PageNumber,1); CLK_SysTickDelay(200000); /*=== Program SPI Flash ===*/ printf("\n Flash Programming... "); /* Trigger PDMA specified Channel */ PDMA_CH1->CSR |= (PDMA_CSR_TRIG_EN_Msk | PDMA_CSR_PDMACEN_Msk); /* Page Program */ SpiFlash_w_PDMA_PageProgram(u32ProgramFlashAddress, 256); SpiFlash_w_PDMA_WaitReady(); u32ProgramFlashAddress += 0x100; printf("Done!"); /*=== Read Back and Compare Data ===*/ printf("\n Flash Verifying... "); /* Trigger PDMA specified Channel */ PDMA_CH2->CSR |= (PDMA_CSR_TRIG_EN_Msk | PDMA_CSR_PDMACEN_Msk); /* Page Read */ SpiFlash_w_PDMA_ReadData(u32VerifyFlashAddress, 256); u32VerifyFlashAddress += 0x100; for(u32ByteCount=0; u32ByteCount<256; u32ByteCount++) { if(DestArray[u32ByteCount]!=u32ByteCount) { /* Error */ printf("\n\nSPI Flash R/W Fail!"); while(1); } } /* Clear Destination Data Buffer */ for(u32ByteCount=0; u32ByteCount<256; u32ByteCount++) DestArray[u32ByteCount] = 0; printf("Done!"); } printf("\n\nSPI Flash with PDMA Test Ok!"); printf("\n\n"); while(1); }
//========================================================================= // 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; }
int32_t main (void) { int tdelay=1000000; /* Init System, IP clock and multi-function I/O */ SYS_Init(); //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. /* Init UART0 for printf */ UART0_Init(); printf("\n\nCPU @ %dHz\n", SystemCoreClock); /* This sample code will Output module clock from PC.0 pin. */ printf("+-----------------------------------------+\n"); printf("| Nano100 Module Clock Output Sample Code |\n"); printf("+-----------------------------------------+\n"); /* Enable PLL clock and set PLL clock to 48Mhz */ CLK_EnablePLL(CLK_PLLCTL_PLL_SRC_HIRC,48000000); CLK->MCLKO |= CLK_MCLKO_MCLK_EN_Msk ; printf("This sample code will Output module clock from PC.0 pin.\n"); while(1) { printf("MCLK output = ISP_CLK\n"); CLK->MCLKO = (CLK->MCLKO & ~CLK_MCLKO_MCLK_SEL_Msk) | CLK_MCLKO_MCLK_SEL_ISP_CLK; CLK_SysTickDelay(tdelay); printf("MCLK output = HIRC\n"); CLK->MCLKO = (CLK->MCLKO & ~CLK_MCLKO_MCLK_SEL_Msk) | CLK_MCLKO_MCLK_SEL_HIRC; CLK_SysTickDelay(tdelay); printf("MCLK output = HXT\n"); CLK->MCLKO = (CLK->MCLKO & ~CLK_MCLKO_MCLK_SEL_Msk) | CLK_MCLKO_MCLK_SEL_HXT; CLK_SysTickDelay(tdelay); printf("MCLK output = LXT\n"); CLK->MCLKO = (CLK->MCLKO & ~CLK_MCLKO_MCLK_SEL_Msk) | CLK_MCLKO_MCLK_SEL_LXT; CLK_SysTickDelay(tdelay); printf("MCLK output = LIRC\n"); CLK->MCLKO = (CLK->MCLKO & ~CLK_MCLKO_MCLK_SEL_Msk) | CLK_MCLKO_MCLK_SEL_LIRC; CLK_SysTickDelay(tdelay); printf("MCLK output = PLL ouptut\n"); CLK->MCLKO = (CLK->MCLKO & ~CLK_MCLKO_MCLK_SEL_Msk) | CLK_MCLKO_MCLK_SEL_PLLO; CLK_SysTickDelay(tdelay); printf("MCLK output = PLL input\n"); CLK->MCLKO = (CLK->MCLKO & ~CLK_MCLKO_MCLK_SEL_Msk) | CLK_MCLKO_MCLK_SEL_PLLI; CLK_SysTickDelay(tdelay); printf("MCLK output = sytem tick \n"); CLK->MCLKO = (CLK->MCLKO & ~CLK_MCLKO_MCLK_SEL_Msk) | CLK_MCLKO_MCLK_SEL_SYSTICK; CLK_SysTickDelay(tdelay); printf("MCLK output = HCLK\n"); CLK->MCLKO = (CLK->MCLKO & ~CLK_MCLKO_MCLK_SEL_Msk) | CLK_MCLKO_MCLK_SEL_ISP_CLK; CLK_SysTickDelay(tdelay); printf("MCLK output = PCLK\n"); CLK->MCLKO = (CLK->MCLKO & ~CLK_MCLKO_MCLK_SEL_Msk) | CLK_MCLKO_MCLK_SEL_PCLK; CLK_SysTickDelay(tdelay); } }