/**
* @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;
}
