/*! * @brief Main function */ void test_audio(void) { if(!yesno("Audio?")) return; const gpio_pin_config_t OUTFALSE = {kGPIO_DigitalOutput, 0}; CLOCK_EnableClock(kCLOCK_PortC); PORT_SetPinMux(PORTC, 12U, kPORT_MuxAsGpio); PORT_SetPinMux(PORTC, 13U, kPORT_MuxAsGpio); GPIO_PinInit(GPIOC, 12U, &OUTFALSE); GPIO_PinInit(GPIOC, 13U, &OUTFALSE); GPIO_WritePinOutput(GPIOC, 12, true); GPIO_WritePinOutput(GPIOC, 13, true); i2c_init(&i2c_config_default); uint8_t cmd[1] = {0b00001111}; send_cmd(cmd, sizeof(cmd)); GPIO_WritePinOutput(GPIOC, 12, false); PORT_SetPinMux(PORTC, 9U, kPORT_MuxAlt3); ftm_config_t ftmInfo; uint8_t updatedDutycycle = 100U; ftm_chnl_pwm_signal_param_t ftmParam[2]; /* Configure ftm params with frequency 24kHZ */ ftmParam[0].chnlNumber = (ftm_chnl_t) BOARD_SECOND_FTM_CHANNEL; ftmParam[0].level = kFTM_LowTrue; ftmParam[0].dutyCyclePercent = 0U; ftmParam[0].firstEdgeDelayPercent = 0U; FTM_GetDefaultConfig(&ftmInfo); FTM_Init(BOARD_FTM_BASEADDR, &ftmInfo); FTM_SetupPwm(BOARD_FTM_BASEADDR, ftmParam, 1U, kFTM_EdgeAlignedPwm, 1000000, FTM_SOURCE_CLOCK); FTM_StartTimer(BOARD_FTM_BASEADDR, kFTM_SystemClock); FTM_UpdatePwmDutycycle(BOARD_FTM_BASEADDR, (ftm_chnl_t) BOARD_SECOND_FTM_CHANNEL, kFTM_EdgeAlignedPwm, updatedDutycycle); int idx = 0; int cnt = 0; while (1) { if(cnt++ % 100 == 0) { uint8_t duty_cycle = (uint8_t) abs((sin(idx++ * 3.14159265358979f / 180) * 100.0)); if (idx > 360) idx = 0; FTM_UpdatePwmDutycycle(BOARD_FTM_BASEADDR, (ftm_chnl_t) BOARD_SECOND_FTM_CHANNEL, kFTM_EdgeAlignedPwm, (uint8_t) (duty_cycle++ % 100)); /* Software trigger to update registers */ FTM_SetSoftwareTrigger(BOARD_FTM_BASEADDR, true); } } }
void initMAX31855() { GPIO_PinInit(p_clk, GPIO_PinOutput); GPIO_PinInit(p_cs, GPIO_PinOutput); GPIO_PinInit(p_miso, GPIO_PinInput); GPIO_PinClear(p_clk); GPIO_PinSet(p_cs); }
static int mcux_igpio_configure(struct device *dev, int access_op, u32_t pin, int flags) { const struct mcux_igpio_config *config = dev->config->config_info; gpio_pin_config_t pin_config; u32_t i; /* Check for an invalid pin configuration */ if ((flags & GPIO_INT) && (flags & GPIO_DIR_OUT)) { return -EINVAL; } pin_config.direction = ((flags & GPIO_DIR_MASK) == GPIO_DIR_IN) ? kGPIO_DigitalInput : kGPIO_DigitalOutput; pin_config.outputLogic = 0; if (flags & GPIO_INT) { if (flags & GPIO_INT_EDGE) { if (flags & GPIO_INT_ACTIVE_HIGH) { pin_config.interruptMode = kGPIO_IntRisingEdge; } else if (flags & GPIO_INT_DOUBLE_EDGE) { pin_config.interruptMode = kGPIO_IntRisingOrFallingEdge; } else { pin_config.interruptMode = kGPIO_IntFallingEdge; } } else { /* GPIO_INT_LEVEL */ if (flags & GPIO_INT_ACTIVE_HIGH) { pin_config.interruptMode = kGPIO_IntHighLevel; } else { pin_config.interruptMode = kGPIO_IntLowLevel; } } } else { pin_config.interruptMode = kGPIO_NoIntmode; } if (access_op == GPIO_ACCESS_BY_PIN) { GPIO_PinInit(config->base, pin, &pin_config); } else { /* GPIO_ACCESS_BY_PORT */ for (i = 0U; i < 32; i++) { GPIO_PinInit(config->base, i, &pin_config); } } return 0; }
void modem_init() { const gpio_pin_config_t OUTTRUE = {kGPIO_DigitalOutput, true}; const gpio_pin_config_t IN = {kGPIO_DigitalInput, false}; // initialize BOARD_CELL pins CLOCK_EnableClock(BOARD_CELL_UART_PORT_CLOCK); PORT_SetPinMux(BOARD_CELL_UART_PORT, BOARD_CELL_UART_TX_PIN, BOARD_CELL_UART_TX_ALT); PORT_SetPinMux(BOARD_CELL_UART_PORT, BOARD_CELL_UART_RX_PIN, BOARD_CELL_UART_RX_ALT); CLOCK_EnableClock(BOARD_CELL_PIN_PORT_CLOCK); PORT_SetPinMux(BOARD_CELL_PIN_PORT, BOARD_CELL_STATUS_PIN, kPORT_MuxAsGpio); GPIO_PinInit(BOARD_CELL_PIN_GPIO, BOARD_CELL_STATUS_PIN, &IN); #if BOARD_CELL_RESET_PIN PORT_SetPinMux(BOARD_CELL_PIN_PORT, BOARD_CELL_RESET_PIN, kPORT_MuxAsGpio); GPIO_PinInit(BOARD_CELL_PIN_GPIO, BOARD_CELL_RESET_PIN, &OUTTRUE); #endif PORT_SetPinMux(BOARD_CELL_PIN_PORT, BOARD_CELL_PWRKEY_PIN, kPORT_MuxAsGpio); GPIO_PinInit(BOARD_CELL_PIN_GPIO, BOARD_CELL_PWRKEY_PIN, &OUTTRUE); // the ring identifier is optional, only use if a pin and port exists #if BOARD_CELL_RI_PIN PORT_SetPinMux(BOARD_CELL_PIN_PORT, BOARD_CELL_RI_PIN, kPORT_MuxAsGpio); GPIO_PinInit(BOARD_CELL_PIN_GPIO, BOARD_CELL_RI_PIN, &IN); #endif #if BOARD_CELL_PWR_DOMAIN const gpio_pin_config_t OUTFALSE = {kGPIO_DigitalOutput, false}; CLOCK_EnableClock(BOARD_CELL_PWR_EN_CLOCK); PORT_SetPinMux(BOARD_CELL_PWR_EN_PORT, BOARD_CELL_PWR_EN_PIN, kPORT_MuxAsGpio); GPIO_PinInit(BOARD_CELL_PWR_EN_GPIO, BOARD_CELL_PWR_EN_PIN, &OUTFALSE); #endif // configure uart driver connected to the SIM800H lpuart_config_t lpuart_config; LPUART_GetDefaultConfig(&lpuart_config); lpuart_config.baudRate_Bps = 115200; lpuart_config.parityMode = kLPUART_ParityDisabled; lpuart_config.stopBitCount = kLPUART_OneStopBit; LPUART_Init(BOARD_CELL_UART, &lpuart_config, BOARD_CELL_PORT_CLOCK_FREQ); LPUART_EnableRx(BOARD_CELL_UART, true); LPUART_EnableTx(BOARD_CELL_UART, true); LPUART_EnableInterrupts(BOARD_CELL_UART, kLPUART_RxDataRegFullInterruptEnable); EnableIRQ(BOARD_CELL_UART_IRQ); }
static void _touch(void *p) { int io_s; gpio_pin_config_t pin_config = { kGPIO_DigitalInput, 0, }; CLOCK_EnableClock(kCLOCK_Gpio4); /* Enable touch panel controller */ GPIO_PinInit(GPIO, 4, 0, &pin_config); while(1) { rt_thread_delay(RT_TICK_PER_SECOND / 60); io_s = GPIO_ReadPinInput(GPIO, 4, 0); if (io_s == 0) { _touch_session(); } else continue; } }
int main(void) { gpio_pin_config_t config; BOARD_InitPins(); BOARD_BootClockHSRUN(); BOARD_InitDebugConsole(); /* Enable USB Host VBUS */ config.outputLogic = 1; config.pinDirection = kGPIO_DigitalOutput; GPIO_PinInit(GPIOC, 9, &config); APP_init(); while (1) { #if ((defined USB_HOST_CONFIG_KHCI) && (USB_HOST_CONFIG_KHCI)) USB_HostKhciTaskFunction(g_hostHandle); #endif #if ((defined USB_HOST_CONFIG_EHCI) && (USB_HOST_CONFIG_EHCI)) USB_HostEhciTaskFunction(g_hostHandle); #endif USB_HosCdcTask(&g_cdc); } }
void LedDriver_InitAllLeds(char isEnabled) { CLOCK_EnableClock(LED_DRIVER_SDB_CLOCK); PORT_SetPinMux(LED_DRIVER_SDB_PORT, LED_DRIVER_SDB_PIN, kPORT_MuxAsGpio); GPIO_PinInit(GPIOA, LED_DRIVER_SDB_PIN, &(gpio_pin_config_t){kGPIO_DigitalOutput, 0}); GPIO_WritePinOutput(LED_DRIVER_SDB_GPIO, LED_DRIVER_SDB_PIN, 1); uint8_t ledDriverAddresses[] = {I2C_ADDRESS_LED_DRIVER_LEFT, I2C_ADDRESS_LED_DRIVER_RIGHT}; for (uint8_t addressId=0; addressId<sizeof(ledDriverAddresses); addressId++) { uint8_t address = ledDriverAddresses[addressId]; LedDriver_WriteRegister(address, LED_DRIVER_REGISTER_FRAME, LED_DRIVER_FRAME_FUNCTION); LedDriver_WriteRegister(address, LED_DRIVER_REGISTER_SHUTDOWN, SHUTDOWN_MODE_NORMAL); LedDriver_WriteRegister(address, LED_DRIVER_REGISTER_FRAME, LED_DRIVER_FRAME_1); uint8_t i; for (i=FRAME_REGISTER_PWM_FIRST; i<=FRAME_REGISTER_PWM_LAST; i++) { LedDriver_WriteRegister(address, i, isEnabled ? 0xFF : 0x00); } for (i=FRAME_REGISTER_LED_CONTROL_FIRST; i<=FRAME_REGISTER_LED_CONTROL_LAST; i++) { LedDriver_WriteRegister(address, i, 0xff); } for (i=FRAME_REGISTER_BLINK_CONTROL_FIRST; i<=FRAME_REGISTER_BLINK_CONTROL_LAST; i++) { LedDriver_WriteRegister(address, i, 0x00); } } }
int main(void) { BOARD_InitPins(); BOARD_BootClockRUN(); BOARD_InitDebugConsole(); GPIO_PinInit(BOARD_LED_RED_GPIO, BOARD_LED_RED_GPIO_PIN, \ &(gpio_pin_config_t){kGPIO_DigitalOutput, 0u}); GPIO_PinInit(BOARD_LED_GREEN_GPIO, BOARD_LED_GREEN_GPIO_PIN, \ &(gpio_pin_config_t){kGPIO_DigitalOutput, 0u}); GPIO_PinInit(BOARD_LED_BLUE_GPIO, BOARD_LED_BLUE_GPIO_PIN, \ &(gpio_pin_config_t){kGPIO_DigitalOutput, 0u}); GPIO_SetPinsOutput(BOARD_LED_RED_GPIO, 1u << BOARD_LED_RED_GPIO_PIN); GPIO_SetPinsOutput(BOARD_LED_GREEN_GPIO, 1u << BOARD_LED_GREEN_GPIO_PIN); GPIO_SetPinsOutput(BOARD_LED_BLUE_GPIO, 1u << BOARD_LED_BLUE_GPIO_PIN); for(;;) { GPIO_TogglePinsOutput(BOARD_LED_BLUE_GPIO, 1u << BOARD_LED_BLUE_GPIO_PIN); delay(); } }
/*! * @brief Main function */ int main(void) { /* Define the init structure for the input switch pin */ gpio_pin_config_t sw_config = { kGPIO_DigitalInput, 0, }; /* Define the init structure for the output LED pin */ gpio_pin_config_t led_config = { kGPIO_DigitalOutput, 0, }; BOARD_InitPins(); BOARD_BootClockRUN(); BOARD_InitDebugConsole(); /* Print a note to terminal. */ PRINTF("\r\n GPIO Driver example\r\n"); PRINTF("\r\n Press %s to turn on/off a LED \r\n", BOARD_SW_NAME); /* Init input switch GPIO. */ PORT_SetPinInterruptConfig(BOARD_SW_PORT, BOARD_SW_GPIO_PIN, kPORT_InterruptFallingEdge); EnableIRQ(BOARD_SW_IRQ); GPIO_PinInit(BOARD_SW_GPIO, BOARD_SW_GPIO_PIN, &sw_config); /* Init output LED GPIO. */ GPIO_PinInit(BOARD_LED_GPIO, BOARD_LED_GPIO_PIN, &led_config); while (1) { if (g_ButtonPress) { PRINTF(" %s is pressed \r\n", BOARD_SW_NAME); /* Reset state of button. */ g_ButtonPress = false; } } }
static Status tml_Init(void) { i2c_master_config_t masterConfig; uint32_t sourceClock; gpio_pin_config_t irq_config = {kGPIO_DigitalInput, 0,}; gpio_pin_config_t ven_config = {kGPIO_DigitalOutput, 0,}; GPIO_PinInit(NXPNCI_IRQ_GPIO, NXPNCI_IRQ_PIN, &irq_config); GPIO_PinInit(NXPNCI_VEN_GPIO, NXPNCI_VEN_PIN, &ven_config); I2C_MasterGetDefaultConfig(&masterConfig); masterConfig.baudRate_Bps = NXPNCI_I2C_BAUDRATE; sourceClock = CLOCK_GetFreq(I2C0_CLK_SRC); masterXfer.slaveAddress = NXPNCI_I2C_ADDR_7BIT; masterXfer.subaddress = 0; masterXfer.subaddressSize = 0; masterXfer.flags = kI2C_TransferDefaultFlag; I2C_MasterInit(NXPNCI_I2C_INSTANCE, &masterConfig, sourceClock); IrqSem = xSemaphoreCreateBinary(); return SUCCESS; }
int hal_gpio_init_out(int pin, int val) { gpio_pin_config_t gconfig; port_pin_config_t pconfig; gconfig.pinDirection = kGPIO_DigitalOutput; pconfig.mux = kPORT_MuxAsGpio; CLOCK_EnableClock(s_portClocks[GPIO_PORT(pin)]); PORT_SetPinConfig(s_portBases[GPIO_PORT(pin)], GPIO_INDEX(pin), &pconfig); GPIO_PinInit(s_gpioBases[GPIO_PORT(pin)], GPIO_INDEX(pin), &gconfig); return 0; }
int hal_gpio_init_in(int pin, hal_gpio_pull_t pull) { gpio_pin_config_t gconfig; port_pin_config_t pconfig; gconfig.pinDirection = kGPIO_DigitalInput; pconfig.pullSelect = hal_to_fsl_pull(pull); pconfig.mux = kPORT_MuxAsGpio; CLOCK_EnableClock(s_portClocks[GPIO_PORT(pin)]); PORT_SetPinConfig(s_portBases[GPIO_PORT(pin)], GPIO_INDEX(pin), &pconfig); GPIO_PinInit(s_gpioBases[GPIO_PORT(pin)], GPIO_INDEX(pin), &gconfig); return 0; }
int ft5406_hw_init(void) { rt_thread_t tid; rt_device_t dev; dev = rt_device_find(I2CBUS_NAME); if (!dev) return -1; if (rt_device_open(dev, RT_DEVICE_OFLAG_RDWR) != RT_EOK) return -1; FTDEBUG("ft5406 set i2c bus to %s\n", I2CBUS_NAME); _i2c_bus = (struct rt_i2c_bus_device *)dev; { gpio_pin_config_t pin_config = { kGPIO_DigitalOutput, 0, }; CLOCK_EnableClock(kCLOCK_Gpio2); /* Enable touch panel controller */ GPIO_PinInit(GPIO, 2, 27, &pin_config); GPIO_WritePinOutput(GPIO, 2, 27, 1); rt_thread_delay(50); GPIO_WritePinOutput(GPIO, 2, 27, 0); rt_thread_delay(50); GPIO_WritePinOutput(GPIO, 2, 27, 1); } rt_sem_init(&_tp_sem, "touch", 0, RT_IPC_FLAG_FIFO); tid = rt_thread_create("touch", _touch, RT_NULL, 2048, 10, 20); if (!tid) { rt_device_close(dev); return -1; } rt_thread_startup(tid); return 0; }
void init_sdhc_pins() { port_pin_config_t config = {0}; config.pullSelect = kPORT_PullUp; config.driveStrength = kPORT_HighDriveStrength; config.mux = kPORT_MuxAlt4; CLOCK_EnableClock(kCLOCK_PortE); // SD pins PORT_SetPinConfig(PORTE, 0U, &config); PORT_SetPinConfig(PORTE, 1U, &config); PORT_SetPinConfig(PORTE, 2U, &config); PORT_SetPinConfig(PORTE, 3U, &config); PORT_SetPinConfig(PORTE, 4U, &config); PORT_SetPinConfig(PORTE, 5U, &config); // SD CD pin config.driveStrength = kPORT_LowDriveStrength; config.mux = kPORT_MuxAsGpio; PORT_SetPinConfig(PORTE, 7U, &config); const gpio_pin_config_t IN = {kGPIO_DigitalInput, false}; GPIO_PinInit(GPIOE, 7U, &IN); }
int main(void) { /* Init board hardware. */ BOARD_InitPins(); BOARD_BootClockRUN(); BOARD_InitDebugConsole(); for(uint8_t i = 0; i < NUM_LEDS; i++) { leds[i].r = 0; leds[i].g = 0; leds[i].b = 0; } struct FLEXIO_WS2812_LED led; led.r = 0; led.g = 0; led.b = 0; /* Init and enable FlexIO */ CLOCK_EnableClock(kCLOCK_Flexio0); flexio_config_t user_config = { .enableFlexio = true, .enableInDoze = false, .enableInDebug = false, .enableFastAccess = false }; FLEXIO_Init(FLEXIO0, &user_config); FLEXIO_Enable(FLEXIO0, true); FLEXIO_WS2812_Init(); /* Init GPIOs */ gpio_pin_config_t config = { kGPIO_DigitalOutput, 0, }; GPIO_PinInit(GPIOA, 5U, &config); GPIO_WritePinOutput(GPIOA, 5U, 0U); GPIO_PinInit(GPIOA, 13U, &config); GPIO_WritePinOutput(GPIOA, 13U, 0U); GPIO_PinInit(GPIOA, 12U, &config); GPIO_WritePinOutput(GPIOA, 12U, 0U); GPIO_PinInit(GPIOA, 17U, &config); GPIO_WritePinOutput(GPIOA, 17U, 0U); GPIO_PinInit(GPIOA, 14U, &config); GPIO_WritePinOutput(GPIOA, 14U, 0U); GPIO_PinInit(GPIOC, 7U, &config); GPIO_WritePinOutput(GPIOC, 7U, 0U); GPIO_PinInit(GPIOA, 16U, &config); GPIO_WritePinOutput(GPIOA, 16U, 0U); GPIO_PinInit(GPIOA, 15U, &config); GPIO_WritePinOutput(GPIOA, 15U, 0U); while(1) { /* Read serial char */ char ch = GETCHAR(); switch(ch) { /* All LEDs red */ case 'r': led.r = 255; led.g = 0; led.b = 0; FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_TransmitBuffer(); break; /* All LEDs green */ case 'g': led.r = 0; led.g = 255; led.b = 0; FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_TransmitBuffer(); break; /* All LEDs red */ case 'b': led.r = 0; led.g = 0; led.b = 255; FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_TransmitBuffer(); break; /* All LEDs off */ case 'o': led.r = 0; led.g = 0; led.b = 0; FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_Update(&led); FLEXIO_WS2812_TransmitBuffer(); break; /* Serial test */ case 's': PRINTF("Serial test\r\n"); break; /* Start measurement */ case 'p': updaterange(); PRINTF("%d,%d,%d,%d,%d,%d,%d,%d\r\n", range[0], range[1], range[2], range[3], range[4], range[5], range[6], range[7]); break; } } }