void App_Button_Init(void) { ButtonWaiting = 0; //Initialize the timer for the debouncing, but don't start it Chip_TIMER_Init(DEBOUNCE_TIMER); Chip_TIMER_Reset(DEBOUNCE_TIMER); DEBOUNCE_TIMER->PR = 100; DEBOUNCE_TIMER->MCR = (1<<1)|(1<<0); //Enable MR0 match interrupt, Reset TC on MR0 match DEBOUNCE_TIMER->MR[0]= 0xFFFF; //MR0 match value //Enable the IRQ for the timer NVIC_EnableIRQ(DEBOUNCE_TIMER_NVIC_NAME); //Set all button pins to GPIO input with pullup Chip_IOCON_PinMuxSet(LPC_IOCON, BUTTON_1_PORT, BUTTON_1_PIN, (IOCON_FUNC0 | IOCON_MODE_PULLUP)); Chip_IOCON_PinMuxSet(LPC_IOCON, BUTTON_2_PORT, BUTTON_2_PIN, (IOCON_FUNC0 | IOCON_MODE_PULLUP)); Chip_IOCON_PinMuxSet(LPC_IOCON, BUTTON_3_PORT, BUTTON_3_PIN, (IOCON_FUNC0 | IOCON_MODE_PULLUP)); Chip_IOCON_PinMuxSet(LPC_IOCON, BUTTON_4_PORT, BUTTON_4_PIN, (IOCON_FUNC0 | IOCON_MODE_PULLUP)); Chip_IOCON_PinMuxSet(LPC_IOCON, BUTTON_5_PORT, BUTTON_5_PIN, (IOCON_FUNC0 | IOCON_MODE_PULLUP)); Chip_GPIO_SetPinDIRInput(LPC_GPIO, BUTTON_1_PORT, BUTTON_1_PIN); Chip_GPIO_SetPinDIRInput(LPC_GPIO, BUTTON_2_PORT, BUTTON_2_PIN); Chip_GPIO_SetPinDIRInput(LPC_GPIO, BUTTON_3_PORT, BUTTON_3_PIN); Chip_GPIO_SetPinDIRInput(LPC_GPIO, BUTTON_4_PORT, BUTTON_4_PIN); Chip_GPIO_SetPinDIRInput(LPC_GPIO, BUTTON_5_PORT, BUTTON_5_PIN); //TODO: Probably put this in the main initalization... Chip_Clock_EnablePeriphClock(SYSCTL_CLOCK_PINT); //Setup GPIO interrupts for each button /* Configure interrupt channel for the GPIO pin in SysCon block */ Chip_SYSCTL_SetPinInterrupt(BUTTON_1_PININT_INDEX, BUTTON_1_PORT, BUTTON_1_PIN); Chip_SYSCTL_SetPinInterrupt(BUTTON_2_PININT_INDEX, BUTTON_2_PORT, BUTTON_2_PIN); Chip_SYSCTL_SetPinInterrupt(BUTTON_3_PININT_INDEX, BUTTON_3_PORT, BUTTON_3_PIN); Chip_SYSCTL_SetPinInterrupt(BUTTON_4_PININT_INDEX, BUTTON_4_PORT, BUTTON_4_PIN); Chip_SYSCTL_SetPinInterrupt(BUTTON_5_PININT_INDEX, BUTTON_5_PORT, BUTTON_5_PIN); /* Configure channel interrupt as edge sensitive and falling edge interrupt */ Chip_PININT_SetPinModeEdge(LPC_PININT, PININTCH(BUTTON_1_PININT_INDEX)); Chip_PININT_SetPinModeEdge(LPC_PININT, PININTCH(BUTTON_2_PININT_INDEX)); Chip_PININT_SetPinModeEdge(LPC_PININT, PININTCH(BUTTON_3_PININT_INDEX)); Chip_PININT_SetPinModeEdge(LPC_PININT, PININTCH(BUTTON_4_PININT_INDEX)); Chip_PININT_SetPinModeEdge(LPC_PININT, PININTCH(BUTTON_5_PININT_INDEX)); Chip_PININT_EnableIntLow(LPC_PININT, PININTCH(BUTTON_1_PININT_INDEX)); Chip_PININT_EnableIntLow(LPC_PININT, PININTCH(BUTTON_2_PININT_INDEX)); Chip_PININT_EnableIntLow(LPC_PININT, PININTCH(BUTTON_3_PININT_INDEX)); Chip_PININT_EnableIntLow(LPC_PININT, PININTCH(BUTTON_4_PININT_INDEX)); Chip_PININT_EnableIntLow(LPC_PININT, PININTCH(BUTTON_5_PININT_INDEX)); Chip_PININT_ClearIntStatus(LPC_PININT, ((1 << BUTTON_1_PININT_INDEX)|(1<<BUTTON_2_PININT_INDEX)|(1<<BUTTON_3_PININT_INDEX)|(1<<BUTTON_4_PININT_INDEX)|(1<<BUTTON_5_PININT_INDEX)) ); App_EnableButtons(); return; }
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; }
int main(void) { Dice noppa; uint32_t sysTickRate; #if defined (__USE_LPCOPEN) // Read clock settings and update SystemCoreClock variable SystemCoreClockUpdate(); #if !defined(NO_BOARD_LIB) // Set up and initialize all required blocks and // functions related to the board hardware Board_Init(); // Set the LED to the state of "On" Board_LED_Set(0, true); #endif #endif sysTickRate = Chip_Clock_GetSysTickClockRate(); // Määritellään nappi PB1 toimimaan inputtina Chip_IOCON_PinMuxSet(LPC_IOCON, 1, 0, (IOCON_MODE_PULLUP | IOCON_DIGMODE_EN | IOCON_INV_EN)); Chip_GPIO_SetPinDIRInput(LPC_GPIO, 1, 0); // Määritellään nappi PC0 toimimaan inputtina Chip_IOCON_PinMuxSet(LPC_IOCON, 0, 8, (IOCON_MODE_PULLUP | IOCON_DIGMODE_EN | IOCON_INV_EN)); Chip_GPIO_SetPinDIRInput(LPC_GPIO, 0, 8); /* Enable and setup SysTick Timer at a periodic rate */ SysTick_Config(sysTickRate / TICKRATE_HZ1); noppa.SetValue(0); while(1) { if (Chip_GPIO_GetPinState(LPC_GPIO, 1,0)) { noppa.SetValue(0); while(Chip_GPIO_GetPinState(LPC_GPIO, 1,0)) { } if(!Chip_GPIO_GetPinState(LPC_GPIO, 1,0)) { noppa.SetValue(calc); } } // Testinappi, kaikki ledit syttyy if (Chip_GPIO_GetPinState(LPC_GPIO, 0,8)) { while(Chip_GPIO_GetPinState(LPC_GPIO, 0,8)) { noppa.SetValue(7); } noppa.SetValue(0); } } return 0; }
/** * @brief GPIO initialization. */ void gpioInit(void) { //Chip_GPIO_Init(LPC_GPIO_PORT); Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 0, LCD_BACKLIGHT); Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, LCD_BACKLIGHT, 1); Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 0, RANGE_POWER_PIN); Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, RANGE_POWER_PIN, 0); Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 0, MoonLander_LED); Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, MoonLander_LED, 0); Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, 0, SW_LEFT); Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, 0, SW_RIGHT); }
/* Initialize buttons on the board */ void Board_Buttons_Init(void) { //enable pull-ups Chip_IOCON_PinMuxSet(LPC_IOCON, BUTTONS_ENCA_GPIO_PORT_NUM, BUTTONS_ENCA_GPIO_BIT_NUM, (IOCON_FUNC0 | IOCON_MODE_PULLUP | IOCON_DIGMODE_EN)); Chip_IOCON_PinMuxSet(LPC_IOCON, BUTTONS_ENCB_GPIO_PORT_NUM, BUTTONS_ENCB_GPIO_BIT_NUM, (IOCON_FUNC0 | IOCON_MODE_PULLUP | IOCON_DIGMODE_EN)); Chip_IOCON_PinMuxSet(LPC_IOCON, BUTTONS_ENCC_GPIO_PORT_NUM, BUTTONS_ENCC_GPIO_BIT_NUM, (IOCON_FUNC0 | IOCON_MODE_PULLUP | IOCON_DIGMODE_EN)); //set as input pins Chip_GPIO_SetPinDIRInput(LPC_GPIO, BUTTONS_ENCA_GPIO_PORT_NUM, BUTTONS_ENCA_GPIO_BIT_NUM); Chip_GPIO_SetPinDIRInput(LPC_GPIO, BUTTONS_ENCB_GPIO_PORT_NUM, BUTTONS_ENCB_GPIO_BIT_NUM); Chip_GPIO_SetPinDIRInput(LPC_GPIO, BUTTONS_ENCC_GPIO_PORT_NUM, BUTTONS_ENCC_GPIO_BIT_NUM); }
static void ADC_PinMuxSetup(void) { #if defined(BOARD_NXP_LPCXPRESSO_54102) /* Enable PININT1, which will trigger SEQ_B */ Chip_PININT_Init(LPC_PININT); Chip_IOCON_PinMuxSet(LPC_IOCON, 0, 24, IOCON_MODE_INACT | IOCON_FUNC0 | IOCON_DIGITAL_EN | IOCON_GPIO_MODE); Chip_GPIO_SetPinDIRInput(LPC_GPIO, 0, 24); LPC_INMUX->PINTSEL[PININTSELECT1] = 24; Chip_PININT_ClearIntStatus(LPC_PININT, PININTCH(PININTSELECT1)); Chip_PININT_SetPinModeEdge(LPC_PININT, PININTCH(PININTSELECT1)); Chip_PININT_EnableIntLow(LPC_PININT, PININTCH(PININTSELECT1)); NVIC_ClearPendingIRQ(PIN_INT1_IRQn); NVIC_EnableIRQ(PIN_INT1_IRQn); /* All pins to inactive, neither pull-up nor pull-down. */ Chip_IOCON_PinMuxSet(LPC_IOCON, 0, 29, IOCON_MODE_INACT | IOCON_FUNC1 | IOCON_ANALOG_EN); Chip_IOCON_PinMuxSet(LPC_IOCON, 0, 30, IOCON_MODE_INACT | IOCON_FUNC1 | IOCON_ANALOG_EN); Chip_IOCON_PinMuxSet(LPC_IOCON, 0, 31, IOCON_MODE_INACT | IOCON_FUNC1 | IOCON_ANALOG_EN); Chip_IOCON_PinMuxSet(LPC_IOCON, 1, 0, IOCON_MODE_INACT | IOCON_FUNC1 | IOCON_ANALOG_EN); Chip_IOCON_PinMuxSet(LPC_IOCON, 1, 1, IOCON_MODE_INACT | IOCON_FUNC1 | IOCON_ANALOG_EN); Chip_IOCON_PinMuxSet(LPC_IOCON, 1, 2, IOCON_MODE_INACT | IOCON_FUNC1 | IOCON_ANALOG_EN); Chip_IOCON_PinMuxSet(LPC_IOCON, 1, 3, IOCON_MODE_INACT | IOCON_FUNC1 | IOCON_ANALOG_EN); Chip_IOCON_PinMuxSet(LPC_IOCON, 1, 4, IOCON_MODE_INACT | IOCON_FUNC1 | IOCON_ANALOG_EN); Chip_IOCON_PinMuxSet(LPC_IOCON, 1, 5, IOCON_MODE_INACT | IOCON_FUNC1 | IOCON_ANALOG_EN); Chip_IOCON_PinMuxSet(LPC_IOCON, 1, 6, IOCON_MODE_INACT | IOCON_FUNC1 | IOCON_ANALOG_EN); Chip_IOCON_PinMuxSet(LPC_IOCON, 1, 7, IOCON_MODE_INACT | IOCON_FUNC1 | IOCON_ANALOG_EN); Chip_IOCON_PinMuxSet(LPC_IOCON, 1, 8, IOCON_MODE_INACT | IOCON_FUNC1 | IOCON_ANALOG_EN); #else #warning "No ADC setup for this example" #endif }
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; } }
/** * @brief Main program body * @return Does not return */ int main(void) { /* Generic Initialization */ SystemCoreClockUpdate(); /* Board_Init calls Chip_GPIO_Init and enables GPIO clock if needed, Chip_GPIO_Init is not called again */ Board_Init(); Board_LED_Set(0, false); /* Configure GPIO interrupt pin as input */ Chip_GPIO_SetPinDIRInput(LPC_GPIO, GPIO_INTERRUPT_PORT, GPIO_INTERRUPT_PIN); /* Configure the GPIO interrupt */ Chip_GPIOINT_SetIntFalling(LPC_GPIOINT, GPIO_INTERRUPT_PORT, 1 << GPIO_INTERRUPT_PIN); /* Enable interrupt in the NVIC */ NVIC_ClearPendingIRQ(GPIO_INTERRUPT_NVIC_NAME); NVIC_EnableIRQ(GPIO_INTERRUPT_NVIC_NAME); /* Wait for interrupts - LED will toggle on each wakeup event */ while (1) { __WFI(); } return 0; }
/* NXP_Quick_Jack io initilize detect the mic&gnd */ void QUICKJACK_IO_Init(void) { uint32_t MgAcmpOutVal; uint32_t i = 0; Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 0, MnGSWENAPINNUM); Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, MnGSWENAPINNUM, 1); Chip_IOCON_PinSetMode(LPC_IOCON, IOCON_PIO14, PIN_MODE_INACTIVE); Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, 0, 14); Chip_IOCON_PinSetMode(LPC_IOCON, MnGACMPOUTPIN, PIN_MODE_INACTIVE); Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, 0, MnGACMPOUTPINNUM); MgAcmpOutVal = Chip_GPIO_ReadPortBit(LPC_GPIO_PORT, 0, 6); for(i=0; i<5; i++) { /* waiting a while */ __NOP(); } while(MgAcmpOutVal!= Chip_GPIO_ReadPortBit(LPC_GPIO_PORT, 0, 6)) { for(i=0; i<5; i++) { /* waiting a while */ __NOP(); } MgAcmpOutVal = Chip_GPIO_ReadPortBit(LPC_GPIO_PORT, 0, 6); for(i=0; i<5; i++) { /* waiting a while */ __NOP(); } } /* configured analog switch selectable pin */ Chip_IOCON_PinSetMode(LPC_IOCON, MnGSWSELPIN, PIN_MODE_INACTIVE); Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 0, MnGSWSELPINNUM); if(MgAcmpOutVal==0) { Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, MnGSWSELPINNUM, 1); } else { Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, MnGSWSELPINNUM, 0); } /* enabled analog switch enabled pin */ Chip_IOCON_PinSetMode(LPC_IOCON, MnGSWENAPIN, PIN_MODE_INACTIVE); Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 0, MnGSWENAPINNUM); Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, MnGSWENAPINNUM, 0); }
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); }
/* Set GPIO direction for a single GPIO pin */ void Chip_GPIO_SetPinDIR(LPC_GPIO_T *pGPIO, uint8_t port, uint8_t pin, bool output) { if (output) { Chip_GPIO_SetPinDIROutput(pGPIO, port, pin); } else { Chip_GPIO_SetPinDIRInput(pGPIO, port, pin); } }
/* Initializes board Button(s) */ static void Board_BTN_Init(void) { pinmux_t buttons[] = { ONBOARD_BTNS }; Chip_GPIO_Init(LPC_GPIO_PORT); for (int i = 0; i < (sizeof(buttons)/sizeof(buttons[0])); i++) { Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, TO_PORT(buttons[i]), TO_PIN(buttons[i])); } }
/* Initialize Joystick */ void Board_Joystick_Init(void) { int i; /* IOCON states already selected in SystemInit(), GPIO setup only. Pullups are external, so IOCON with no states */ for (i = 0; i < NUM_BUTTONS; i++) { Chip_GPIO_SetPinDIRInput(LPC_GPIO, portButton[i], pinButton[i]); } }
void Earphone_Init(void) { Chip_IOCON_PinSetMode(LPC_IOCON, IOCON_PIO14, PIN_MODE_INACTIVE); Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, 0, 14); Chip_IOCON_PinSetMode(LPC_IOCON, QUICKJACKTXPIN, PIN_MODE_INACTIVE); Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 0, QUICKJACKTXPINNUM); Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, QUICKJACKTXPINNUM, 1); Chip_Clock_DisablePeriphClock(SYSCTL_CLOCK_SWM); Chip_Clock_DisablePeriphClock(SYSCTL_CLOCK_IOCON); }
static void gpio_init(void) { Chip_GPIO_Init(LPC_GPIO_PORT); // 0_4 -> Wake // 0_16 -> Misc Chip_Clock_EnablePeriphClock(SYSCTL_CLOCK_IOCON); Chip_IOCON_PinSetMode(LPC_IOCON, IOCON_PIO4, PIN_MODE_PULLUP); Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, 0, 4); }
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; }
/** * Methods */ void nRF24L01PInit(unsigned char transmitMode) { Chip_GPIO_SetPinOutHigh(LPC_GPIO, CSN_PORT, CSN_PIN); Chip_GPIO_SetPinDIROutput(LPC_GPIO, CSN_PORT, CSN_PIN); Chip_GPIO_SetPinOutLow(LPC_GPIO, NORDIC_CE_PORT, NORDIC_CE_PIN); Chip_GPIO_SetPinDIROutput(LPC_GPIO, NORDIC_CE_PORT, NORDIC_CE_PIN); Chip_GPIO_SetPinDIRInput(LPC_GPIO, NORDIC_IRQ_PORT, NORDIC_IRQ_PIN); nRF24L01P.mode = NRF24L01P_MODE_UNKNOWN; nRF24L01P.transmissionTimeout = -1; nRF24L01P.payloadsinTXFIFO = 0; RFdisable(); Chip_Clock_EnablePeriphClock(SYSCTL_CLOCK_SSP1); Chip_SSP_Set_Mode(LPC_SSP1, SSP_MODE_MASTER); Chip_SSP_SetFormat(LPC_SSP1, SSP_BITS_8, SSP_FRAMEFORMAT_SPI, SSP_CLOCK_CPHA0_CPOL0); // 8-bit, ClockPhase = 0, ClockPolarity = 0 Chip_SSP_SetBitRate(LPC_SSP1, NRF24L01P_SPI_MAX_DATA_RATE / 2); // 2Mbit, 1/5th the maximum transfer rate for the SPI bus Chip_SSP_Enable(LPC_SSP1); RingBuffer_Init(&nordicTxBuffer, nordictxBufferArray, 1, TX_BUFFER_SIZE); memset(&spi, 0, sizeof(spi)); spi.tx_data = spiBufferTx; spi.rx_data = spiBufferRx; timerDelayUs(NRF24L01P_TIMING_Tundef2pd_us); // Wait for Power-on reset RFsetRegister(NRF24L01P_REG_CONFIG, 0); // Power Down RFsetRegister(NRF24L01P_REG_STATUS, NRF24L01P_STATUS_MAX_RT | NRF24L01P_STATUS_TX_DS | NRF24L01P_STATUS_RX_DR); // Clear any pending interrupts RFsetRegister(NRF24L01P_REG_FEATURE, NRF24L01P_EN_DYN_ACK | NRF24L01P_EN_ACK_PAY | NRF24L01P_EN_DPL); //Enabled no ack packages RFsetRegister(NRF24L01P_REG_DYNPD, NRF24L01P_DPL_P0); RFsetRegister(NRF24L01P_REG_RF_SETUP, 0); // Clear this register // // Setup default configuration // RFdisableAllRxPipes(); RFsetFrequency(DEFAULTNRF24L01P_RF_FREQUENCY); RFsetAirDataRate(DEFAULTNRF24L01P_DATARATE); RFsetRfOutputPower(DEFAULTNRF24L01P_TX_PWR); RFsetCrcWidth(DEFAULTNRF24L01P_CRC); RFsetTxAddress(DEFAULTNRF24L01P_ADDRESS, DEFAULTNRF24L01P_ADDRESS_WIDTH); RFsetRxAddress(DEFAULTNRF24L01P_ADDRESS, DEFAULTNRF24L01P_ADDRESS_WIDTH, NRF24L01P_PIPE_P0); RFenableAutoRetransmit(250, 3); RFdisableAutoAcknowledge(); RFenableAutoAcknowledge(NRF24L01P_PIPE_P0); RFsetTransferSize(DEFAULTNRF24L01P_TRANSFER_SIZE, NRF24L01P_PIPE_P0); nRF24L01P.mode = NRF24L01P_MODE_POWER_DOWN; if (transmitMode) { RFsetTransmitMode(); } else { RFsetReceiveMode(); } RFenable(); }
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); }
/* Set up and initialize all required blocks and functions related to the board hardware */ void Board_Init(void) { QUICKJACK_IO_Init(); /* Initialize GPIO */ Chip_GPIO_Init(LPC_GPIO_PORT); /* Initialize the LEDs */ Board_LED_Init(); // init sensor switch SensorSwitch_Init(); /* Configure GPIO pin as input pin */ Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, 0, 0); /* MCU Tx Pin initialize */ Chip_IOCON_PinSetMode(LPC_IOCON, QUICKJACKTXPIN, PIN_MODE_INACTIVE); Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 0, QUICKJACKTXPINNUM); Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, QUICKJACKTXPINNUM, 1); /* MCU Rx Pin initialize */ Chip_IOCON_PinSetMode(LPC_IOCON, QUICKJACKRXPIN, PIN_MODE_INACTIVE); /* Configure analog comparator for Manchester Rx */ Chip_SWM_FixedPinEnable(SWM_FIXED_ACMP_I1, 1); Chip_ACMP_Init(LPC_CMP); Chip_ACMP_SetPosVoltRef(LPC_CMP, ACMP_POSIN_ACMP_I1); Chip_ACMP_SetNegVoltRef(LPC_CMP, ACMP_NEGIN_VLO); Chip_ACMP_SetupVoltLadder(LPC_CMP, (15<<1), false); Chip_ACMP_EnableVoltLadder(LPC_CMP); Chip_ACMP_SetHysteresis(LPC_CMP, ACMP_HYS_10MV); Chip_ACMP_SetEdgeSelection(LPC_CMP, ACMP_EDGESEL_RISING); /* Uncomment below 2 lines to connect analog comparator output to P1_0 (not needed for normal operation) */ // Chip_SWM_FixedPinEnable(SWM_FIXED_ACMP_I2, 0); // Chip_SWM_MovablePinAssign(SWM_ACMP_O_O, 1); Chip_ACMP_EdgeClear(LPC_CMP); NVIC_EnableIRQ(CMP_IRQn); /* Disable clocks to SWM and IOCON to save power */ Chip_Clock_DisablePeriphClock(SYSCTL_CLOCK_SWM); Chip_Clock_DisablePeriphClock(SYSCTL_CLOCK_IOCON); }
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; }
static void flash_spi_pinmux_init(void) { /* Connect the SPI1 signals to port pins */ Chip_IOCON_PinMuxSet(LPC_IOCON, 0, 6 , (IOCON_FUNC0 | IOCON_MODE_PULLUP | IOCON_DIGITAL_EN)); /* SPI1_SCK */ Chip_IOCON_PinMuxSet(LPC_IOCON, 1, 16, (IOCON_FUNC0 | IOCON_MODE_INACT | IOCON_DIGITAL_EN)); /* SPI1_MISO */ Chip_IOCON_PinMuxSet(LPC_IOCON, 0, 7 , (IOCON_FUNC0 | IOCON_MODE_PULLUP | IOCON_DIGITAL_EN)); /* SPI1_MOSI */ Chip_IOCON_PinMuxSet(LPC_IOCON, 0, 8 , (IOCON_FUNC0 | IOCON_MODE_PULLUP | IOCON_DIGITAL_EN)); /* SPI1_SSEL0 */ // Chip_IOCON_PinMuxSet(LPC_IOCON, 1, 15, (IOCON_FUNC0 | IOCON_MODE_PULLUP | IOCON_DIGITAL_EN)); // Chip_GPIO_SetPinDIROutput(LPC_GPIO, 1, 15); // Chip_GPIO_SetPinState(LPC_GPIO, 1, 15, 1); Chip_GPIO_SetPinDIROutput(LPC_GPIO, 0, 6); Chip_GPIO_SetPinState(LPC_GPIO, 0, 6, 0); /* SPI1_SCK */ Chip_GPIO_SetPinDIRInput(LPC_GPIO, 1, 16); /* SPI1_MISO */ Chip_GPIO_SetPinState(LPC_GPIO, 1, 16, 0); Chip_GPIO_SetPinDIROutput(LPC_GPIO, 0, 7); /* SPI1_MOSI */ Chip_GPIO_SetPinState(LPC_GPIO, 0, 7, 1); Chip_GPIO_SetPinDIROutput(LPC_GPIO, 0, 8);/* SPI1_SSEL0 */ Chip_GPIO_SetPinState(LPC_GPIO, 0, 8, 1); }
/* * Wind Speed translation : V = p*(2,25/t) * V: speed in mph * p: pulses per sampelperiod * t: sample period in sec */ void setupirq(){ DBG("Initialize Wind Cups...\n"); Chip_GPIOINT_Init(LPC_GPIOINT); Chip_GPIO_SetPinDIRInput(LPC_GPIO,2,13); Chip_GPIO_SetPinState(LPC_GPIO, 2, 13, true); Chip_IOCON_PinMux(LPC_IOCON, 2, 13, IOCON_MODE_PULLUP, IOCON_FUNC0); const uint32_t prescaleDivisor = 8; Chip_TIMER_Init(LPC_TIMER2); Chip_TIMER_PrescaleSet(LPC_TIMER2, prescaleDivisor - 1); Chip_TIMER_Enable(LPC_TIMER2); ticksPerSecond = Chip_Clock_GetSystemClockRate() / prescaleDivisor / 4; Chip_GPIOINT_SetIntFalling(LPC_GPIOINT, GPIOINT_PORT2, (1 << 13)); Chip_GPIOINT_ClearIntStatus(LPC_GPIOINT, GPIOINT_PORT2, (1 << 13)); NVIC_ClearPendingIRQ(EINT3_IRQn); NVIC_EnableIRQ(EINT3_IRQn); DBG("Initialize Wind Cups complete...\n"); }
void Board_Buttons_Init(void) { Chip_SCU_PinMuxSet(BUTTONS_BUTTON1_PIN_PORT_NUM, BUTTONS_BUTTON1_PIN_BIT_NUM, (SCU_MODE_PULLUP | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | BUTTONS_BUTTON1_MODE_FUNC)); Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, BUTTONS_BUTTON1_GPIO_PORT_NUM, (1 << BUTTONS_BUTTON1_GPIO_BIT_NUM)); // input }
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 }
/** * @brief Main program body * @return Does not return */ int main(void) { /* Generic Initialization */ SystemCoreClockUpdate(); /* Board_Init calls Chip_GPIO_Init and enables GPIO clock if needed, Chip_GPIO_Init is not called again */ Board_Init(); Board_LED_Set(0, false); Chip_PININT_Init(LPC_PININT); /* Configure GPIO pin as input */ Chip_GPIO_SetPinDIRInput(LPC_GPIO, GPIO_PININT_PORT, GPIO_PININT_PIN); /* Configure pin as GPIO */ Chip_IOCON_PinMuxSet(LPC_IOCON, GPIO_PININT_PORT, GPIO_PININT_PIN, (IOCON_FUNC0 | IOCON_DIGITAL_EN | IOCON_GPIO_MODE)); /* Configure pin interrupt selection for the GPIO pin in Input Mux Block */ Chip_INMUX_PinIntSel(GPIO_PININT_INDEX, GPIO_PININT_PORT, GPIO_PININT_PIN); /* Configure channel interrupt as edge sensitive and falling edge interrupt */ Chip_PININT_ClearIntStatus(LPC_PININT, PININTCH(GPIO_PININT_INDEX)); Chip_PININT_SetPinModeEdge(LPC_PININT, PININTCH(GPIO_PININT_INDEX)); Chip_PININT_EnableIntLow(LPC_PININT, PININTCH(GPIO_PININT_INDEX)); /* Enable interrupt in the NVIC */ NVIC_EnableIRQ(PININT_NVIC_NAME); /* Enable wakeup for PININT0 */ Chip_SYSCON_EnableWakeup(SYSCON_STARTER_PINT0); /* save the clock source, power down the PLL */ saved_clksrc = Chip_Clock_GetMainClockSource(); /* Go to sleep mode - LED will toggle on each wakeup event */ while (1) { /* Go to sleep state - will wake up automatically on interrupt */ /* Disable PLL, if previously enabled, prior to sleep */ if (saved_clksrc == SYSCON_MAINCLKSRC_PLLOUT) { Chip_Clock_SetMainClockSource(SYSCON_MAINCLKSRC_IRC); Chip_SYSCON_PowerDown(SYSCON_PDRUNCFG_PD_SYS_PLL); } /* Lower system voltages to current lock (likely IRC) */ Chip_POWER_SetVoltage(POWER_LOW_POWER_MODE, Chip_Clock_GetMainClockRate()); /* Go to sleep leaving SRAM powered during sleep. Use lower voltage during sleep. */ Chip_POWER_EnterPowerMode(PDOWNMODE, (SYSCON_PDRUNCFG_PD_SRAM0A | SYSCON_PDRUNCFG_PD_SRAM0B)); /* On wakeup, restore PLL power if needed */ if (saved_clksrc == SYSCON_MAINCLKSRC_PLLOUT) { Chip_SYSCON_PowerUp(SYSCON_PDRUNCFG_PD_SYS_PLL); /* Wait for PLL lock */ while (!Chip_Clock_IsSystemPLLLocked()) {} Chip_POWER_SetVoltage(POWER_LOW_POWER_MODE, Chip_Clock_GetSystemPLLOutClockRate(false)); /* Use PLL for system clock */ Chip_Clock_SetMainClockSource(SYSCON_MAINCLKSRC_PLLOUT); } } return 0; }
uint8_t __attribute__ ((noinline)) i2c_read_sda(void) { Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, 0, 0); return Chip_GPIO_ReadPortBit(LPC_GPIO_PORT, 0, 0); }
void Board_Attach_Interrupt(uint32_t ulPin, void (*callback)(void), uint32_t mode) { uint8_t port = 1; uint8_t pin = 24; uint8_t pinIntChannel = 0; LPC1347_IRQn_Type pinIntIRQ = PIN_INT0_IRQn; port = APIN_PORT(ulPin); pin = APIN_PIN(ulPin); pinIntChannel = APIN_INT(ulPin); if(pinIntChannel == EXT_INT_0) { pinIntIRQ = PIN_INT0_IRQn; callbackPinIntA = callback; } else if(pinIntChannel == EXT_INT_1) { pinIntIRQ = PIN_INT1_IRQn; callbackPinIntB = callback; } else if(pinIntChannel == EXT_INT_2) { pinIntIRQ = PIN_INT2_IRQn; callbackPinIntC = callback; } else if(pinIntChannel == EXT_INT_3) { pinIntIRQ = PIN_INT3_IRQn; callbackPinIntD = callback; } /* Configure GPIO pin as input */ Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, port, pin); /* Configure pin as GPIO with pulldown */ // All digital pins are selected such that GPIO is on IOCON_FUNC0 Chip_IOCON_PinMuxSet(LPC_IOCON, port, pin, (IOCON_FUNC0 | IOCON_MODE_PULLDOWN)); /* Enable PININT clock */ Chip_Clock_EnablePeriphClock(SYSCTL_CLOCK_PINT); /* Configure interrupt channel for the GPIO pin in SysCon block */ Chip_SYSCTL_SetPinInterrupt(pinIntChannel, port, pin); /* Configure channel interrupt as edge sensitive and falling edge interrupt */ Chip_PININT_ClearIntStatus(LPC_PININT, PININTCH(pinIntChannel)); if(mode == HIGH) { Chip_PININT_SetPinModeLevel(LPC_PININT, PININTCH(pinIntChannel)); Chip_PININT_EnableIntHigh(LPC_PININT, PININTCH(pinIntChannel)); } else if(mode == LOW) { Chip_PININT_SetPinModeLevel(LPC_PININT, PININTCH(pinIntChannel)); Chip_PININT_EnableIntLow(LPC_PININT, PININTCH(pinIntChannel)); } else if(mode == RISING) { Chip_PININT_SetPinModeEdge(LPC_PININT, PININTCH(pinIntChannel)); Chip_PININT_EnableIntHigh(LPC_PININT, PININTCH(pinIntChannel)); } else if(mode == FALLING) { Chip_PININT_SetPinModeEdge(LPC_PININT, PININTCH(pinIntChannel)); Chip_PININT_EnableIntLow(LPC_PININT, PININTCH(pinIntChannel)); } else if(mode == CHANGE) { Chip_PININT_SetPinModeEdge(LPC_PININT, PININTCH(pinIntChannel)); Chip_PININT_EnableIntHigh(LPC_PININT, PININTCH(pinIntChannel)); Chip_PININT_EnableIntLow(LPC_PININT, PININTCH(pinIntChannel)); } /* Enable interrupt in the NVIC */ NVIC_ClearPendingIRQ(pinIntIRQ); NVIC_EnableIRQ(pinIntIRQ); }
/** * @brief Set GPIO direction for a single GPIO pin to an input */ void GPIO_setAsInput(uint8_t port, uint8_t pin) { Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT,port,pin); }
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]); } } }
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; }