示例#1
0
void board_userled_all(uint8_t ledset)
{
  lpc17_gpiowrite(GPIO_LED1, (ledset & BOARD_LED1_BIT) == 0);
  lpc17_gpiowrite(GPIO_LED2, (ledset & BOARD_LED2_BIT) == 0);
  lpc17_gpiowrite(GPIO_LED3, (ledset & BOARD_LED3_BIT) == 0);
  lpc17_gpiowrite(GPIO_LED4, (ledset & BOARD_LED4_BIT) == 0);
}
示例#2
0
void lpc17_setleds(uint8_t ledset)
{
  lpc17_gpiowrite(GPIO_LED1, (ledset & BOARD_LED1_BIT) == 0);
  lpc17_gpiowrite(GPIO_LED2, (ledset & BOARD_LED2_BIT) == 0);
  lpc17_gpiowrite(GPIO_LED3, (ledset & BOARD_LED3_BIT) == 0);
  lpc17_gpiowrite(GPIO_LED4, (ledset & BOARD_LED4_BIT) == 0);
}
示例#3
0
void lpc17_led2(enum lpc17_ledstate_e state)
{
  bool red   = (((unsigned int)state & LPC17_LEDSTATE_RED) != 0);
  bool green = (((unsigned int)state & LPC17_LEDSTATE_GREEN) != 0);

  lpc17_gpiowrite(NUCLEUS2G_LED2_A, red);
  lpc17_gpiowrite(NUCLEUS2G_LED2_B, green);
}
示例#4
0
void lpc17_setled(int led, bool ledon)
{
  if (led == BOARD_LED1)
    {
      lpc17_gpiowrite(LPC1766STK_LED1, !ledon);
    }
  else if (led == BOARD_LED2)
    {
      lpc17_gpiowrite(LPC1766STK_LED2, !ledon);
    }
}
示例#5
0
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;
}
示例#6
0
int usbmsc_archinitialize(void)
{
  FAR struct spi_dev_s *spi;
  int ret;

  /* Enable power to the SD/MMC via a GPIO. LOW enables SD/MMC. */

  lpc17_gpiowrite(LPC1766STK_MMC_PWR, false);

  /* Get the SPI port */

  message("usbmsc_archinitialize: Initializing SPI port %d\n",
          LPC17XX_MMCSDSPIPORTNO);

  spi = up_spiinitialize(LPC17XX_MMCSDSPIPORTNO);
  if (!spi)
    {
      message("usbmsc_archinitialize: Failed to initialize SPI port %d\n",
              LPC17XX_MMCSDSPIPORTNO);
      ret = -ENODEV;
      goto errout;
    }

  message("usbmsc_archinitialize: Successfully initialized SPI port %d\n",
          LPC17XX_MMCSDSPIPORTNO);

  /* Bind the SPI port to the slot */

  message("usbmsc_archinitialize: Binding SPI port %d to MMC/SD slot %d\n",
          LPC17XX_MMCSDSPIPORTNO, LPC17XX_MMCSDSLOTNO);

  ret = mmcsd_spislotinitialize(CONFIG_EXAMPLES_USBMSC_DEVMINOR1, LPC17XX_MMCSDSLOTNO, spi);
  if (ret < 0)
    {
      message("usbmsc_archinitialize: Failed to bind SPI port %d to MMC/SD slot %d: %d\n",
              LPC17XX_MMCSDSPIPORTNO, LPC17XX_MMCSDSLOTNO, ret);
      goto errout;
    }

  message("usbmsc_archinitialize: Successfuly bound SPI port %d to MMC/SD slot %d\n",
          LPC17XX_MMCSDSPIPORTNO, LPC17XX_MMCSDSLOTNO);
  return OK;

  /* Disable power to the SD/MMC via a GPIO. HIGH disables SD/MMC. */

errout:
  lpc17_gpiowrite(LPC1766STK_MMC_PWR, true);
  return ret;}
