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