/*!
* @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;
}
