/** * @brief main routine for CLKOUT example * @return Function should not exit. */ int main(void) { CHIP_SYSCTL_CLKOUTSRC_T clkoutClks; SystemCoreClockUpdate(); Board_Init(); Board_LED_Set(0, false); /* Enable and setup SysTick Timer at a 100Hz rate */ SysTick_Config(Chip_Clock_GetSysTickClockRate() / 100); /* Enable the power to the WDT */ Chip_SYSCTL_PowerUp(SYSCTL_POWERDOWN_WDTOSC_PD); /* Setup SCT PLL */ Chip_SYSCTL_PowerDown(SYSCTL_POWERDOWN_SCTPLL_PD); Chip_Clock_SetSCTPLLSource(SYSCTL_PLLCLKSRC_MAINOSC); Chip_Clock_SetupSCTPLL(5, 2); Chip_SYSCTL_PowerUp(SYSCTL_POWERDOWN_SCTPLL_PD); /* Wait for PLL to lock */ while (!Chip_Clock_IsSCTPLLLocked()) {} /* Enable RTC Oscillator */ Chip_Clock_EnableRTCOsc(); /* Enable SWM clocking prior to switch matrix operations */ Chip_SWM_Init(); Chip_GPIO_Init(LPC_GPIO); /* Setup pin as CLKOUT */ Chip_SWM_MovablePortPinAssign(SWM_CLK_OUT_O, CLKOUT_PORT, CLKOUT_PIN); /* Configure as a digital pin with no pullups/pulldowns */ Chip_IOCON_PinMuxSet(LPC_IOCON, CLKOUT_PORT, CLKOUT_PIN, (IOCON_MODE_INACT | IOCON_DIGMODE_EN)); /* Cycle through all clock sources for the CLKOUT pin */ while (1) { for (clkoutClks = SYSCTL_CLKOUTSRC_IRC; clkoutClks <= SYSCTL_CLKOUTSRC_RTC32K; clkoutClks++) { /* Setup CLKOUT pin for specific clock with a divider of 1 */ Chip_Clock_SetCLKOUTSource(clkoutClks, 1); /* Wait 5 seconds */ ticks100 = 0; while (ticks100 < 500) { __WFI(); } } } /* Disable CLKOUT pin by setting divider to 0 */ Chip_Clock_SetCLKOUTSource(SYSCTL_CLKOUTSRC_MAINSYSCLK, 0); return 0; }
/** * This brings up enough clocks to allow the processor to run quickly while initialising memory. * Other platform specific clock init can be done in init_platform() or init_architecture() */ WEAK void init_clocks( void ){ /** This brings up enough clocks to allow the processor to run quickly while initialising memory. * Other platform specific clock init can be done in init_platform() or init_architecture() */ //LPC54xx clock initialized in SystemInit(). #ifdef BOOTLOADER LPC_SYSCTL->SYSAHBCLKCTRL[0] |= 0x00000018; // Magicoe #if defined(__FPU_PRESENT) && __FPU_PRESENT == 1 fpuInit(); #endif #if defined(NO_BOARD_LIB) /* Chip specific SystemInit */ Chip_SystemInit(); #else /* Enable RAM 2 clock */ Chip_Clock_EnablePeriphClock(SYSCTL_CLOCK_SRAM2); /* Board specific SystemInit */ Board_SystemInit(); //init pin muxing and clock. #endif LPC_SYSCTL->SYSAHBCLKCTRL[0] |= 0x00000018; // Magicoe Chip_SYSCTL_PowerUp(PDRUNCFG_PD_IRC_OSC_EN|PDRUNCFG_PD_IRC_EN); /* Configure PIN0.21 as CLKOUT with pull-up, monitor the MAINCLK on scope */ Chip_IOCON_PinMuxSet(LPC_IOCON, 0, 21, IOCON_MODE_PULLUP | IOCON_FUNC1 | IOCON_DIGITAL_EN | IOCON_INPFILT_OFF); Chip_Clock_SetCLKOUTSource(SYSCTL_CLKOUTSRC_RTC, 1); Chip_Clock_EnableRTCOsc(); Chip_RTC_Init(LPC_RTC); Chip_RTC_Enable1KHZ(LPC_RTC); Chip_RTC_Enable(LPC_RTC); #endif }
/* common clock initialisation function * This brings up enough clocks to allow the processor to run quickly while initialising memory. * Other platform specific clock init can be done in init_platform() or init_host_mcu() */ WEAK void platform_init_system_clocks( void ) { /* CPU clock source starts with IRC */ Chip_Clock_SetMainPllSource( SYSCTL_PLLCLKSRC_IRC ); Chip_Clock_SetCPUClockSource( SYSCTL_CCLKSRC_SYSCLK ); /* Enable main oscillator used for PLLs */ LPC_SYSCTL->SCS = SYSCTL_OSCEC; while ( ( LPC_SYSCTL->SCS & SYSCTL_OSCSTAT ) == 0 ) { } /* PLL0 clock source is 12MHz oscillator, PLL1 can only be the main oscillator */ Chip_Clock_SetMainPllSource( SYSCTL_PLLCLKSRC_MAINOSC ); /* Setup PLL0 for a 480MHz clock. It is divided by CPU Clock Divider to create CPU Clock. Input clock rate (FIN) is main oscillator = 12MHz FCCO is selected for PLL Output and it must be between 275 MHz to 550 MHz. FCCO = (2 * M * FIN) / N = integer multiplier of CPU Clock (120MHz) = 480MHz N = 1, M = 480 * 1/(2*12) = 20 */ Chip_Clock_SetupPLL( SYSCTL_MAIN_PLL, PLL_M_CONSTANT - 1, PLL_N_CONSTANT - 1 );/* Multiply by PLL_M_CONSTANT, Divide by PLL_N_CONSTANT */ /* Enable PLL0 */ Chip_Clock_EnablePLL( SYSCTL_MAIN_PLL, SYSCTL_PLL_ENABLE ); /* Change the CPU Clock Divider setting for the operation with PLL0. Divide value = (480/120) = 4 */ Chip_Clock_SetCPUClockDiv( 3 ); /* pre-minus 1 */ while ( !Chip_Clock_IsMainPLLLocked( ) ) { } /* Connect PLL0 */ Chip_Clock_EnablePLL( SYSCTL_MAIN_PLL, SYSCTL_PLL_ENABLE | SYSCTL_PLL_CONNECT ); /* Wait for PLL0 to be connected */ while ( !Chip_Clock_IsMainPLLConnected( ) ) { } /* Setup FLASH access to 5 clocks (120MHz clock) */ Chip_FMC_SetFLASHAccess( FLASHTIM_120MHZ_CPU ); /* Enable peripheral base clocks*/ Chip_Clock_SetPCLKDiv( SYSCTL_PCLK_SPI, SYSCTL_CLKDIV_1 ); Chip_RTC_Enable( LPC_RTC, ENABLE ); Chip_Clock_SetCLKOUTSource( SYSCTL_CLKOUTSRC_RTC, 1 ); Chip_Clock_EnableCLKOUT( ); }
/* Wecan Modify platform_rtc_init 2015.06.10 */ OSStatus platform_rtc_init(void) { #ifdef MICO_ENABLE_MCU_RTC /* CLKOUT = 32K_Osc */ Chip_IOCON_PinMuxSet(LPC_IOCON, platform_gpio_pins[CLKOUT].port , platform_gpio_pins[CLKOUT].pin_number, (IOCON_MODE_PULLUP | IOCON_FUNC1 | IOCON_DIGITAL_EN | IOCON_INPFILT_OFF)); Chip_Clock_SetCLKOUTSource(SYSCON_CLKOUTSRC_RTC, 1); /* Turn on the RTC 32K Oscillator */ Chip_SYSCON_PowerUp(SYSCON_PDRUNCFG_PD_32K_OSC); /* Enable the RTC oscillator, oscillator rate can be determined by calling Chip_Clock_GetRTCOscRate() */ Chip_Clock_EnableRTCOsc(); /* Initialize RTC driver (enables RTC clocking) */ Chip_RTC_Init(LPC_RTC); /* Enable RTC as a peripheral wakeup event */ //Chip_SYSCON_EnsableWakeup(SYSCON_STARTER_RTC); /* RTC reset */ Chip_RTC_Reset(LPC_RTC); /* Start RTC at a count of 0 when RTC is disabled. If the RTC is enabled, you need to disable it before setting the initial RTC count. */ Chip_RTC_Disable(LPC_RTC); platform_rtc_set_time(&default_rtc_time); //Chip_RTC_SetCount(LPC_RTC, 0); /* Set a long alarm time so the interrupt won't trigger */ //Chip_RTC_SetAlarm(LPC_RTC, (Chip_RTC_GetCount(LPC_RTC) + 5)); /* Enable RTC and high resolution timer - this can be done in a single call with Chip_RTC_EnableOptions(LPC_RTC, (RTC_CTRL_RTC1KHZ_EN | RTC_CTRL_RTC_EN)); */ //Chip_RTC_Enable1KHZ(LPC_RTC); Chip_RTC_Enable(LPC_RTC); /* Clear latched RTC interrupt statuses */ Chip_RTC_ClearStatus(LPC_RTC, (RTC_CTRL_OFD | RTC_CTRL_ALARM1HZ | RTC_CTRL_WAKE1KHZ)); return kNoErr; #else return kUnsupportedErr; #endif }
/* Set up and initialize clocking prior to call to main */ void Board_SetupClocking(void) { /* The IRC is always the first clock source even if CLK_IN is used later. Once CLK_IN is selected as the clock source. We can turned off the IRC later. Turn on the IRC by clearing the power down bit */ Chip_SYSCTL_PowerUp(PDRUNCFG_PD_IRC_OSC_EN | PDRUNCFG_PD_IRC_EN); //Board_SetupXtalClocking(); Board_SetupIRCClocking(); /* Select the CLKOUT clocking source */ Chip_Clock_SetCLKOUTSource(SYSCTL_CLKOUTSRC_MAINSYSCLK, 1); /* ASYSNC SYSCON needs to be on or all serial peripheral won't work. Be careful if PLL is used or not, ASYNC_SYSCON source needs to be selected carefully. */ Chip_SYSCTL_Enable_ASYNC_Syscon(true); Chip_Clock_SetAsyncSysconClockDiv(1); Chip_Clock_SetAsyncSysconClockSource(ASYNC_SYSCTL_CLOCK_IRC); }
/** * @brief Application main function * @return Does not return */ int main(void) { /* Board Initialization */ SystemCoreClockUpdate(); Board_Init(); /* Clock enables and checks */ if (CLKOUT_SEL == SYSCON_CLKOUTSRC_RTC) { /* Turn on the RTC 32K Oscillator */ Chip_SYSCON_PowerUp(SYSCON_PDRUNCFG_PD_32K_OSC); Chip_Clock_EnableRTCOsc(); } else if (CLKOUT_SEL == SYSCON_CLKOUTSRC_WDTOSC) { /* Enable the power to the WDT Oscillator */ Chip_SYSCON_PowerUp(SYSCON_PDRUNCFG_PD_WDT_OSC); } else if (CLKOUT_SEL == SYSCON_CLKOUTSRC_CLKIN) { /* Setup CLKIN via IOCON (pin muxing) */ Chip_IOCON_PinMuxSet(LPC_IOCON, 0, 22, (IOCON_FUNC1 | IOCON_MODE_INACT | IOCON_DIGITAL_EN)); if (Chip_Clock_GetExtClockInRate() == 0) { /* Can't continue, stop! */ DEBUGSTR("CLKIN selected for CLKOUT, but CLKIN rate is 0\r\n"); while (1) {} } } /* Map P0.21 as CLKOUT pin */ Chip_IOCON_PinMuxSet(LPC_IOCON, 0, 21, (IOCON_FUNC1 | IOCON_MODE_INACT | IOCON_DIGITAL_EN)); /* There isn't too much to this example */ Chip_Clock_SetCLKOUTSource(CLKOUT_SEL, CLKOUT_DIV); return 0; }
int main(void) { #if defined (__USE_LPCOPEN) // Read clock settings and update SystemCoreClock variable SystemCoreClockUpdate(); #if !defined(NO_BOARD_LIB) #if defined (__MULTICORE_MASTER) || defined (__MULTICORE_NONE) // Set up and initialize all required blocks and // functions related to the board hardware Board_Init(); #endif // Set the LED to the state of "On" Board_LED_Set(0, true); #endif #endif #if defined (__MULTICORE_MASTER_SLAVE_M0SLAVE) || \ defined (__MULTICORE_MASTER_SLAVE_M4SLAVE) boot_multicore_slave(); #endif // Get the address of the PCM value FIFO from the M4 master. PCM_FIFO = (PCM_FIFO_T *) Chip_MBOX_GetValue(LPC_MBOX, MAILBOX_CM0PLUS); // Map P0.21 as the CLKOUT pin. Chip_IOCON_PinMuxSet(LPC_IOCON, 0, 21, (IOCON_FUNC1 | IOCON_MODE_INACT | IOCON_DIGITAL_EN)); // Route the main clock to the CLKOUT pin, for a 1 MHz signal. Chip_Clock_SetCLKOUTSource(SYSCON_CLKOUTSRC_MAINCLK, SystemCoreClock / 1000000); // Enable the GPIO and pin-interrupt sub-systems. Chip_GPIO_Init(LPC_GPIO); Chip_PININT_Init(LPC_PININT); // Map PIO0_9 as a GPIO input pin. This is the data signal from the // microphone. Chip_GPIO_SetPinDIRInput(LPC_GPIO, 0, 9); Chip_IOCON_PinMuxSet(LPC_IOCON, 0, 9, (IOCON_FUNC0 | IOCON_DIGITAL_EN | IOCON_GPIO_MODE)); // Map PIO0_11 as a GPIO input pin, triggering pin-interrupt 0. This will // indicate that there is a sample ready from the microphone. Chip_GPIO_SetPinDIRInput(LPC_GPIO, 0, 11); Chip_IOCON_PinMuxSet(LPC_IOCON, 0, 11, (IOCON_FUNC0 | IOCON_DIGITAL_EN | IOCON_GPIO_MODE)); Chip_INMUX_PinIntSel(PININTSELECT0, 0, 11); // Trigger the interrupt on the clock's rising edge. Chip_PININT_ClearIntStatus(LPC_PININT, PININTCH(PININTSELECT0)); Chip_PININT_SetPinModeEdge(LPC_PININT, PININTCH(PININTSELECT0)); Chip_PININT_EnableIntHigh(LPC_PININT, PININTCH(PININTSELECT0)); // Enable the interrupt in the NVIC. NVIC_EnableIRQ(PIN_INT0_IRQn); // Spin while waiting for interrupts from the microphone. while (1) { __WFI(); } return 0; }