コード例 #1
0
ファイル: lpc17_leds.c プロジェクト: nodesign/nuttx-kernel
void board_led_initialize(void)
{
  /* Configure all LED GPIO lines */

  lpc17_configgpio(ZKITARM_LED1);
  lpc17_configgpio(ZKITARM_LED2);
}
コード例 #2
0
ファイル: up_outputs.c プロジェクト: 1015472/PX4NuttX
void up_relayinit(void)
{
  lpc17_configgpio(NUCLEUS_BMS_RELAY1);
  lpc17_configgpio(NUCLEUS_BMS_RELAY2);
  lpc17_configgpio(NUCLEUS_BMS_RELAY3);
  lpc17_configgpio(NUCLEUS_BMS_RELAY4);
}
コード例 #3
0
ファイル: up_boot.c プロジェクト: l--putt/nuttx-bb
void lpc17_boardinitialize(void)
{
  /* Enable +5V needed for CAN */

#if defined(CONFIG_LPC17_CAN1) || defined(CONFIG_LPC17_CAN2)
  lpc17_configgpio(NUCLEUS2G_5V_ENABLE);
#else
  lpc17_configgpio(NUCLEUS2G_5V_DISABLE);
#endif

  /* If UART0 is used, enabled the MAX232 driver */

#ifdef CONFIG_LPC17_UART0
  lpc17_configgpio(NUCLEUS2G_232_ENABLE);
#else
  lpc17_configgpio(NUCLEUS2G_232_POWERSAVE);
#endif

  /* Configure SSP chip selects if 1) at least one SSP is enabled, and 2) the weak
   * function lpc17_sspinitialize() has been brought into the link.
   */

#if defined(CONFIG_LPC17_SSP0) || defined(CONFIG_LPC17_SSP1)
  if (lpc17_sspinitialize)
    {
      lpc17_sspinitialize();
    }
#endif

  /* Configure on-board LEDs if LED support has been selected. */

#ifdef CONFIG_ARCH_LEDS
  up_ledinit();
#endif
}
コード例 #4
0
ファイル: lpc17_ssp.c プロジェクト: FreddieChopin/NuttX
void weak_function lpc1766stk_sspinitialize(void)
{
  /* Configure the SSP0 chip select GPIOs.  Only the Nokia LCD is connected to SSP0 */

#ifdef CONFIG_LPC17_SSP0
  ssp_dumpssp0gpio("BEFORE SSP0 Initialization");
  lpc17_configgpio(LPC1766STK_LCD_CS);
  ssp_dumpssp0gpio("AFTER SSP0 Initialization");
#endif

  /* Configure SSP1 chip select GPIOs.  Only the SD/MMC card slot is connected to SSP1 */

#ifdef CONFIG_LPC17_SSP1
  ssp_dumpssp0gpio("BEFORE SSP1 Initialization");
  lpc17_configgpio(LPC1766STK_MMC_CS);

  /* Also configure the SD/MMC power GPIO (but leave power off).  This really has
   * nothing to do with SSP, but does belong with other SD/MMC GPIO configuration
   * settings.
   */

  lpc17_configgpio(LPC1766STK_MMC_PWR);
  ssp_dumpssp0gpio("AFTER SSP1 Initialization");
#endif

#ifdef CONFIG_SPI_CALLBACK
  /* If there were any CD detect pins for the LPC1766-STK, this is where
   * they would be configured.
   */
#endif
}
コード例 #5
0
ファイル: lpc17_ssp.c プロジェクト: acassis/ros2_nuttx
void weak_function lpcxpresso_sspdev_initialize(void)
{
  /* Configure the SPI-based microSD CS GPIO */

  ssp_dumpgpio("lpcxpresso_sspdev_initialize() Entry)");

  /* Configure card detect and chip select for the SD slot.  NOTE:  Jumper J55 must
   * be set correctly for the SD slot chip select.
   */

#ifdef CONFIG_LPC17_SSP1
  (void)lpc17_configgpio(LPCXPRESSO_SD_CS);
  (void)lpc17_configgpio(LPCXPRESSO_SD_CD);

  /* Configure chip select for the OLED. For the SPI interface, insert jumpers in
   * J42, J43, J45 pin1-2 and J46 pin 1-2.
   */

#ifdef CONFIG_NX_LCDDRIVER
  (void)lpc17_configgpio(LPCXPRESSO_OLED_CS);
#endif
#endif

  ssp_dumpgpio("lpcxpresso_sspdev_initialize() Exit");
}
コード例 #6
0
ファイル: lpc17_autoleds.c プロジェクト: AlexShiLucky/NuttX
void board_autoled_initialize(void)
{
  /* Configure LED1-4 GPIOs for output */

  lpc17_configgpio(GPIO_LED1);
  lpc17_configgpio(GPIO_LED2);
  lpc17_configgpio(GPIO_LED3);
  lpc17_configgpio(GPIO_LED4);
}
コード例 #7
0
ファイル: lpc17_userleds.c プロジェクト: jrosberg/NuttX-L21
void lpc17_ledinit(void)
{
  /* Configure LED1-4 GPIOs for output */

  lpc17_configgpio(GPIO_LED1);
  lpc17_configgpio(GPIO_LED2);
  lpc17_configgpio(GPIO_LED3);
  lpc17_configgpio(GPIO_LED4);
}
コード例 #8
0
ファイル: lpc17_leds.c プロジェクト: JforGitHub/thingsee-sdk
void board_led_initialize(void)
{
    /* Configure all LED GPIO lines */

    led_dumpgpio("board_led_initialize() Entry)");

    lpc17_configgpio(LINCOLN60_LED1);
    lpc17_configgpio(LINCOLN60_LED2);

    led_dumpgpio("board_led_initialize() Exit");
}
コード例 #9
0
ファイル: up_leds.c プロジェクト: 1015472/PX4NuttX
void up_ledinit(void)    /* Name when invoked via up_boot.c */
#endif
{
  /* Configure all LED GPIO lines */

  led_dumpgpio("up_ledinit() Entry)");

  lpc17_configgpio(LPC1766STK_LED1);
  lpc17_configgpio(LPC1766STK_LED2);

  led_dumpgpio("up_ledinit() Exit");
}
コード例 #10
0
ファイル: up_leds.c プロジェクト: drasko/opendous_nuttx
void up_ledinit(void)
{
  /* Configure all LED GPIO lines */

  led_dumpgpio("up_ledinit() Entry)");

  lpc17_configgpio(MBED_LED1);
  lpc17_configgpio(MBED_LED2);
  lpc17_configgpio(MBED_LED3);
  lpc17_configgpio(MBED_LED4);

  led_dumpgpio("up_ledinit() Exit");
}
コード例 #11
0
ファイル: lpc17_spi.c プロジェクト: a1ien/nuttx
void weak_function zkit_spidev_initialize(void)
{
  /* Configure the SPI-based microSD CS  and Card Detect (CD) GPIO */

  spi_dumpgpio("zkit_spidev_initialize() Entry)");

  /* Configure card detect and chip select for the SD slot. */

  (void)lpc17_configgpio(ZKITARM_SD_CS);
  (void)lpc17_configgpio(ZKITARM_SD_CD);

  spi_dumpgpio("zkit_spidev_initialize() Exit");
}
コード例 #12
0
ファイル: up_lcd.c プロジェクト: andrecurvello/NuttX
FAR struct lcd_dev_s *up_nxdrvinit(unsigned int devno)
{
  FAR struct spi_dev_s *spi;
  FAR struct lcd_dev_s *dev;

  /* Configure the LCD GPIOs */

  lcd_dumpgpio("up_nxdrvinit: On entry");
  lpc17_configgpio(LPC1766STK_LCD_RST);
  lpc17_configgpio(LPC1766STK_LCD_BL);
  lcd_dumpgpio("up_nxdrvinit: After GPIO setup");

  /* Reset the LCD */

  lpc17_gpiowrite(LPC1766STK_LCD_RST, false);
  up_udelay(10);
  lpc17_gpiowrite(LPC1766STK_LCD_RST, true);
  up_mdelay(5);

  /* Configure PWM1 to support the backlight */

  nokia_blinitialize();

  /* Get the SSP port (configure as a Freescale SPI port) */

  spi = up_spiinitialize(0);
  if (!spi)
    {
      glldbg("Failed to initialize SSP port 0\n");
    }
  else
    {
      /* Bind the SSP port to the LCD */

      dev = nokia_lcdinitialize(spi, devno);
      if (!dev)
        {
          glldbg("Failed to bind SSP port 0 to LCD %d: %d\n", devno);
        }
     else
        {
          gllvdbg("Bound SSP port 0 to LCD %d\n", devno);

          /* And turn the LCD on (CONFIG_LCD_MAXPOWER should be 1) */

          (void)dev->setpower(dev, CONFIG_LCD_MAXPOWER);
          return dev;
        }
    }
  return NULL;
}
コード例 #13
0
ファイル: up_buttons.c プロジェクト: FreddieChopin/NuttX
xcpt_t board_button_irq(int id, xcpt_t irqhandler)
{
  xcpt_t rethandler = NULL;
  irqstate_t flags;
  int ret;

  /* Interrupts are supported on KEY5 only */

  if (id == BOARD_BUTTON_5)
    {
      /* Return the previous value of the interrupt handler */

      flags = irqsave();
      rethandler   = g_oldhandler;
      g_oldhandler = irqhandler;

      /* Attach or detach the interrupt handler for KEY5. */

      if (irqhandler)
        {
          /* Configure KEY5 as an interrupting input */

          lpc17_configgpio(ZKITARM_INT_KEY5);

          /* Attach the new interrupt handler and enable the interrupt */

          ret = irq_attach(ZKITARM_KEY5_IRQ, irqhandler);
          if (ret == OK)
            {
              up_enable_irq(ZKITARM_KEY5_IRQ);
            }
        }
      else
        {
          /* Disable the interrupt and detach the handler */

          up_disable_irq(ZKITARM_KEY5_IRQ);
          (void)irq_detach(ZKITARM_KEY5_IRQ);

          /* Configure KEY5 as a non-interrupting input */

          lpc17_configgpio(ZKITARM_KEY5);

        }

      irqrestore(flags);
    }

  return rethandler;
}
コード例 #14
0
ファイル: up_ssp.c プロジェクト: 1015472/PX4NuttX
void weak_function nucleus2g_sspinitialize(void)
{
  /* Configure the SPI-based microSD CS GPIO */

  ssp_dumpgpio("nucleus2g_sspinitialize() Entry)");

  /* SSP0 connects only to the MMC/SD slot on the Nucleus 1G board.
   * P0[15]/TXD1/SCK0/SCK              MMC_CLK
   * P0[16]/RXD1/SSEL0/SSEL            MMC_CD
   * P0[17]/CTS1/MISO0/MISO            MMC_DATA0
   * P0[18]/DCD1/MOSI0/MOSI            MMC_MISO
   *
   * In SPI mode the MMC/SD DATA3/CD functions as the SPI chip select.
   */

#ifdef CONFIG_LPC17_SSP0
  lpc17_configgpio(NUCLEUS2G_MMCSD_CS);
#endif
  
  /* SSP1 goes off the Nucleus 2G board to the Babel CAN board along with 3 chip
   * select pins.  However, it is currently not used on that board.
   */

#ifdef CONFIG_LPC17_SSP1
# warning "SSP1 chip selects not known"
#endif
  ssp_dumpgpio("nucleus2g_sspinitialize() Exit");
}
コード例 #15
0
ファイル: lpc17_leds.c プロジェクト: acassis/ros2_nuttx
void board_autoled_initialize(void)
{
  /* Configure all LED GPIO lines */

  lpc17_configgpio(C027_LED);
  g_ncstate = true;
}
コード例 #16
0
ファイル: up_leds.c プロジェクト: andrecurvello/NuttX
void up_ledinit(void)
{
  /* Configure all LED GPIO lines */

  lpc17_configgpio(LPCXPRESSO_LED);
  g_ncstate = true;
}
コード例 #17
0
ファイル: up_oled.c プロジェクト: nsrango/Firmware
FAR struct lcd_dev_s *up_nxdrvinit(unsigned int devno)
{
  FAR struct spi_dev_s *spi;
  FAR struct lcd_dev_s *dev;

  /* Configure the OLED GPIOs. For the SPI interface, insert jumpers in J42,
   * J43, J45 pin1-2 and J46 pin 1-2.
   */
 
  oledcs_dumpgpio("up_nxdrvinit: After OLED CS setup");
  oleddc_dumpgpio("up_nxdrvinit: On entry");

  (void)lpc17_configgpio(LPCXPRESSO_OLED_POWER); /* OLED 11V power */
  (void)lpc17_configgpio(LPCXPRESSO_OLED_DC);    /* OLED Command/Data */

  oleddc_dumpgpio("up_nxdrvinit: After OLED Power/DC setup");

  /* Get the SSI port (configure as a Freescale SPI port) */

  spi = up_spiinitialize(1);
  if (!spi)
    {
      glldbg("Failed to initialize SSI port 1\n");
    }
  else
    {
      /* Bind the SSI port to the OLED */

      dev = ug_initialize(spi, devno);
      if (!dev)
        {
          glldbg("Failed to bind SSI port 1 to OLED %d: %d\n", devno);
        }
     else
        {
          gllvdbg("Bound SSI port 1 to OLED %d\n", devno);

          /* And turn the OLED on (dim) */

          (void)dev->setpower(dev, UG_POWER_DIM);
          return dev;
        }
    }
  return NULL;
}
コード例 #18
0
ファイル: lpc17_nsh.c プロジェクト: 1015472/PX4NuttX
static int nsh_sdinitialize(void)
{
  int ret;

#ifdef NSH_HAVE_MMCSD_CD
  /* Configure the SD card detect GPIO */

  lpc17_configgpio(GPIO_SD_CD);

  /* Attach an interrupt handler to get notifications when a card is
   * inserted or deleted.
   */

#if NSH_HAVE_MMCSD_CDINT

   (void)irq_attach(LPC17_IRQ_P0p13, nsh_cdinterrupt);
   up_enable_irq(LPC17_IRQ_P0p13);

#endif
#endif

  /* First, get an instance of the SDIO interface */

  g_sdiodev = sdio_initialize(CONFIG_NSH_MMCSDSLOTNO);
  if (!g_sdiodev)
    {
      message("nsh_archinitialize: Failed to initialize SDIO slot %d\n",
              CONFIG_NSH_MMCSDSLOTNO);
      return -ENODEV;
    }

  /* Now bind the SDIO interface to the MMC/SD driver */

  ret = mmcsd_slotinitialize(CONFIG_NSH_MMCSDMINOR, g_sdiodev);
  if (ret != OK)
    {
      message("nsh_archinitialize: "
              "Failed to bind SDIO to the MMC/SD driver: %d\n",
              ret);

      return ret;
    }

  /* Check if there is a card in the slot and inform the SDCARD driver.  If
   * we do not support the card  detect, then let's assume that there is
   * one.
   */

#ifdef NSH_HAVE_MMCSD_CD
  sdio_mediachange(g_sdiodev, !lpc17_gpioread(GPIO_SD_CD));
#else
  sdio_mediachange(g_sdiodev, true);
#endif
  return OK;
}
コード例 #19
0
ファイル: up_buttons.c プロジェクト: 1015472/PX4NuttX
void up_buttoninit(void)
{
  int i;

  /* Configure the GPIO pins as interrupting inputs. */

  for (i = 0; i < BOARD_NUM_BUTTONS; i++)
    {
      lpc17_configgpio(g_buttoncfg[i]);
    }
}
コード例 #20
0
ファイル: lpc17_lcd.c プロジェクト: acassis/ros2_nuttx
int board_lcd_initialize(void)
{
  lpc17_configgpio(ZKITARM_OLED_RST);
  lpc17_configgpio(ZKITARM_OLED_RS);
  lpc17_gpiowrite(ZKITARM_OLED_RST, 1);
  lpc17_gpiowrite(ZKITARM_OLED_RS, 1);

  zkit_sspdev_initialize();
  g_spidev = lpc17_sspbus_initialize(0);
  if (!g_spidev)
    {
      glldbg("Failed to initialize SSP port 0\n");
      return 0;
    }

  lpc17_gpiowrite(ZKITARM_OLED_RST, 0);
  up_mdelay(1);
  lpc17_gpiowrite(ZKITARM_OLED_RST, 1);
  return 1;
}
コード例 #21
0
int up_lcdinitialize(void)
{
  lpc17_configgpio(ZKITARM_OLED_RST);
  lpc17_configgpio(ZKITARM_OLED_RS);
  lpc17_gpiowrite(ZKITARM_OLED_RST, 1);
  lpc17_gpiowrite(ZKITARM_OLED_RS, 1);

  zkit_sspinitialize();
  spi = lpc17_sspinitialize(0);
  if (!spi)
    {
      glldbg("Failed to initialize SSP port 0\n");
      return 0;
    }

  lpc17_gpiowrite(ZKITARM_OLED_RST, 0);
  up_mdelay(1);
  lpc17_gpiowrite(ZKITARM_OLED_RST, 1);
  return 1;
}
コード例 #22
0
ファイル: lpc17_buttons.c プロジェクト: AlexShiLucky/NuttX
void board_button_initialize(void)
{
  int i;

  /* Configure the GPIO pins as interrupting inputs. */

  for (i = 0; i < NUM_BUTTONS; i++)
    {
      lpc17_configgpio(g_buttoncfg[i]);
    }
}
コード例 #23
0
ファイル: up_buttons.c プロジェクト: FreddieChopin/NuttX
void board_button_initialize(void)
{
  int i;

  /* Configure the GPIO pins as inputs.  NOTE that EXTI interrupts are
   * configured for some pins but NOT used in this file
   */

  for (i = 0; i < BOARD_NUM_BUTTONS; i++)
    {
      lpc17_configgpio(g_buttons[i]);
    }
}
コード例 #24
0
ファイル: lpc17_ssp.c プロジェクト: Nuages/terrarium_2015
void weak_function zkit_sspinitialize(void)
{
  /* Configure the SPI-based LCD CS GPIO */

  ssp_dumpgpio("zkit_sspinitialize() Entry)");

  /* Configure chip select for the LCD. */

#ifdef CONFIG_LPC17_SSP0
#ifdef CONFIG_NX_LCDDRIVER
  (void)lpc17_configgpio(ZKITARM_OLED_CS);
#endif
#endif /* CONFIG_LPC17_SSP0 */

  ssp_dumpgpio("zkit_sspinitialize() Exit");
}
コード例 #25
0
ファイル: lpc17_dac.c プロジェクト: centurysys/NuttX-SA1xx
static void dac_reset(FAR struct dac_dev_s *dev)
{
  irqstate_t flags;
  uint32_t regval;

  flags = irqsave();

  regval  = getreg32(LPC17_SYSCON_PCLKSEL0);
  regval &= ~SYSCON_PCLKSEL0_DAC_MASK;
  regval |= (SYSCON_PCLKSEL_CCLK8 << SYSCON_PCLKSEL0_DAC_SHIFT);
  putreg32(regval, LPC17_SYSCON_PCLKSEL0);

  //putreg32(DAC_CTRL_DBLBUFEN,LPC17_DAC_CTRL); ?

  lpc17_configgpio(GPIO_AOUT);

  irqrestore(flags);
}
コード例 #26
0
ファイル: up_leds.c プロジェクト: casro/vrbrain_nuttx
void board_led_initialize(void)
{
  /* Configure all LED GPIO lines */

  led_dumpgpio("board_led_initialize() Entry)");

  lpc17_configgpio(NUCLEUS2G_LED1_A);
  lpc17_configgpio(NUCLEUS2G_LED1_B);
  lpc17_configgpio(NUCLEUS2G_LED2_A);
  lpc17_configgpio(NUCLEUS2G_LED2_B);
  lpc17_configgpio(NUCLEUS2G_HEARTBEAT);
  lpc17_configgpio(NUCLEUS2G_EXTRA_LED);

  led_dumpgpio("board_led_initialize() Exit");
}
コード例 #27
0
ファイル: lpc17_lowputc.c プロジェクト: l--putt/nuttx-bb
void lpc17_lowsetup(void)
{
#ifdef HAVE_UART
  uint32_t regval;

  /* Step 1: Enable power for all console UART and disable power for
   * other UARTs
   */

  regval  = getreg32(LPC17_SYSCON_PCONP);
  regval &= ~(SYSCON_PCONP_PCUART0|SYSCON_PCONP_PCUART1|
              SYSCON_PCONP_PCUART2|SYSCON_PCONP_PCUART3);
#if defined(CONFIG_UART0_SERIAL_CONSOLE)
  regval |= SYSCON_PCONP_PCUART0;
#elif defined(CONFIG_UART1_SERIAL_CONSOLE)
  regval |= SYSCON_PCONP_PCUART1;
#elif defined(CONFIG_UART2_SERIAL_CONSOLE)
  regval |= SYSCON_PCONP_PCUART2;
#elif defined(CONFIG_UART3_SERIAL_CONSOLE)
  regval |= SYSCON_PCONP_PCUART3;
#endif
  putreg32(regval, LPC17_SYSCON_PCONP);

/* Step 2: Enable peripheral clocking for the console UART and disable
 * clocking for all other UARTs
 */

  regval = getreg32(LPC17_SYSCON_PCLKSEL0);
  regval &= ~(SYSCON_PCLKSEL0_UART0_MASK|SYSCON_PCLKSEL0_UART1_MASK);
#if defined(CONFIG_UART0_SERIAL_CONSOLE)
  regval |= (CONSOLE_CCLKDIV << SYSCON_PCLKSEL0_UART0_SHIFT);
#elif defined(CONFIG_UART1_SERIAL_CONSOLE)
  regval |= (CONSOLE_CCLKDIV << SYSCON_PCLKSEL0_UART1_SHIFT);
#endif
  putreg32(regval, LPC17_SYSCON_PCLKSEL0);

  regval = getreg32(LPC17_SYSCON_PCLKSEL1);
  regval &= ~(SYSCON_PCLKSEL1_UART2_MASK|SYSCON_PCLKSEL1_UART3_MASK);
#if defined(CONFIG_UART2_SERIAL_CONSOLE)
  regval |= (CONSOLE_CCLKDIV << SYSCON_PCLKSEL1_UART2_SHIFT);
#elif defined(CONFIG_UART3_SERIAL_CONSOLE)
  regval |= (CONSOLE_CCLKDIV << SYSCON_PCLKSEL1_UART3_SHIFT);
#endif
  putreg32(regval, LPC17_SYSCON_PCLKSEL1);

  /* Configure UART pins for the selected CONSOLE */

#if defined(CONFIG_UART0_SERIAL_CONSOLE)
  lpc17_configgpio(GPIO_UART0_TXD);
  lpc17_configgpio(GPIO_UART0_RXD);
#elif defined(CONFIG_UART1_SERIAL_CONSOLE)
  lpc17_configgpio(GPIO_UART1_TXD);
  lpc17_configgpio(GPIO_UART1_RXD);
#ifdef CONFIG_UART1_FLOWCONTROL
  lpc17_configgpio(GPIO_UART1_CTS);
  lpc17_configgpio(GPIO_UART1_DCD);
  lpc17_configgpio(GPIO_UART1_DSR);
  lpc17_configgpio(GPIO_UART1_DTR);
  lpc17_configgpio(GPIO_UART1_RI);
  lpc17_configgpio(GPIO_UART1_RTS);
#endif
#elif defined(CONFIG_UART2_SERIAL_CONSOLE)
  lpc17_configgpio(GPIO_UART2_TXD);
  lpc17_configgpio(GPIO_UART2_RXD);
  irqrestore(flags);
#elif defined(CONFIG_UART3_SERIAL_CONSOLE)
  lpc17_configgpio(GPIO_UART3_TXD);
  lpc17_configgpio(GPIO_UART3_RXD);
#endif

  /* Configure the console (only) */

#if defined(HAVE_CONSOLE) && !defined(CONFIG_SUPPRESS_UART_CONFIG)

  /* Clear fifos */

  putreg32(UART_FCR_RXRST|UART_FCR_TXRST, CONSOLE_BASE+LPC17_UART_FCR_OFFSET);

  /* Set trigger */

  putreg32(UART_FCR_FIFOEN|UART_FCR_RXTRIGGER_8, CONSOLE_BASE+LPC17_UART_FCR_OFFSET);

  /* Set up the LCR and set DLAB=1 */

  putreg32(CONSOLE_LCR_VALUE|UART_LCR_DLAB, CONSOLE_BASE+LPC17_UART_LCR_OFFSET);

  /* Set the BAUD divisor */

  putreg32(CONSOLE_DL >> 8, CONSOLE_BASE+LPC17_UART_DLM_OFFSET);
  putreg32(CONSOLE_DL & 0xff, CONSOLE_BASE+LPC17_UART_DLL_OFFSET);

  /* Clear DLAB */

  putreg32(CONSOLE_LCR_VALUE, CONSOLE_BASE+LPC17_UART_LCR_OFFSET);

  /* Configure the FIFOs */

  putreg32(UART_FCR_RXTRIGGER_8|UART_FCR_TXRST|UART_FCR_RXRST|UART_FCR_FIFOEN,
           CONSOLE_BASE+LPC17_UART_FCR_OFFSET);
#endif
#endif /* HAVE_UART */
}
コード例 #28
0
ファイル: lpc17_lcd.c プロジェクト: 1015472/PX4NuttX
void open1788_lcd_initialize(void)
{
  /* Configure the LCD backlight (and turn the backlight off) */

  lpc17_configgpio(GPIO_LCD_BL);
}