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