/*! * @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 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 mc_usb_init() { if (usb_device_system_init(USB_CDC) != WM_SUCCESS) { int i; wmprintf("usb_stdio_init failed\r\n"); for (i = 0; i < MC_MAX_LED_PINS; i++) GPIO_WritePinOutput(mc_conf.led_pins[i], GPIO_IO_HIGH); GPIO_WritePinOutput(mc_conf.led_pins[0], GPIO_IO_LOW); /* red */ os_thread_sleep(5000); return -1; } os_thread_sleep(1000); mc_thread_create(usb_thread_main, NULL, -1); /* create a thread for USB input */ return 0; }
void gpio_write(gpio_t *obj, int value) { MBED_ASSERT(obj->pin != (PinName)NC); uint32_t pin_number = obj->pin & 0x1F; uint8_t port_number = obj->pin / 32; GPIO_WritePinOutput(GPIO, port_number, pin_number, value); }
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 modem_disable() { // try to power down the SIM800, then switch off power domain modem_send("AT+CPOWD=1"); modem_expect_urc(14, 7000); #if ((defined BOARD_CELL_PWR_EN_GPIO) && (defined BOARD_CELL_PWR_EN_PIN)) CSTDEBUG("GSM #### -- power off\r\n"); GPIO_WritePinOutput(BOARD_CELL_PWR_EN_GPIO, BOARD_CELL_PWR_EN_PIN, false); #endif }
static int imx_gpio_write(struct device *dev, int access_op, u32_t pin, u32_t value) { const struct imx_gpio_config *config = dev->config->config_info; if (access_op == GPIO_ACCESS_BY_PIN) { GPIO_WritePinOutput(config->base, pin, (gpio_pin_action_t)value); } else { /* GPIO_ACCESS_BY_PORT */ GPIO_WritePortOutput(config->base, value); } return 0; }
mdev_t *ssp_drv_open(SSP_ID_Type ssp_id, SSP_FrameFormat_Type format, SSP_MS_Type mode, SSP_DMA dma, int cs, bool level) { int ret; SSP_CFG_Type sspCfgStruct; SSP_FIFO_Type sspFifoCfg; SPI_Param_Type spiParaStruct; SSP_NWK_Type sspNetworkCfg; PSP_Param_Type pspParaStruct; sspdev_data_t *ssp_data_p; mdev_t *mdev_p = mdev_get_handle(mdev_ssp_name[ssp_id]); ssp_data_p = (sspdev_data_t *) mdev_p->private_data; if (mdev_p == NULL) { SSP_LOG("Unable to open device %s\r\n", mdev_ssp_name[ssp_id]); return NULL; } ssp_data_p->slave = mode; ret = os_mutex_get(&ssp_mutex[mdev_p->port_id], OS_WAIT_FOREVER); if (ret == -WM_FAIL) { SSP_LOG("failed to get mutex\r\n"); return NULL; } /* If ringbuffer size is not set by user then set to default size */ if (GET_RX_BUF_SIZE(ssp_data_p) == 0) { SET_RX_BUF_SIZE(ssp_data_p, SSP_RX_BUF_SIZE); } if (rx_buf_init(ssp_data_p)) { SSP_LOG("Unable to allocate ssp software ring buffer\r\n"); return NULL; } /* If clk is not set by user then set it to default */ if (ssp_data_p->freq == 0) { ret = ssp_drv_set_clk(mdev_p->port_id, DEFAULT_SSP_FREQ); } /* Configure the pinmux for ssp pins */ if (cs >= 0 && mode == SSP_MASTER) { board_ssp_pin_config(mdev_p->port_id, 0); /* Use user specified chip select pin */ ssp_data_p->cs = cs; ssp_data_p->cs_level = level; GPIO_PinMuxFun(cs, PINMUX_FUNCTION_0); GPIO_SetPinDir(cs, GPIO_OUTPUT); /* Initially keep slave de-selected */ GPIO_WritePinOutput(cs, !level); } else { board_ssp_pin_config(mdev_p->port_id, 1); } /* Configure SSP interface */ sspCfgStruct.mode = SSP_NORMAL; sspCfgStruct.masterOrSlave = mode; sspCfgStruct.trMode = SSP_TR_MODE; sspCfgStruct.dataSize = SSP_DATASIZE_8; sspCfgStruct.sfrmPola = SSP_SAMEFRM_PSP; sspCfgStruct.slaveClkRunning = SSP_SLAVECLK_TRANSFER; sspCfgStruct.txd3StateEnable = ENABLE; /* RXFIFO inactivity timeout, [timeout = 100 / 26MHz] (Bus clock) */ sspCfgStruct.timeOutVal = 100; switch (format) { case SSP_FRAME_SPI: sspCfgStruct.frameFormat = SSP_FRAME_SPI; sspCfgStruct.txd3StateType = SSP_TXD3STATE_ELSB; break; case SSP_FRAME_PSP: sspCfgStruct.frameFormat = SSP_FRAME_PSP; sspCfgStruct.txd3StateType = SSP_TXD3STATE_12SLSB; break; case SSP_FRAME_SSP: SSP_LOG("Frame Format not implemented.\r\n"); return NULL; } /* Configure SSP Fifo */ sspFifoCfg.fifoPackMode = DISABLE; /* See if dma needs to be enabled */ if (dma == DMA_ENABLE) { /* Enable DMA controller clock */ CLK_ModuleClkEnable(CLK_DMAC); sspFifoCfg.rxFifoFullLevel = SSP_DMA_FIFO_RX_THRESHOLD; sspFifoCfg.txFifoEmptyLevel = SSP_DMA_FIFO_TX_THRESHOLD; sspFifoCfg.rxDmaService = ENABLE; sspFifoCfg.txDmaService = ENABLE; ssp_data_p->dma = 1; sspCfgStruct.trailByte = SSP_TRAILBYTE_DMA; } else { sspFifoCfg.rxFifoFullLevel = SSP_FIFO_RX_THRESHOLD; sspFifoCfg.txFifoEmptyLevel = SSP_FIFO_TX_THRESHOLD; sspFifoCfg.rxDmaService = DISABLE; sspFifoCfg.txDmaService = DISABLE; sspCfgStruct.trailByte = SSP_TRAILBYTE_CORE; } /* Let the settings take effect */ SSP_Disable(mdev_p->port_id); SSP_Init(mdev_p->port_id, &sspCfgStruct); SSP_FifoConfig(mdev_p->port_id, &sspFifoCfg); /* Do frame format config */ switch (format) { case SSP_FRAME_SPI: spiParaStruct.spiClkPhase = SPI_SCPHA_1; spiParaStruct.spiClkPolarity = SPI_SCPOL_LOW; SPI_Config(mdev_p->port_id, &spiParaStruct); break; case SSP_FRAME_PSP: pspParaStruct.pspFsrtType = 0; pspParaStruct.pspClkMode = PSP_DRIVFALL_SAMPRISE_IDLELOW; pspParaStruct.pspFrmPola = PSP_SFRMP_LOW; pspParaStruct.pspEndTransState = PSP_ENDTRANS_LOW; pspParaStruct.startDelay = 0; pspParaStruct.dummyStart = 0; pspParaStruct.dummyStop = 0; pspParaStruct.frmDelay = 0; pspParaStruct.frmLength = 8; PSP_Config(mdev_p->port_id, &pspParaStruct); sspNetworkCfg.frameRateDiv = 1; sspNetworkCfg.txTimeSlotActive = 3; sspNetworkCfg.rxTimeSlotActive = 3; SSP_NwkConfig(mdev_p->port_id, &sspNetworkCfg); break; case SSP_FRAME_SSP: SSP_LOG("Frame Format not implemented.\r\n"); return NULL; } /* Enable read interrupts only for slave when dma is disabled*/ if (mode == SSP_SLAVE && dma == DMA_DISABLE) { install_int_callback(SSP_INT_BASE + mdev_p->port_id, SSP_INT_RFFI, ssp_read_irq_handler[mdev_p->port_id]); NVIC_EnableIRQ(SSP_IRQn_BASE + mdev_p->port_id); NVIC_SetPriority(SSP_IRQn_BASE + mdev_p->port_id, 0xF); SSP_IntMask(mdev_p->port_id, SSP_INT_RFFI, UNMASK); } SSP_Enable(mdev_p->port_id); return mdev_p; }
void ssp_drv_cs_deactivate(mdev_t *dev) { sspdev_data_t *ssp_data_p; ssp_data_p = (sspdev_data_t *) dev->private_data; GPIO_WritePinOutput(ssp_data_p->cs, !ssp_data_p->cs_level); }
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; } } }
void hal_gpio_write(int pin, int val) { GPIO_WritePinOutput(s_gpioBases[GPIO_PORT(pin)], GPIO_INDEX(pin), val); }
bool modem_enable() { char response[10]; size_t len; #if BOARD_CELL_PWR_DOMAIN CSTDEBUG("GSM #### -- power on\r\n"); GPIO_WritePinOutput(BOARD_CELL_PWR_EN_GPIO, BOARD_CELL_PWR_EN_PIN, true); // TODO check that power has come up correctly #endif // after enabling power, power on the SIM800 while (modem_read() != -1) /* clear buffer */; // we need to identify if the chip is already on by sending AT commands // send AT and just ignore the echo and OK to get into a stable state // sometimes there is initial noise on the serial line modem_send("AT"); len = modem_readline(response, 9, 500); CIODEBUG("GSM (%02d) -> '%s'\r\n", len, response); len = modem_readline(response, 9, 500); CIODEBUG("GSM (%02d) -> '%s'\r\n", len, response); // now identify if the chip is actually on, by issue AT and expecting something // if we can't read a response, either AT or OK, we need to run the power on sequence modem_send("AT"); len = modem_readline(response, 9, 1000); CIODEBUG("GSM (%02d) -> '%s'\r\n", len, response); if (!len) { CSTDEBUG("GSM #### !! trigger PWRKEY\r\n"); #if defined(BOARD_UBIRCH_1R02) // there is a bug in the circuit on the board which does not use an extra // transistor to switch the PWRKEY pin, so the signals are reversed // power on the SIM800H GPIO_WritePinOutput(BOARD_CELL_PIN_GPIO, BOARD_CELL_PWRKEY_PIN, true); delay(10); //10ms GPIO_WritePinOutput(BOARD_CELL_PIN_GPIO, BOARD_CELL_PWRKEY_PIN, false); delay(1100); // 1.1s GPIO_WritePinOutput(BOARD_CELL_PIN_GPIO, BOARD_CELL_PWRKEY_PIN, true); #else // power on the cell phone chip GPIO_WritePinOutput(BOARD_CELL_PIN_GPIO, BOARD_CELL_PWRKEY_PIN, false); delay(10); //10ms GPIO_WritePinOutput(BOARD_CELL_PIN_GPIO, BOARD_CELL_PWRKEY_PIN, true); delay(1100); // 1.1s GPIO_WritePinOutput(BOARD_CELL_PIN_GPIO, BOARD_CELL_PWRKEY_PIN, false); #endif } else { CSTDEBUG("GSM #### !! already on\r\n"); } bool is_on = false; // wait for the chip to boot and react to commands for (int i = 0; i < 5; i++) { modem_send("ATE0"); // if we still have echo on, this fails and falls through to the next OK if ((is_on = modem_expect_OK(1000))) break; if ((is_on = modem_expect_OK(1000))) break; } return is_on; }