/* Set up and initialize all required blocks and functions related to the board hardware */ void Board_Init(void) { /* Sets up DEBUG UART */ DEBUGINIT(); /* Updates SystemCoreClock global var with current clock speed */ SystemCoreClockUpdate(); /* Initializes GPIO */ Chip_GPIO_Init(LPC_GPIO_PORT); /* Setup GPIOs for USB demos */ Chip_SCU_PinMuxSet(0x2, 6, (SCU_MODE_PULLUP | SCU_MODE_INBUFF_EN | SCU_MODE_FUNC4)); /* P2_6 USB1_PWR_EN, USB1 VBus function */ Chip_SCU_PinMuxSet(0x2, 5, (SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC2)); /* P2_5 USB1_VBUS, MUST CONFIGURE THIS SIGNAL FOR USB1 NORMAL OPERATION */ Chip_SCU_PinMuxSet(0x1, 7, (SCU_MODE_PULLUP | SCU_MODE_INBUFF_EN | SCU_MODE_FUNC4)); /* P1_7 USB0_PWR_EN, USB0 VBus function Xplorer */ Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 5, 6); /* GPIO5[6] = USB1_PWR_EN */ Chip_GPIO_SetPinState(LPC_GPIO_PORT, 5, 6, true); /* GPIO5[6] output high */ /* Initialize LEDs */ Board_LED_Init(); #if defined(USE_RMII) Chip_ENET_RMIIEnable(LPC_ETHERNET); #else Chip_ENET_MIIEnable(LPC_ETHERNET); #endif }
uint32_t PWMSetWidth(uint8_t channel, uint8_t output, uint32_t width) { if (output >= MAX_OUTPUTS || channel > CHANNEL_C_TIMER_INDEX) { return 1; } if (eDVSMode != EDVS_MODE_INTERNAL && channel == 0) { return 1; // channel 0 taken for master/slave mode } LPC_TIMER_T * timer = halTimers[channel].timer; halTimers[channel].witdh[output] = width; halTimers[channel].enabled[output] = ENABLE; /** * Since we have to use the Core M0 to overcome hardware limitations * when the width is 0 or bigger than the period of the wave, * the output is set as GPIO and driven accordingly. */ if (width == 0) { //Set GPIO Low Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, halTimers[channel].portGpio[output], halTimers[channel].pinGpio[output]); Chip_GPIO_SetPinOutLow(LPC_GPIO_PORT, halTimers[channel].portGpio[output], halTimers[channel].pinGpio[output]); Chip_SCU_PinMuxSet(halTimers[channel].port[output], halTimers[channel].pin[output], halTimers[channel].gpioMode[output]); } else if (width >= timer->MR[2]) { //Set GPIO High Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, halTimers[channel].portGpio[output], halTimers[channel].pinGpio[output]); Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, halTimers[channel].portGpio[output], halTimers[channel].pinGpio[output]); Chip_SCU_PinMuxSet(halTimers[channel].port[output], halTimers[channel].pin[output], halTimers[channel].gpioMode[output]); } else { Chip_TIMER_SetMatch(timer, halTimers[channel].timerChannel[output], width); Chip_SCU_PinMuxSet(halTimers[channel].port[output], halTimers[channel].pin[output], halTimers[channel].timerMode[output]); } return 0; }
/***************************************************************************** * Private functions ****************************************************************************/ static void set_pinmux(void) { #if defined(BOARD_NXP_LPCXPRESSO_4337) Chip_SCU_PinMuxSet(0x3, 1, (SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_FUNC2)); /* CAN RD */ Chip_SCU_PinMuxSet(0x3, 2, (SCU_MODE_INACT | SCU_MODE_FUNC2)); /* CAN TD */ #else #warning "No pin muxing set for this board" #endif }
uint32_t PWMSetPeriod(uint8_t channel, uint32_t period) { if (channel > CHANNEL_C_TIMER_INDEX) { return 1; } if (eDVSMode != EDVS_MODE_INTERNAL && channel == 0) { return 1; // channel 0 taken for master/slave mode } LPC_TIMER_T * timer = halTimers[channel].timer; halTimers[channel].period = period; /** * If the period equal 0, the timer is disable and its outputs are set as GPIO and driven low. */ if (period == 0) { Chip_TIMER_DeInit(timer); //Stop the timer Chip_TIMER_SetMatch(timer, 2, 0); halTimers[channel].enabled[0] = DISABLE; halTimers[channel].enabled[1] = DISABLE; Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, halTimers[channel].portGpio[0], halTimers[channel].pinGpio[0]); Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, halTimers[channel].portGpio[1], halTimers[channel].pinGpio[1]); Chip_GPIO_SetPinOutLow(LPC_GPIO_PORT, halTimers[channel].portGpio[0], halTimers[channel].pinGpio[0]); Chip_GPIO_SetPinOutLow(LPC_GPIO_PORT, halTimers[channel].portGpio[1], halTimers[channel].pinGpio[1]); Chip_SCU_PinMuxSet(halTimers[channel].port[0], halTimers[channel].pin[0], halTimers[channel].gpioMode[0]); Chip_SCU_PinMuxSet(halTimers[channel].port[1], halTimers[channel].pin[1], halTimers[channel].gpioMode[1]); } else { /** * The channel match 2 is used as the controller of the base frequency. * When there is a match on this channel, the timer is reset and the external match bit * is set to 1. * The M0 core is looking for this change and it sets the output of the channels to high. */ Chip_TIMER_Init(timer); Chip_TIMER_Disable(timer); Chip_TIMER_Reset(timer); /** * The Main clock is running at 192Mhz so set the Prescaler in order to have * a 1 Mhz timer. Timer_CLK = Main_CLK/ (PR+1) */ Chip_TIMER_PrescaleSet(timer, 191); Chip_TIMER_ResetOnMatchEnable(timer, 2); Chip_TIMER_StopOnMatchDisable(timer, 2); Chip_TIMER_MatchDisableInt(timer, 2); Chip_TIMER_SetMatch(timer, 2, period); //Reconfigure match channels! if (halTimers[channel].enabled[0]) { PWMSetWidth(channel, 0, halTimers[channel].witdh[0]); } if (halTimers[channel].enabled[1]) { PWMSetWidth(channel, 1, halTimers[channel].witdh[1]); } Chip_TIMER_ExtMatchControlSet(timer, 0, TIMER_EXTMATCH_SET, 2); // Clear interrupt pending timer->IR = 0xFFFFFFFF; Chip_TIMER_Enable(timer); } return 0; }
void Board_SDMMC_Init(void) { Chip_SCU_PinMuxSet(0x1, 9, (SCU_PINIO_FAST | SCU_MODE_FUNC7)); /* P1.9 connected to SDIO_D0 */ Chip_SCU_PinMuxSet(0x1, 10, (SCU_PINIO_FAST | SCU_MODE_FUNC7)); /* P1.10 connected to SDIO_D1 */ Chip_SCU_PinMuxSet(0x1, 11, (SCU_PINIO_FAST | SCU_MODE_FUNC7)); /* P1.11 connected to SDIO_D2 */ Chip_SCU_PinMuxSet(0x1, 12, (SCU_PINIO_FAST | SCU_MODE_FUNC7)); /* P1.12 connected to SDIO_D3 */ Chip_SCU_ClockPinMuxSet(2, (SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_FUNC4)); /* CLK2 connected to SDIO_CLK */ Chip_SCU_PinMuxSet(0x1, 6, (SCU_PINIO_FAST | SCU_MODE_FUNC7)); /* P1.6 connected to SDIO_CMD */ }
/* Sets up board specific I2C interface */ void Board_I2C_Init(I2C_ID_T id) { if (id == I2C1) { /* Configure pin function for I2C1 on PE.13 (I2C1_SDA) and PE.15 (I2C1_SCL) */ Chip_SCU_PinMuxSet(0xE, 13, (SCU_MODE_ZIF_DIS | SCU_MODE_INBUFF_EN | SCU_MODE_FUNC2)); Chip_SCU_PinMuxSet(0xE, 15, (SCU_MODE_ZIF_DIS | SCU_MODE_INBUFF_EN | SCU_MODE_FUNC2)); } else { Chip_SCU_I2C0PinConfig(I2C0_STANDARD_FAST_MODE); } }
void Board_I2C_Init(I2C_ID_T id) { if (id == I2C1) { /* Configure pin function for I2C1*/ Chip_SCU_PinMuxSet(0x2, 3, (SCU_MODE_ZIF_DIS | SCU_MODE_INBUFF_EN | SCU_MODE_FUNC1)); /* P2.3 : I2C1_SDA */ Chip_SCU_PinMuxSet(0x2, 4, (SCU_MODE_ZIF_DIS | SCU_MODE_INBUFF_EN | SCU_MODE_FUNC1)); /* P2.4 : I2C1_SCL */ } else { Chip_SCU_I2C0PinConfig(I2C0_STANDARD_FAST_MODE); } }
void Board_UART_Init(LPC_USART_T *pUART) { if (pUART == LPC_USART0) { Chip_SCU_PinMuxSet(0x6, 4, (SCU_MODE_PULLDOWN | SCU_MODE_FUNC2)); /* P6.5 : UART0_TXD */ Chip_SCU_PinMuxSet(0x6, 5, (SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC2));/* P6.4 : UART0_RXD */ } else if (pUART == LPC_UART1) { Chip_SCU_PinMuxSet(0x1, 13, (SCU_MODE_PULLDOWN | SCU_MODE_FUNC2)); /* P1.13 : UART1_TXD */ Chip_SCU_PinMuxSet(0x1, 14, (SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC2)); /* P1.14 : UART1_RX */ } }
static void Board_LED_Init() { /* Set LEDs as output */ Chip_SCU_PinMuxSet(LED1_PIN_PORT_NUM, LED1_PIN_BIT_NUM, (SCU_PINIO_FAST | LED1_MODE_FUNC)); Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, LED1_GPIO_PORT_NUM, LED1_GPIO_BIT_NUM); Chip_SCU_PinMuxSet(LED2_PIN_PORT_NUM, LED2_PIN_BIT_NUM, (SCU_PINIO_FAST | LED2_MODE_FUNC)); Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, LED2_GPIO_PORT_NUM, LED2_GPIO_BIT_NUM); /* Set initial states to off (true to disable) */ Chip_GPIO_SetPinState(LPC_GPIO_PORT, LED1_GPIO_PORT_NUM, LED1_GPIO_BIT_NUM, (bool) true); Chip_GPIO_SetPinState(LPC_GPIO_PORT, LED2_GPIO_PORT_NUM, LED2_GPIO_BIT_NUM, (bool) true); }
void Board_SSP_Init(LPC_SSP_T *pSSP) { if (pSSP == LPC_SSP1) { Chip_SCU_PinMuxSet(0x1, 5, (SCU_PINIO_FAST | SCU_MODE_FUNC5)); /* P1.5 => SSEL1 */ Chip_SCU_PinMuxSet(0xF, 4, (SCU_PINIO_FAST | SCU_MODE_FUNC0)); /* PF.4 => SCK1 */ Chip_SCU_PinMuxSet(0x1, 4, (SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC5)); /* P1.4 => MOSI1 */ Chip_SCU_PinMuxSet(0x1, 3, (SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC5)); /* P1.3 => MISO1 */ } else { return; } }
/* Initialize pin muxing for a UART */ void Board_UART_Init(LPC_USART_T *pUART) { if (pUART == LPC_USART0) { } else if (pUART == LPC_UART1) { } else if (pUART == LPC_USART2) { /* P2.10 : UART2_TXD J3 -> Pin 8, P2.11 : UART2_RXD -> J3 Pin-7*/ Chip_SCU_PinMuxSet(0x2, 10, (SCU_MODE_PULLDOWN | SCU_MODE_FUNC2)); Chip_SCU_PinMuxSet(0x2, 11, (SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC2)); } else if (pUART == LPC_USART3) { } }
void Board_SSP_Init(LPC_SSP_T *pSSP) { if (pSSP == LPC_SSP1) { /* Set up clock and power for SSP1 module */ /* Configure SSP1 pins*/ /* SCLK comes out pin CLK0 */ Chip_SCU_ClockPinMuxSet(0, (SCU_PINIO_FAST | SCU_MODE_FUNC6)); /* CLK0 connected to CLK SCU_MODE_FUNC6=SSP1 CLK1 */ Chip_SCU_PinMuxSet(0x1, 5, (SCU_PINIO_FAST | SCU_MODE_FUNC5)); /* P1.5 connected to nCS SCU_MODE_FUNC5=SSP1 SSEL1 */ Chip_SCU_PinMuxSet(0x1, 3, (SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC5));/* P1.3 connected to SO SCU_MODE_FUNC5=SSP1 MISO1 */ Chip_SCU_PinMuxSet(0x1, 4, (SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC5));/* P1.4 connected to nSI SCU_MODE_FUNC5=SSP1 MOSI1 */ } else { return; } }
/** * @brief Very minor system initialization * @return none * The DFU Utility setup does the minimum amount of setup as possible to be * portable among different devices. */ void dfuUtilSystemInit(void) { int i; unsigned int *pSCB_VTOR = (unsigned int *) 0xE000ED08; #if defined(__IAR_SYSTEMS_ICC__) extern void *__vector_table; *pSCB_VTOR = (unsigned int) &__vector_table; #elif defined(__CODE_RED) extern void *g_pfnVectors; *pSCB_VTOR = (unsigned int) &g_pfnVectors; #elif defined(__ARMCC_VERSION) extern void *__Vectors; *pSCB_VTOR = (unsigned int) &__Vectors; #endif /* SPIFI pin setup is done prior to setting up system clocking */ for (i = 0; i < (sizeof(spifipinmuxing) / sizeof(spifipinmuxing[0])); i++) { Chip_SCU_PinMuxSet(spifipinmuxing[i].pingrp, spifipinmuxing[i].pinnum, spifipinmuxing[i].modefunc); } }
static void pinConfig(void) { // PE.15 FUNC4 => GPIO7[15] output for CS Chip_SCU_PinMuxSet(0xE, 15, SCU_MODE_PULLDOWN | FUNC4); Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 7, 15); // P8.1 FUNC0 => GPIO4[1] input for TP_IRQ Chip_SCU_PinMuxSet(0x8, 1, SCU_MODE_INACT | SCU_MODE_INBUFF_EN | FUNC0); Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, 4, 1); // CS is controlled via PE.15 (GPIO7[16]) and not SSP0_SSEL. // Pin PF.1 should be configured as GPIO and set high. Chip_SCU_PinMuxSet(0xf, 1, SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_HIGHSPEEDSLEW_EN | FUNC4); Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 7, 16); Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, 7, 16); }
void Board_GPIOs_configure(int32_t gpioNumber,int32_t mode, int32_t pullup) { int32_t pullUpMode=SCU_MODE_INACT; switch(pullup) { case BOARD_GPIO_NOPULL: pullUpMode=SCU_MODE_INACT; break; case BOARD_GPIO_PULLUP: pullUpMode=SCU_MODE_PULLUP; break; case BOARD_GPIO_PULLDOWN: pullUpMode=SCU_MODE_PULLDOWN; break; } Chip_SCU_PinMuxSet(gpiosInfo[gpioNumber].port, gpiosInfo[gpioNumber].portBit, (pullUpMode | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | gpiosInfo[gpioNumber].func)); switch(mode) { case BOARD_GPIO_MODE_INPUT: Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, gpiosInfo[gpioNumber].gpio, gpiosInfo[gpioNumber].gpioBit); // Input break; case BOARD_GPIO_MODE_OUTPUT_PP: Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, gpiosInfo[gpioNumber].gpio, gpiosInfo[gpioNumber].gpioBit); // Output break; case BOARD_GPIO_MODE_OUTPUT_OD: Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, gpiosInfo[gpioNumber].gpio, gpiosInfo[gpioNumber].gpioBit); // Output break; } }
void Board_Buttons_Init(void) { buttonsData[0].callbackSw=NULL; buttonsData[1].callbackSw=NULL; buttonsData[2].callbackSw=NULL; buttonsData[3].callbackSw=NULL; Chip_SCU_PinMuxSet(0x1, 0, (SCU_MODE_PULLUP | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC0)); // P1_0 as GPIO0[4] Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, BUTTONS_BUTTON1_GPIO_PORT_NUM, BUTTONS_BUTTON1_GPIO_BIT_NUM); // input Chip_SCU_GPIOIntPinSel(0, 0, 4); // GPIO0[4] to INT0 Chip_PININT_ClearIntStatus(LPC_GPIO_PIN_INT, PININTCH(0)); // INT0 Chip_PININT_SetPinModeEdge(LPC_GPIO_PIN_INT, PININTCH(0)); // INT0 Chip_PININT_EnableIntLow(LPC_GPIO_PIN_INT, PININTCH(0)); // INT0 NVIC_ClearPendingIRQ(PIN_INT0_IRQn); NVIC_EnableIRQ(PIN_INT0_IRQn); Chip_SCU_PinMuxSet(0x1, 1, (SCU_MODE_PULLUP | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC0)); // P1_1 as GPIO0[8] Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, BUTTONS_BUTTON2_GPIO_PORT_NUM, BUTTONS_BUTTON2_GPIO_BIT_NUM); // input Chip_SCU_GPIOIntPinSel(1, 0, 8); // GPIO0[8] to INT1 Chip_PININT_ClearIntStatus(LPC_GPIO_PIN_INT, PININTCH(1)); // INT1 Chip_PININT_SetPinModeEdge(LPC_GPIO_PIN_INT, PININTCH(1)); // INT1 Chip_PININT_EnableIntLow(LPC_GPIO_PIN_INT, PININTCH(1)); // INT1 NVIC_ClearPendingIRQ(PIN_INT1_IRQn); NVIC_EnableIRQ(PIN_INT1_IRQn); Chip_SCU_PinMuxSet(0x1, 2, (SCU_MODE_PULLUP | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC0)); // P1_2 as GPIO0[9] Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, BUTTONS_BUTTON3_GPIO_PORT_NUM, BUTTONS_BUTTON3_GPIO_BIT_NUM); // input Chip_SCU_GPIOIntPinSel(2, 0, 9); // GPIO0[9] to INT2 Chip_PININT_ClearIntStatus(LPC_GPIO_PIN_INT, PININTCH(2)); // INT2 Chip_PININT_SetPinModeEdge(LPC_GPIO_PIN_INT, PININTCH(2)); // INT2 Chip_PININT_EnableIntLow(LPC_GPIO_PIN_INT, PININTCH(2)); // INT2 NVIC_ClearPendingIRQ(PIN_INT2_IRQn); NVIC_EnableIRQ(PIN_INT2_IRQn); Chip_SCU_PinMuxSet(0x1, 6, (SCU_MODE_PULLUP | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC0)); // P1_6 as GPIO1[9] Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, BUTTONS_BUTTON4_GPIO_PORT_NUM, BUTTONS_BUTTON4_GPIO_BIT_NUM); // input Chip_SCU_GPIOIntPinSel(3, 1, 9); // GPIO1[9] to INT3 Chip_PININT_ClearIntStatus(LPC_GPIO_PIN_INT, PININTCH(3)); // INT3 Chip_PININT_SetPinModeEdge(LPC_GPIO_PIN_INT, PININTCH(3)); // INT3 Chip_PININT_EnableIntLow(LPC_GPIO_PIN_INT, PININTCH(3)); // INT3 NVIC_ClearPendingIRQ(PIN_INT3_IRQn); NVIC_EnableIRQ(PIN_INT3_IRQn); }
/* Setup system clocking */ STATIC void SystemSetupClocking(void) { int i; /* Switch main system clocking to crystal */ Chip_Clock_EnableCrystal(); Chip_Clock_SetBaseClock(CLK_BASE_MX, CLKIN_CRYSTAL, true, false); /* Setup PLL for 100MHz and switch main system clocking */ Chip_Clock_SetupMainPLLHz(CLKIN_CRYSTAL, CRYSTAL_MAIN_FREQ_IN, 100 * 1000000, 100 * 1000000); Chip_Clock_SetBaseClock(CLK_BASE_MX, CLKIN_MAINPLL, true, false); /* Setup PLL for maximum clock */ Chip_Clock_SetupMainPLLHz(CLKIN_CRYSTAL, CRYSTAL_MAIN_FREQ_IN, MAX_CLOCK_FREQ, MAX_CLOCK_FREQ); /* Setup system base clocks and initial states. This won't enable and disable individual clocks, but sets up the base clock sources for each individual peripheral clock. */ for (i = 0; i < (sizeof(InitClkStates) / sizeof(InitClkStates[0])); i++) { Chip_Clock_SetBaseClock(InitClkStates[i].clk, InitClkStates[i].clkin, InitClkStates[i].autoblock_enab, InitClkStates[i].powerdn); } /* Reset and enable 32Khz oscillator */ LPC_CREG->CREG0 &= ~((1 << 3) | (1 << 2)); LPC_CREG->CREG0 |= (1 << 1) | (1 << 0); /* SPIFI pin setup is done prior to setting up system clocking */ for (i = 0; i < (sizeof(spifipinmuxing) / sizeof(spifipinmuxing[0])); i++) { Chip_SCU_PinMuxSet(spifipinmuxing[i].pingrp, spifipinmuxing[i].pinnum, spifipinmuxing[i].modefunc); } /* Setup a divider E for main PLL clock switch SPIFI clock to that divider. Divide rate is based on CPU speed and speed of SPI FLASH part. */ #if (MAX_CLOCK_FREQ > 180000000) Chip_Clock_SetDivider(CLK_IDIV_E, CLKIN_MAINPLL, 5); #else Chip_Clock_SetDivider(CLK_IDIV_E, CLKIN_MAINPLL, 4); #endif Chip_Clock_SetBaseClock(CLK_BASE_SPIFI, CLKIN_IDIVE, true, false); /* Attach main PLL clock to divider C with a divider of 2 */ Chip_Clock_SetDivider(CLK_IDIV_C, CLKIN_MAINPLL, 2); /* Setup default USB PLL state for a 480MHz output and attach */ Chip_Clock_SetupPLL(CLKIN_CRYSTAL, CGU_USB_PLL, &usbPLLSetup); /* USB1 needs a 60MHz clock. To get it, a divider of 4 and then 2 are chained to make a divide by 8 function. Connect the output of divider D to the USB1 base clock. */ Chip_Clock_SetDivider(CLK_IDIV_A, CLKIN_USBPLL, 4); Chip_Clock_SetDivider(CLK_IDIV_D, CLKIN_IDIVA, 2); Chip_Clock_SetBaseClock(CLK_BASE_USB1, CLKIN_IDIVD, true, true); /* Setup default audio PLL state for a FIXME output */ // Chip_Clock_SetupPLL(CGU_AUDIO_PLL, &audioPLLSetup); // FIXME }
/* Initialize pin muxing for SSP interface */ void Board_SSP_Init(LPC_SSP_T *pSSP) { if (pSSP == LPC_SSP0) { /* Not available on the board */ while (1) {} } else if (pSSP == LPC_SSP1) { /* Set up clock and muxing for SSP1 interface */ /* SSEL: P1.20: J3 PIN-6 [Serial Expansion Interface] */ Chip_SCU_PinMuxSet(0x1, 20, (SCU_PINIO_FAST | SCU_MODE_FUNC1)); /* MISO: P1.3: J3 PIN-5 [Serial Expansion Interface] */ Chip_SCU_PinMuxSet(0x1, 3, (SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC5)); /* MOSI: P1.4: J3 PIN-4 [Serial Expansion Interface] */ Chip_SCU_PinMuxSet(0x1, 4, (SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC5)); /* SCLK: PF.4: J3 PIN-3 [Serial Expansion Interface] */ Chip_SCU_PinMuxSet(0xF, 4, (SCU_PINIO_FAST | SCU_MODE_FUNC0)); } }
/* Board Audio initialization */ void Board_Audio_Init(LPC_I2S_T *pI2S, int micIn) { if (pI2S == LPC_I2S0) { /* TODO :Add pin mux for I2S0 later */ } else if (pI2S == LPC_I2S1) { Chip_SCU_PinMuxSet (0x1, 19, (SCU_PINIO_FAST | SCU_MODE_FUNC7)); /* I2S1_TX_SCK */ Chip_SCU_PinMuxSet (0x0, 1, (SCU_PINIO_FAST | SCU_MODE_FUNC7)); /* I2S1_TX_SDA */ Chip_SCU_PinMuxSet (0x3, 4, (SCU_PINIO_FAST | SCU_MODE_FUNC6)); /* I2S1_RX_SDA */ Chip_SCU_PinMuxSet (0x0, 0, (SCU_PINIO_FAST | SCU_MODE_FUNC7)); /* I2S1_TX_WS */ Chip_SCU_ClockPinMuxSet(0,(SCU_MODE_FUNC1|SCU_MODE_INACT)); /* Setup base clock for CLKOUT */ Chip_Clock_SetBaseClock(CLK_BASE_OUT, CLKIN_CRYSTAL, false, false); } else { /* It is a BUG catch it */ while(1); } /* Init WM8904 CODEC */ while (Board_Audio_CodecInit(micIn) != SUCCESS) {} }
void Board_GPIOs_Init(void) { // GPIOs default: input. pull up and pull down disabled. for(int32_t i=0 ; i<9; i++) { Chip_SCU_PinMuxSet(gpiosInfo[i].port, gpiosInfo[i].portBit, (SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | gpiosInfo[i].func)); Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, gpiosInfo[i].gpio, gpiosInfo[i].gpioBit); } extIntData[0].callback=NULL; extIntData[1].callback=NULL; extIntData[2].callback=NULL; extIntData[3].callback=NULL; }
void Board_KEYBOARD_Init(uint8_t rows, uint8_t columns) { keyboardInfo.enable=0; if(rows>KEYBOARD_MAX_ROWS) rows=KEYBOARD_MAX_ROWS; if(columns>KEYBOARD_MAX_COLUMNS) columns=KEYBOARD_MAX_COLUMNS; keyboardInfo.rows=rows; keyboardInfo.columns=columns; // configure Rows (Input) for(i=0 ; i<rows; i++) { Chip_SCU_PinMuxSet(keyboardRowsPinInfo[i].port, keyboardRowsPinInfo[i].portBit, (SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | keyboardRowsPinInfo[i].func)); Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, keyboardRowsPinInfo[i].gpio, keyboardRowsPinInfo[i].gpioBit); } // configure Columns (output) for(i=0 ; i<columns; i++) { Chip_SCU_PinMuxSet(keyboardColsPinInfo[i].port, keyboardColsPinInfo[i].portBit, (SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | keyboardColsPinInfo[i].func)); Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, keyboardColsPinInfo[i].gpio, keyboardColsPinInfo[i].gpioBit); Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, keyboardColsPinInfo[i].gpio, keyboardColsPinInfo[i].gpioBit); } keyboardInfo.state=KEYBOARD_SCAN_STATE_START; for(r=0; r<KEYBOARD_MAX_ROWS; r++) { for(c=0; c<KEYBOARD_MAX_COLUMNS; c++) keyboardInfo.stateMatrix[r][c]=1; } keyboardInfo.enable=1; }
/* Sets up system pin muxing */ STATIC void SystemSetupMuxing(void) { int i; /* Setup system level pin muxing */ for (i = 0; i < (sizeof(pinmuxing) / sizeof(pinmuxing[0])); i++) { Chip_SCU_PinMuxSet(pinmuxing[i].pingrp, pinmuxing[i].pinnum, pinmuxing[i].modefunc); } /* Clock pins only, group field not used */ for (i = 0; i < (sizeof(pinclockmuxing) / sizeof(pinclockmuxing[0])); i++) { Chip_SCU_ClockPinMuxSet(pinclockmuxing[i].pinnum, pinclockmuxing[i].modefunc); } }
void manual_test() { updateMotorDutyCycle(0, 1); test_sd_card(); Chip_SCU_PinMuxSet(LED0_PORT, LED0_PIN, MD_PLN_FAST | FUNC0); // set P0.0 as output Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, LED0_PORT_GPIO, LED0_PIN_GPIO); Chip_GPIO_SetPinOutLow(LPC_GPIO_PORT, LED0_PORT_GPIO, LED0_PIN_GPIO); for (;;) { timerDelayMs(1000); xprintf("Alive\n"); Chip_GPIO_SetPinToggle(LPC_GPIO_PORT, LED0_PORT_GPIO, LED0_PIN_GPIO); } }
/* Initialize Audio Codec */ static Status Board_Audio_CodecInit(int micIn) { /* Reset UDA1380 on board NGX Xplorer */ Chip_SCU_PinMuxSet(0x2, 10, (SCU_MODE_PULLUP | SCU_MODE_FUNC0)); Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 0, 14); Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, 14, true); // delay 1us delay(100000); Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, 14, false); delay(100000); if (!UDA1380_Init(UDA1380_MIC_IN_LR & - (micIn != 0))) { return ERROR; } return SUCCESS; }
void Board_UART_Init(LPC_USART_T *pUART) { if (pUART == LPC_USART0) { Chip_SCU_PinMuxSet(0x6, 4, (SCU_MODE_PULLDOWN | SCU_MODE_FUNC2)); /* P6.5 : UART0_TXD */ Chip_SCU_PinMuxSet(0x6, 5, (SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC2));/* P6.4 : UART0_RXD */ } else if (pUART == LPC_UART1) { Chip_SCU_PinMuxSet(0x5, 6, (SCU_MODE_PULLDOWN | SCU_MODE_FUNC4)); /* P5.6 : UART1_TXD */ Chip_SCU_PinMuxSet(0x1, 14, (SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC1)); /* P1.14 : UART1_RX */ } else if (pUART == LPC_USART2) { Chip_SCU_PinMuxSet(0x2, 10, (SCU_MODE_PULLDOWN | SCU_MODE_FUNC2)); /* P2.10 : UART2_TXD */ Chip_SCU_PinMuxSet(0x2, 11, (SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC2)); /* P2.11 : UART2_RX */ } }
/* Initialize Pin Muxing for LCD */ void Board_LCD_Init(void) { uint32_t val; Board_SSP_Init(LCD_SSP); val = LCD_SSP->CR0 & 0xFFFF; Chip_SCU_PinMuxSet(LCD_CDM_PORT, LCD_CMD_PIN, LCD_CMD_CFG); Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, LCD_CMD_GPIO_PORT, LCD_CMD_GPIO_PIN); Chip_GPIO_SetPinOutHigh(LPC_GPIO_PORT, LCD_CMD_GPIO_PORT, LCD_CMD_GPIO_PIN); /* Enable the SSP interface */ Chip_SSP_Init(LCD_SSP); Chip_SSP_Set_Mode(LCD_SSP, SSP_MODE_MASTER); Chip_SSP_SetFormat(LCD_SSP, SSP_BITS_8, SSP_FRAMEFORMAT_SPI, SSP_CLOCK_CPHA1_CPOL1); Chip_SSP_SetBitRate(LCD_SSP, LCD_BIT_RATE); Chip_SSP_Enable(LCD_SSP); lcd_cfg_val = LCD_SSP->CR0 & 0xFFFF; LCD_SSP->CR0 = val; }
static void Board_LED_Init() { uint32_t idx; #ifdef __BOARD_EDU_CIAA_NXP Chip_SCU_PinMuxSet(LED1_GPIO_PORT_NUM,LED1_GPIO_BIT_NUM,SCU_MODE_PULLUP | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC0); Chip_SCU_PinMuxSet(LED2_GPIO_PORT_NUM,LED2_GPIO_BIT_NUM,SCU_MODE_PULLUP | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC0); Chip_SCU_PinMuxSet(LED3_GPIO_PORT_NUM,LED3_GPIO_BIT_NUM,SCU_MODE_PULLUP | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC0); #endif #ifdef __BOARD_CIAA_NXP Chip_SCU_PinMuxSet(LED1_GPIO_PORT_NUM,LED1_GPIO_BIT_NUM,SCU_MODE_PULLUP | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC4); Chip_SCU_PinMuxSet(LED2_GPIO_PORT_NUM,LED2_GPIO_BIT_NUM,SCU_MODE_PULLUP | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC4); Chip_SCU_PinMuxSet(LED3_GPIO_PORT_NUM,LED3_GPIO_BIT_NUM,SCU_MODE_PULLUP | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC4); Chip_SCU_PinMuxSet(LED4_GPIO_PORT_NUM,LED4_GPIO_BIT_NUM,SCU_MODE_PULLUP | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC0); #endif for (idx = 0; idx < (sizeof(gpioLEDBits) / sizeof(io_port_t)); ++idx) { /* Set pin direction and init to off */ Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, gpioLEDBits[idx].port, gpioLEDBits[idx].pin); Chip_GPIO_SetPinState(LPC_GPIO_PORT, gpioLEDBits[idx].port, gpioLEDBits[idx].pin, (bool) true); } }
void Board_UART_Init(LPC_USART_T *pUART) { Chip_SCU_PinMuxSet(0x6, 4, (SCU_MODE_INACT | SCU_MODE_FUNC2)); /* P6,4 : UART0_TXD */ Chip_SCU_PinMuxSet(0x2, 1, (SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC1));/* P2.1 : UART0_RXD */ }
void Board_Buttons_Init(void) { Chip_SCU_PinMuxSet(0x2, 7, (SCU_MODE_PULLUP | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC0)); // P2_7 as GPIO0[7] Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, BUTTONS_BUTTON1_GPIO_PORT_NUM, BUTTONS_BUTTON1_GPIO_BIT_NUM); // input }
void PWMInit(void) { halTimers[CHANNEL_A_TIMER_INDEX].timer = CHANNEL_A_TIMER; halTimers[CHANNEL_A_TIMER_INDEX].port[0] = CHANNEL_A_0_PORT; halTimers[CHANNEL_A_TIMER_INDEX].port[1] = CHANNEL_A_1_PORT; halTimers[CHANNEL_A_TIMER_INDEX].pin[0] = CHANNEL_A_0_PIN; halTimers[CHANNEL_A_TIMER_INDEX].pin[1] = CHANNEL_A_1_PIN; halTimers[CHANNEL_A_TIMER_INDEX].portGpio[0] = CHANNEL_A_0_PORT_GPIO; halTimers[CHANNEL_A_TIMER_INDEX].portGpio[1] = CHANNEL_A_1_PORT_GPIO; halTimers[CHANNEL_A_TIMER_INDEX].pinGpio[0] = CHANNEL_A_0_PIN_GPIO; halTimers[CHANNEL_A_TIMER_INDEX].pinGpio[1] = CHANNEL_A_1_PIN_GPIO; halTimers[CHANNEL_A_TIMER_INDEX].timerMode[0] = MD_PUP | FUNC6; halTimers[CHANNEL_A_TIMER_INDEX].timerMode[1] = MD_PUP | FUNC6; halTimers[CHANNEL_A_TIMER_INDEX].gpioMode[0] = MD_PUP | FUNC4; halTimers[CHANNEL_A_TIMER_INDEX].gpioMode[1] = MD_PUP | FUNC4; halTimers[CHANNEL_A_TIMER_INDEX].timerChannel[0] = 0; halTimers[CHANNEL_A_TIMER_INDEX].timerChannel[1] = 1; halTimers[CHANNEL_A_TIMER_INDEX].witdh[0] = 0; halTimers[CHANNEL_A_TIMER_INDEX].witdh[1] = 0; halTimers[CHANNEL_A_TIMER_INDEX].enabled[0] = 0; halTimers[CHANNEL_A_TIMER_INDEX].enabled[1] = 0; halTimers[CHANNEL_A_TIMER_INDEX].period = 0; Chip_GPIO_SetPinOutLow(LPC_GPIO_PORT, CHANNEL_A_0_PORT_GPIO, CHANNEL_A_0_PIN_GPIO); Chip_GPIO_SetPinOutLow(LPC_GPIO_PORT, CHANNEL_A_1_PORT_GPIO, CHANNEL_A_1_PIN_GPIO); Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, CHANNEL_A_0_PORT_GPIO, CHANNEL_A_0_PIN_GPIO); Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, CHANNEL_A_1_PORT_GPIO, CHANNEL_A_1_PIN_GPIO); Chip_SCU_PinMuxSet(CHANNEL_A_0_PORT, CHANNEL_A_0_PIN, halTimers[CHANNEL_A_TIMER_INDEX].gpioMode[0]); Chip_SCU_PinMuxSet(CHANNEL_A_1_PORT, CHANNEL_A_1_PIN, halTimers[CHANNEL_A_TIMER_INDEX].gpioMode[1]); halTimers[CHANNEL_B_TIMER_INDEX].timer = CHANNEL_B_TIMER; halTimers[CHANNEL_B_TIMER_INDEX].port[0] = CHANNEL_B_0_PORT; halTimers[CHANNEL_B_TIMER_INDEX].port[1] = CHANNEL_B_1_PORT; halTimers[CHANNEL_B_TIMER_INDEX].pin[0] = CHANNEL_B_0_PIN; halTimers[CHANNEL_B_TIMER_INDEX].pin[1] = CHANNEL_B_1_PIN; halTimers[CHANNEL_B_TIMER_INDEX].portGpio[0] = CHANNEL_B_0_PORT_GPIO; halTimers[CHANNEL_B_TIMER_INDEX].portGpio[1] = CHANNEL_B_1_PORT_GPIO; halTimers[CHANNEL_B_TIMER_INDEX].pinGpio[0] = CHANNEL_B_0_PIN_GPIO; halTimers[CHANNEL_B_TIMER_INDEX].pinGpio[1] = CHANNEL_B_1_PIN_GPIO; halTimers[CHANNEL_B_TIMER_INDEX].timerMode[0] = MD_PUP | FUNC5; halTimers[CHANNEL_B_TIMER_INDEX].timerMode[1] = MD_PUP | FUNC5; halTimers[CHANNEL_B_TIMER_INDEX].gpioMode[0] = MD_PUP | FUNC4; halTimers[CHANNEL_B_TIMER_INDEX].gpioMode[1] = MD_PUP | FUNC4; halTimers[CHANNEL_B_TIMER_INDEX].timerChannel[0] = 0; halTimers[CHANNEL_B_TIMER_INDEX].timerChannel[1] = 1; halTimers[CHANNEL_B_TIMER_INDEX].witdh[0] = 0; halTimers[CHANNEL_B_TIMER_INDEX].witdh[1] = 0; halTimers[CHANNEL_B_TIMER_INDEX].enabled[0] = 0; halTimers[CHANNEL_B_TIMER_INDEX].enabled[1] = 0; halTimers[CHANNEL_B_TIMER_INDEX].period = 0; Chip_GPIO_SetPinOutLow(LPC_GPIO_PORT, CHANNEL_B_0_PORT_GPIO, CHANNEL_B_0_PIN_GPIO); Chip_GPIO_SetPinOutLow(LPC_GPIO_PORT, CHANNEL_B_1_PORT_GPIO, CHANNEL_B_1_PIN_GPIO); Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, CHANNEL_B_0_PORT_GPIO, CHANNEL_B_0_PIN_GPIO); Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, CHANNEL_B_1_PORT_GPIO, CHANNEL_B_1_PIN_GPIO); Chip_SCU_PinMuxSet(CHANNEL_B_0_PORT, CHANNEL_B_0_PIN, halTimers[CHANNEL_B_TIMER_INDEX].gpioMode[0]); Chip_SCU_PinMuxSet(CHANNEL_B_1_PORT, CHANNEL_B_1_PIN, halTimers[CHANNEL_B_TIMER_INDEX].gpioMode[1]); halTimers[CHANNEL_C_TIMER_INDEX].timer = CHANNEL_C_TIMER; halTimers[CHANNEL_C_TIMER_INDEX].port[0] = CHANNEL_C_0_PORT; halTimers[CHANNEL_C_TIMER_INDEX].port[1] = CHANNEL_C_1_PORT; halTimers[CHANNEL_C_TIMER_INDEX].pin[0] = CHANNEL_C_0_PIN; halTimers[CHANNEL_C_TIMER_INDEX].pin[1] = CHANNEL_C_1_PIN; halTimers[CHANNEL_C_TIMER_INDEX].portGpio[0] = CHANNEL_C_0_PORT_GPIO; halTimers[CHANNEL_C_TIMER_INDEX].portGpio[1] = CHANNEL_C_1_PORT_GPIO; halTimers[CHANNEL_C_TIMER_INDEX].pinGpio[0] = CHANNEL_C_0_PIN_GPIO; halTimers[CHANNEL_C_TIMER_INDEX].pinGpio[1] = CHANNEL_C_1_PIN_GPIO; halTimers[CHANNEL_C_TIMER_INDEX].timerMode[0] = MD_PUP | FUNC1; halTimers[CHANNEL_C_TIMER_INDEX].timerMode[1] = MD_PUP | FUNC1; halTimers[CHANNEL_C_TIMER_INDEX].gpioMode[0] = MD_PUP | FUNC4; halTimers[CHANNEL_C_TIMER_INDEX].gpioMode[1] = MD_PUP | FUNC0; halTimers[CHANNEL_C_TIMER_INDEX].timerChannel[0] = 0; halTimers[CHANNEL_C_TIMER_INDEX].timerChannel[1] = 3; // Special mapping for the Channel C_1 halTimers[CHANNEL_C_TIMER_INDEX].witdh[0] = 0; halTimers[CHANNEL_C_TIMER_INDEX].witdh[1] = 0; halTimers[CHANNEL_C_TIMER_INDEX].enabled[0] = 0; halTimers[CHANNEL_C_TIMER_INDEX].enabled[1] = 0; halTimers[CHANNEL_C_TIMER_INDEX].period = 0; Chip_GPIO_SetPinOutLow(LPC_GPIO_PORT, CHANNEL_C_0_PORT_GPIO, CHANNEL_C_0_PIN_GPIO); Chip_GPIO_SetPinOutLow(LPC_GPIO_PORT, CHANNEL_C_1_PORT_GPIO, CHANNEL_C_1_PIN_GPIO); Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, CHANNEL_C_0_PORT_GPIO, CHANNEL_C_0_PIN_GPIO); Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, CHANNEL_C_1_PORT_GPIO, CHANNEL_C_1_PIN_GPIO); Chip_SCU_PinMuxSet(CHANNEL_C_0_PORT, CHANNEL_C_0_PIN, halTimers[CHANNEL_C_TIMER_INDEX].gpioMode[0]); Chip_SCU_PinMuxSet(CHANNEL_C_1_PORT, CHANNEL_C_1_PIN, halTimers[CHANNEL_C_TIMER_INDEX].gpioMode[1]); for (int i = 0; i < 3; ++i) { for (int j = 0; j < 2; ++j) { Chip_TIMER_ResetOnMatchDisable(halTimers[i].timer, halTimers[i].timerChannel[j]); Chip_TIMER_StopOnMatchDisable(halTimers[i].timer, halTimers[i].timerChannel[j]); Chip_TIMER_MatchDisableInt(halTimers[i].timer, halTimers[i].timerChannel[j]); Chip_TIMER_ExtMatchControlSet(halTimers[i].timer, 1, TIMER_EXTMATCH_CLEAR, halTimers[i].timerChannel[j]); } } }