示例#7
0
void lpc17_setled(int led, bool ledon)
{
  if ((unsigned)led < BOARD_NLEDS)
    {
      lpc17_gpiowrite(g_ledcfg[led], ledon);
    }
}
示例#8
0
static int nsh_sdinitialize(void)
{
  FAR struct spi_dev_s *ssp;
  int ret;

  /* Enable power to the SD/MMC via a GPIO. LOW enables SD/MMC. */

  lpc17_gpiowrite(LPC1766STK_MMC_PWR, false);

  /* Get the SSP port */

  ssp = lpc17_sspinitialize(CONFIG_NSH_MMCSDSPIPORTNO);
  if (!ssp)
    {
      message("nsh_archinitialize: Failed to initialize SSP port %d\n",
              CONFIG_NSH_MMCSDSPIPORTNO);
      ret = -ENODEV;
      goto errout;
    }

  message("Successfully initialized SSP port %d\n",
          CONFIG_NSH_MMCSDSPIPORTNO);

  /* Bind the SSP port to the slot */

  ret = mmcsd_spislotinitialize(CONFIG_NSH_MMCSDMINOR,
                               CONFIG_NSH_MMCSDSLOTNO, ssp);
  if (ret < 0)
    {
      message("nsh_sdinitialize: "
              "Failed to bind SSP port %d to MMC/SD slot %d: %d\n",
              CONFIG_NSH_MMCSDSPIPORTNO,
              CONFIG_NSH_MMCSDSLOTNO, ret);
      goto errout;
    }

  message("Successfuly bound SSP port %d to MMC/SD slot %d\n",
          CONFIG_NSH_MMCSDSPIPORTNO,
          CONFIG_NSH_MMCSDSLOTNO);
  return OK;

  /* Disable power to the SD/MMC via a GPIO. HIGH disables SD/MMC. */

errout:
  lpc17_gpiowrite(LPC1766STK_MMC_PWR, true);
  return ret;
}
示例#9
0
void board_led_on(int led)
{
  /* We will control LED1 and LED2 not yet completed the boot sequence. */

  if (!g_initialized)
    {
      bool led1 = false;
      bool led2 = false;

      switch (led)
        {
        case LED_STACKCREATED:
          g_initialized = true;
        case LED_STARTED:
        default:
          break;

        case LED_HEAPALLOCATE:
          led1 = true;
          break;

        case LED_IRQSENABLED:
          led2 = true;
          break;
        }

      lpc17_gpiowrite(ZKITARM_LED1, led1);
      lpc17_gpiowrite(ZKITARM_LED2, led2);
    }

  /* We will always control the HB LED */

  switch (led)
    {
    case LED_INIRQ:
    case LED_SIGNAL:
    case LED_ASSERTION:
    case LED_PANIC:
      lpc17_gpiowrite(ZKITARM_LED2, false);
      g_nestcount++;

    default:
      break;
    }
}
示例#10
0
void up_ledoff(int led)
{
  switch (led)
    {
       default:
       case 0 : /* STARTED, HEAPALLOCATE, IRQSENABLED */
       case 1 : /* STACKCREATED */
        lpc17_gpiowrite(LPC1766STK_LED1, true);

       case 2 : /* INIRQ, SIGNAL, ASSERTION, PANIC */
        lpc17_gpiowrite(LPC1766STK_LED2, true);
        break;

       case 3 : /* IDLE */
        lpc17_gpiowrite(LPC1766STK_LED1, g_uninitialized);
        break;
    }
}
示例#11
0
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;
}
示例#12
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;
}
示例#13
0
int lpc17_ssp1cmddata(FAR struct spi_dev_s *dev, enum spi_dev_e devid, bool cmd)
{
  if (devid == SPIDEV_DISPLAY)
    {
      /* Set GPIO to 1 for data, 0 for command */

      (void)lpc17_gpiowrite(LPCXPRESSO_OLED_DC, !cmd);
      return OK;
    }
  return -ENODEV;
}
示例#14
0
int lpc17_ssp0cmddata(FAR struct spi_dev_s *dev, enum spi_dev_e devid, bool cmd)
{
  if (devid == SPIDEV_DISPLAY)
    {
      /* Set GPIO to 1 for data, 0 for command */

      lpc17_gpiowrite(ZKITARM_OLED_RS, !cmd);
      return OK;
    }

  return -ENODEV;
}
示例#15
0
void  lpc17_ssp1select(FAR struct spi_dev_s *dev, enum spi_dev_e devid, bool selected)
{
  sspdbg("devid: %d CS: %s\n", (int)devid, selected ? "assert" : "de-assert");
  ssp_dumpgpio("lpc17_ssp1select() Entry");

  if (devid == SPIDEV_MMCSD)
    {
      /* Assert/de-assert the CS pin to the card */

      (void)lpc17_gpiowrite(LPCXPRESSO_SD_CS, !selected);
    }
#ifdef CONFIG_NX_LCDDRIVER
  else if (devid == SPIDEV_DISPLAY)
    {
      /* Assert the CS pin to the OLED display */

      (void)lpc17_gpiowrite(LPCXPRESSO_OLED_CS, !selected);
    }
#endif
  ssp_dumpgpio("lpc17_ssp1select() Exit");
}
示例#16
0
void  lpc17_ssp1select(FAR struct spi_dev_s *dev, enum spi_dev_e devid, bool selected)
{
  sspdbg("devid: %d CS: %s\n", (int)devid, selected ? "assert" : "de-assert");
  if (devid == SPIDEV_MMCSD)
    {
      /* Assert/de-assert the CS pin to the card */

      ssp_dumpssp1gpio("lpc17_ssp1select() Entry");
      lpc17_gpiowrite(LPC1766STK_MMC_CS, !selected);
      ssp_dumpssp1gpio("lpc17_ssp1select() Exit");
    }
}
示例#17
0
static inline void led_setbits(unsigned int setbits)
{
  if ((setbits & OPEN1788_LED1) != 0)
    {
      lpc17_gpiowrite(GPIO_LED1, true);
    }

  if ((setbits & OPEN1788_LED2) != 0)
    {
      lpc17_gpiowrite(GPIO_LED2, true);
    }

  if ((setbits & OPEN1788_LED3) != 0)
    {
      lpc17_gpiowrite(GPIO_LED3, true);
    }

  if ((setbits & OPEN1788_LED4) != 0)
    {
      lpc17_gpiowrite(GPIO_LED4, true);
    }
}
示例#18
0
static inline void led_clrbits(unsigned int clrbits)
{
  if ((clrbits & OPEN1788_LED1) != 0)
    {
      lpc17_gpiowrite(GPIO_LED1, false);
    }

  if ((clrbits & OPEN1788_LED2) != 0)
    {
      lpc17_gpiowrite(GPIO_LED2, false);
    }

  if ((clrbits & OPEN1788_LED3) != 0)
    {
      lpc17_gpiowrite(GPIO_LED3, false);
    }

  if ((clrbits & OPEN1788_LED4) != 0)
    {
      lpc17_gpiowrite(GPIO_LED4, false);
    }
}
示例#19
0
文件: up_ssp.c 项目: 1015472/PX4NuttX
void  lpc17_ssp0select(FAR struct spi_dev_s *dev, enum spi_dev_e devid, bool selected)
{
  sspdbg("devid: %d CS: %s\n", (int)devid, selected ? "assert" : "de-assert");
  ssp_dumpgpio("lpc17_ssp0select() Entry");

  if (devid == SPIDEV_MMCSD)
    {
      /* Assert the CS pin to the card */

      lpc17_gpiowrite(NUCLEUS2G_MMCSD_CS, !selected);
    }
  ssp_dumpgpio("lpc17_ssp0select() Exit");
}
示例#20
0
文件: lpc17_spi.c 项目: a1ien/nuttx
void  lpc17_spiselect(FAR struct spi_dev_s *dev, enum spi_dev_e devid, bool selected)
{
  spiinfo("devid: %d CS: %s\n", (int)devid, selected ? "assert" : "de-assert");
  spi_dumpgpio("lpc17_spiselect() Entry");

  if (devid == SPIDEV_MMCSD)
    {
      /* Assert/de-assert the CS pin to the card */

      (void)lpc17_gpiowrite(ZKITARM_SD_CS, !selected);
    }

  spi_dumpgpio("lpc17_spiselect() Exit");
}
示例#21
0
void board_led_off(int led)
{
  /* In all states, OFF can only mean turning off the HB LED */

  if (g_nestcount <= 1)
    {
      lpc17_gpiowrite(NUCLEUS2G_HEARTBEAT, true);
      g_nestcount = 0;
    }
  else
    {
      g_nestcount--;
    }
}
示例#22
0
void board_led_off(int led)
{
  /* In all states, OFF can only mean turning off the HB LED */

  if (g_nestcount <= 1)
    {
      lpc17_gpiowrite(ZKITARM_LED2, true);
      g_nestcount = 0;
    }
  else
    {
      g_nestcount--;
    }
}
示例#23
0
void  lpc17_ssp0select(FAR struct spi_dev_s *dev, enum spi_dev_e devid, bool selected)
{
  sspdbg("devid: %d CS: %s\n", (int)devid, selected ? "assert" : "de-assert");
  ssp_dumpgpio("lpc17_spi0select() Entry");

#ifdef CONFIG_NX_LCDDRIVER
  if (devid == SPIDEV_DISPLAY)
    {
      /* Assert the CS pin to the OLED display */

      (void)lpc17_gpiowrite(ZKITARM_OLED_CS, !selected);
    }
#endif

  ssp_dumpgpio("lpc17_spi0select() Exit");
}
示例#24
0
void board_led_on(int led)
{
  /* We will control LED1 and LED2 not yet completed the boot sequence. */

  if (!g_initialized)
    {
      enum lpc17_ledstate_e led1 = LPC17_LEDSTATE_OFF;
      enum lpc17_ledstate_e led2 = LPC17_LEDSTATE_OFF;
      switch (led)
        {
        case LED_STACKCREATED:
          g_initialized = true;
        case LED_STARTED:
        default:
          break;

        case LED_HEAPALLOCATE:
          led1 = LPC17_LEDSTATE_GREEN;
          break;

        case LED_IRQSENABLED:
          led2 = LPC17_LEDSTATE_GREEN;
        }
      lpc17_led1(led1);
      lpc17_led2(led2);
    }

  /* We will always control the HB LED */

  switch (led)
    {
    default:
      break;

    case LED_INIRQ:
    case LED_SIGNAL:
    case LED_ASSERTION:
    case LED_PANIC:
      lpc17_gpiowrite(NUCLEUS2G_HEARTBEAT, false);
      g_nestcount++;
    }
}
示例#25
0
static inline int lpc17_configoutput(lpc17_pinset_t cfgset, unsigned int port,
                                     unsigned int pin)
{
  uint32_t fiobase;
  uint32_t regval;

  /* First, configure the port as a generic input so that we have a known
   * starting point and consistent behavior during the re-configuration.
   */

  (void)lpc17_configinput(DEFAULT_INPUT, port, pin);

  /* Check for open drain output */

  if ((cfgset & GPIO_OPEN_DRAIN) != 0)
    {
      /* Set pull-up mode.  This normally only applies to input pins, but does have
       * meaning if the port is an open drain output.
       */

      lpc17_pullup(cfgset, port, pin);

      /* Select open drain output */

      lpc17_setopendrain(port, pin);
    }

  /* Set the initial value of the output */

  lpc17_gpiowrite(cfgset, ((cfgset & GPIO_VALUE) != GPIO_VALUE_ZERO));

  /* Now, reconfigure the pin as an output */

  fiobase = g_fiobase[port];
  regval  = getreg32(fiobase + LPC17_FIO_DIR_OFFSET);
  regval |= (1 << pin);
  putreg32(regval, fiobase + LPC17_FIO_DIR_OFFSET);


  return OK;
}
示例#26
0
void up_ledoff(int led)
{
  bool off;

  switch (led)
    {
	case 0:
	case 1:
	  off = false;
	  break;

	case 2:
	  off = g_ncstate;
	  break;

	default:
	  return;
	}

  lpc17_gpiowrite(LPCXPRESSO_LED, off);
}
示例#27
0
void board_autoled_off(int led)
{
  bool off;

  switch (led)
    {
    case 0:
    case 1:
      off = false;
      break;

    case 2:
      off = g_ncstate;
      break;

    default:
      return;
    }

  lpc17_gpiowrite(C027_LED, off);
}
示例#28
0
void lpc17_led(int lednum, int state)

{
  lpc17_gpiowrite(lednum, state);
}
示例#29
0
void ug_power(unsigned int devno, bool on)
{
  gllvdbg("power %s\n", on ? "ON" : "OFF");
  (void)lpc17_gpiowrite(LPCXPRESSO_OLED_POWER, on);
}
示例#30
0
void lpc17_backlight(bool blon)
{
  lpc17_gpiowrite(GPIO_LCD_BL, blon);
}