Ejemplo n.º 1
0
/*!
 * @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);
    }
  }
}
Ejemplo n.º 2
0
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);
}
Ejemplo n.º 3
0
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;
}
Ejemplo n.º 4
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);
}
Ejemplo n.º 5
0
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);
    }
}
Ejemplo n.º 7
0
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);
        }
    }
}
Ejemplo n.º 8
0
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();
    }
}
Ejemplo n.º 9
0
/*!
 * @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;
        }
    }
}
Ejemplo n.º 10
0
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;
}
Ejemplo n.º 11
0
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;
}
Ejemplo n.º 12
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;
}
Ejemplo n.º 13
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;
}
Ejemplo n.º 14
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);
}
Ejemplo n.º 15
0
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;
      }
  }
}