自学教程：C++ stm32_gpioread函数代码示例

voidADC::update_system_power(void){#ifdef CONFIG_ARCH_BOARD_PX4FMU_V2	system_power_s system_power;	system_power.timestamp = hrt_absolute_time();	system_power.voltage5V_v = 0;	for (unsigned i = 0; i < _channel_count; i++) {		if (_samples[i].am_channel == 4) {			// it is 2:1 scaled			system_power.voltage5V_v = _samples[i].am_data * (6.6f / 4096);		}	}	// these are not ADC related, but it is convenient to	// publish these to the same topic	system_power.usb_connected = stm32_gpioread(GPIO_OTGFS_VBUS);	// note that the valid pins are active low	system_power.brick_valid   = !stm32_gpioread(GPIO_VDD_BRICK_VALID);	system_power.servo_valid   = !stm32_gpioread(GPIO_VDD_SERVO_VALID);	// OC pins are active low	system_power.periph_5V_OC  = !stm32_gpioread(GPIO_VDD_5V_PERIPH_OC);	system_power.hipower_5V_OC = !stm32_gpioread(GPIO_VDD_5V_HIPOWER_OC);	/* lazily publish */	if (_to_system_power > 0) {		orb_publish(ORB_ID(system_power), _to_system_power, &system_power);	} else {		_to_system_power = orb_advertise(ORB_ID(system_power), &system_power);	}#endif // CONFIG_ARCH_BOARD_PX4FMU_V2}

__EXPORT void led_toggle(int led){	switch (led) {	case 0:		if (stm32_gpioread(GPIO_LED0)) {			stm32_gpiowrite(GPIO_LED0, false);		} else {			stm32_gpiowrite(GPIO_LED0, true);		}		break;	case 1:		if (stm32_gpioread(GPIO_LED1)) {			stm32_gpiowrite(GPIO_LED1, false);		} else {			stm32_gpiowrite(GPIO_LED1, true);		}		break;	default:		warnx("LED ID not recognized/n");	}}

uint8_t up_read_inputs(void){  uint8_t bits = 0;  bits |= stm32_gpioread(GPIO_D14) == 0 ? 1 : 0;  bits |= stm32_gpioread(GPIO_D15) == 0 ? 2 : 0;  bits |= stm32_gpioread(GPIO_A2)  == 0 ? 4 : 0;  bits |= stm32_gpioread(GPIO_A3)  == 0 ? 8 : 0;  return bits;}

uint8_t board_buttons(void){  uint8_t ret = 0;  int i;  /* Check that state of each key */  for (i = 0; i < NUM_BUTTONS; i++)    {       /* A LOW value means that the key is pressed for most keys.  The exception        * is the WAKEUP button.        */       bool released = stm32_gpioread(g_buttons[i]);       if (i == BUTTON_WAKEUP)         {           released = !released;         }       /* Accumulate the set of depressed (not released) keys */       if (!released)         {            ret |= (1 << i);         }    }  return ret;}

__END_DECLS/**************************************************************************** * Protected Functions ****************************************************************************//**************************************************************************** * Public Functions ****************************************************************************//************************************************************************************ * Name: board_peripheral_reset * * Description: * ************************************************************************************/__EXPORT void board_peripheral_reset(int ms){	bool last = stm32_gpioread(GPIO_SPEKTRUM_PWR_EN);	/* Keep Spektum on to discharge rail*/	stm32_gpiowrite(GPIO_SPEKTRUM_PWR_EN, 1);	/* wait for the peripheral rail to reach GND */	usleep(ms * 1000);	warnx("reset done, %d ms", ms);	/* re-enable power */	/* switch the peripheral rail back on */	stm32_gpiowrite(GPIO_SPEKTRUM_PWR_EN, last);}

/** * @brief           Measure the current consumption of a given spring. * @return          current consumption of a given spring (in microamps) * warning          'spring' index starts at 1, not 0. * @param[in]       spring: selected spring ([1..SPRING_COUNT]) * @param[out]      uA: selected spring current measurement, in microamps) */int spwrm_get_current(uint8_t spring, int32_t *uA){    int ret;    uint8_t adc, chan;    uint32_t spin, uV;    CHECK_SPRING(spring);    CHECK_NULL_ARG(uA);    adc = spwrm_get_adc_device(spring);    chan = spwrm_get_adc_channel(spring);    spin = spwrm_get_sign_pin(spring);    *uA = 0;    ret = adc_get_data(adc, chan, &uV);    if (ret) {        dbg_error("%s(): failed to get %s data! (%d)/n", __func__,                  spwrm_get_name(spring), ret);        return ret;    }    /* Convert to uV */    uV = adc_get_uV(uV);    /* Get data sign */    if (stm32_gpioread(spin) == 0) {        dbg_verbose("%s(): pin=0 => sign=-/n", __func__);        *uA = -((int32_t) max9929f_get_Iload(uV));    } else {        dbg_verbose("%s(): pin=1 => sign=+/n", __func__);        *uA = (int32_t) max9929f_get_Iload(uV);    }    dbg_verbose("%s(): measured voltage=%uuV => current=%duA/n",                __func__, uV, *uA);    return 0;}

int stm32_sdio_initialize(void){  int ret;#ifdef HAVE_NCD  /* Card detect */  bool cd_status;  /* Configure the card detect GPIO */  stm32_configgpio(GPIO_SDMMC1_NCD);  /* Register an interrupt handler for the card detect pin */  (void)stm32_gpiosetevent(GPIO_SDMMC1_NCD, true, true, true,                           stm32_ncd_interrupt, NULL);#endif  /* Mount the SDIO-based MMC/SD block driver */  /* First, get an instance of the SDIO interface */  finfo("Initializing SDIO slot %d/n", SDIO_SLOTNO);  g_sdio_dev = sdio_initialize(SDIO_SLOTNO);  if (!g_sdio_dev)    {      ferr("ERROR: Failed to initialize SDIO slot %d/n", SDIO_SLOTNO);      return -ENODEV;    }  /* Now bind the SDIO interface to the MMC/SD driver */  finfo("Bind SDIO to the MMC/SD driver, minor=%d/n", SDIO_MINOR);  ret = mmcsd_slotinitialize(SDIO_MINOR, g_sdio_dev);  if (ret != OK)    {      ferr("ERROR: Failed to bind SDIO to the MMC/SD driver: %d/n", ret);      return ret;    }  finfo("Successfully bound SDIO to the MMC/SD driver/n");#ifdef HAVE_NCD  /* Use SD card detect pin to check if a card is g_sd_inserted */  cd_status = !stm32_gpioread(GPIO_SDMMC1_NCD);  finfo("Card detect : %d/n", cd_status);  sdio_mediachange(g_sdio_dev, cd_status);#else  /* Assume that the SD card is inserted.  What choice do we have? */  sdio_mediachange(g_sdio_dev, true);#endif  return OK;}

uint32_t board_buttons(void){  uint32_t ret = 0;  ret = (stm32_gpioread(g_buttons[i]) == false ? 1 : 0);  return ret;}

__EXPORT void led_toggle(int led){	if (led == 0)	{		if (stm32_gpioread(GPIO_LED1))			stm32_gpiowrite(GPIO_LED1, false);		else			stm32_gpiowrite(GPIO_LED1, true);	}	if (led == 1)	{		if (stm32_gpioread(GPIO_LED2))			stm32_gpiowrite(GPIO_LED2, false);		else			stm32_gpiowrite(GPIO_LED2, true);	}}

__EXPORT void led_toggle(int led){	const uint32_t param = _led_param_get(led);	if (param) {		stm32_gpiowrite(param, !stm32_gpioread(param));	}}

uint8_t board_buttons(void){  /* Check that state of each USER button. A LOW value means that the key is   * pressed.   */  bool released = stm32_gpioread(GPIO_BTN_USER);  return !released;}

uint8_t up_buttons(void){  uint8_t ret = 0;  /* Check that state of each key.  A LOW value means that the key is pressed, */  if (!stm32_gpioread(GPIO_BTN_KEY1))    {      ret |= BUTTON_KEY1_BIT;    }  if (!stm32_gpioread(GPIO_BTN_KEY2))    {      ret |= BUTTON_KEY2_BIT;    }  return ret;}

uint32_tPX4FMU::gpio_read(void){	uint32_t bits = 0;	for (unsigned i = 0; i < _ngpio; i++)		if (stm32_gpioread(_gpio_tab[i].input))			bits |= (1 << i);	return bits;}

__EXPORT void buzzer_toggle(int buzzer){	if (buzzer == 0)	{#if defined(GPIO_BUZZER)		if (stm32_gpioread(GPIO_BUZZER))			stm32_gpiowrite(GPIO_BUZZER, false);		else			stm32_gpiowrite(GPIO_BUZZER, true);#endif	}}

static int determin_hw_version(int *version, int *revision){	*revision = 0; /* default revision */	int rv = 0;	int pos = 0;	stm32_configgpio(GPIO_PULLDOWN | (HW_VER_PB4 & ~GPIO_PUPD_MASK));	up_udelay(10);	rv |= stm32_gpioread(HW_VER_PB4) << pos++;	stm32_configgpio(HW_VER_PB4);	up_udelay(10);	rv |= stm32_gpioread(HW_VER_PB4) << pos++;	int votes = 16;	int ones[2] = {0, 0};	int zeros[2] = {0, 0};	while (votes--) {		stm32_configgpio(GPIO_PULLDOWN | (HW_VER_PB12 & ~GPIO_PUPD_MASK));		up_udelay(10);		stm32_gpioread(HW_VER_PB12) ? ones[0]++ : zeros[0]++;		stm32_configgpio(HW_VER_PB12);		up_udelay(10);		stm32_gpioread(HW_VER_PB12) ? ones[1]++ : zeros[1]++;	}	if (ones[0] > zeros[0]) {		rv |= 1 << pos;	}	pos++;	if (ones[1] > zeros[1]) {		rv |= 1 << pos;	}	stm32_configgpio(HW_VER_PB4_INIT);	stm32_configgpio(HW_VER_PB12_INIT);	*version = rv;	return OK;}

uint8_t board_buttons(void){  uint8_t ret = 0;  /* Check that state of each key */  if (!stm32_gpioread(g_buttons[BUTTON_BUT]))    {      ret |= BUTTON_BUT_BIT;    }  return ret;}

uint8_t stm32_spi1status(FAR struct spi_dev_s *dev, enum spi_dev_e devid){  /* The card detect pin is pulled up so that we detect the presence of a card   * by see a low value on the input pin.   */  if (stm32_gpioread(GPIO_SD_CD))    {      return 0;    }  return SPI_STATUS_PRESENT;}

static int stm32_ncd_interrupt(int irq, FAR void *context){  bool present;  present = !stm32_gpioread(GPIO_SDMMC1_NCD);  if (g_sdio_dev && present != g_sd_inserted)    {      sdio_mediachange(g_sdio_dev, present);      g_sd_inserted = present;    }  return OK;}

int nsh_archinitialize(void){#ifdef NSH_HAVEMMCSD  int ret;  /* Card detect */  bool cd_status;  /* Configure the card detect GPIO */  stm32_configgpio(GPIO_SD_CD);  /* Register an interrupt handler for the card detect pin */  stm32_gpiosetevent(GPIO_SD_CD, true, true, true, nsh_cdinterrupt);  /* Mount the SDIO-based MMC/SD block driver */  /* First, get an instance of the SDIO interface */  message("nsh_archinitialize: Initializing SDIO slot %d/n",          CONFIG_NSH_MMCSDSLOTNO);  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 */  message("nsh_archinitialize: Bind SDIO to the MMC/SD driver, minor=%d/n",          CONFIG_NSH_MMCSDMINOR);  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;    }  dbg("nsh_archinitialize: Successfully bound SDIO to the MMC/SD driver/n");  /* Use SD card detect pin to check if a card is inserted */  cd_status = !stm32_gpioread(GPIO_SD_CD);  vdbg("Card detect : %hhu/n", cd_status);  sdio_mediachange(g_sdiodev, cd_status);#endif  return OK;}

voidADC::update_system_power(hrt_abstime now){#if defined (CONFIG_ARCH_BOARD_PX4FMU_V2) || /    defined (CONFIG_ARCH_BOARD_MINDPX_V2) || /    defined (CONFIG_ARCH_BOARD_PX4FMU_V4)	system_power_s system_power = {};	system_power.timestamp = now;	system_power.voltage5V_v = 0;	for (unsigned i = 0; i < _channel_count; i++) {		if (_samples[i].am_channel == ADC_5V_RAIL_SENSE) {			// it is 2:1 scaled			system_power.voltage5V_v = _samples[i].am_data * (6.6f / 4096);		}	}	// these are not ADC related, but it is convenient to	// publish these to the same topic	system_power.usb_connected = stm32_gpioread(GPIO_OTGFS_VBUS);#if defined (CONFIG_ARCH_BOARD_MINDPX_V2)	// note that the valid pins are active low	system_power.brick_valid   = 1;	system_power.servo_valid   = 1;	// OC pins are active low	system_power.periph_5V_OC  = 1;	system_power.hipower_5V_OC = 1;#elif defined (CONFIG_ARCH_BOARD_PX4FMU_V4)	// note that the valid pins are active high	system_power.brick_valid   = stm32_gpioread(GPIO_VDD_BRICK_VALID);	system_power.servo_valid   = 1;	// OC pins are not supported	system_power.periph_5V_OC  = 0;	system_power.hipower_5V_OC = 0;#else	// note that the valid pins are active low	system_power.brick_valid   = !stm32_gpioread(GPIO_VDD_BRICK_VALID);	system_power.servo_valid   = !stm32_gpioread(GPIO_VDD_SERVO_VALID);	// OC pins are active low	system_power.periph_5V_OC  = !stm32_gpioread(GPIO_VDD_5V_PERIPH_OC);	system_power.hipower_5V_OC = !stm32_gpioread(GPIO_VDD_5V_HIPOWER_OC);#endif	/* lazily publish */	if (_to_system_power != nullptr) {		orb_publish(ORB_ID(system_power), _to_system_power, &system_power);	} else {		_to_system_power = orb_advertise(ORB_ID(system_power), &system_power);	}#endif // CONFIG_ARCH_BOARD_PX4FMU_V2}

__END_DECLS/**************************************************************************** * Private Functions ****************************************************************************/static int _bootloader_force_pin_callback(int irq, void *context){	if (stm32_gpioread(GPIO_FORCE_BOOTLOADER)) {		up_systemreset();	}	return 0;}

static int nsh_cdinterrupt(int irq, FAR void *context){  static bool inserted = 0xff; /* Impossible value */  bool present;  present = !stm32_gpioread(GPIO_SD_CD);  if (present != inserted)    {      sdio_mediachange(g_sdiodev, present);      inserted = present;    }  return OK;}

void stm32_spi2select(FAR struct spi_dev_s *dev, enum spi_dev_e devid, bool selected){    spidbg("devid: %d CS: %s/n", (int)devid, selected ? "assert" : "de-assert");        if (devid == SPIDEV_WIRELESS) {            stm32_gpiowrite(GPIO_CC1101_CS, !selected);        /* Wait for MISO to go low, indicates that Quart has stabilized */        if (selected) {            while( stm32_gpioread(GPIO_SPI2_MISO) ) up_waste();        }            }}

static uint8_t stm32_gpio_get(void *driver_data, uint8_t pin){    uint32_t cfgset;    int ret;    lldbg("%s: pin=%hhu/n", __func__, pin);    ret = map_pin_nr_to_cfgset(pin, &cfgset);    if (ret) {        lldbg("%s: Invalid pin %hhu/n", pin);        return -EINVAL;    }    return stm32_gpioread(cfgset);}

uint8_t stm32_spi3status(FAR struct spi_dev_s *dev, enum spi_dev_e devid){  uint8_t ret = 0;#if defined(CONFIG_MMCSD)  if (devid == SPIDEV_MMCSD)    {      /* A low value indicates the card is present */      if (!stm32_gpioread(GPIO_SD_CD))        {          ret = SPI_STATUS_PRESENT;        }    }#endif  return ret;}

void sif_gpio2_update(void){    uint32_t val;    switch(vsn_sif.gpio[1]) {        case VSN_SIF_GPIO_HIGHZ:    val = GPIO_GP2_HIZ; break;        case VSN_SIF_GPIO_PULLUP:   val = GPIO_GP2_PUP; break;        case VSN_SIF_GPIO_PULLDOWN: val = GPIO_GP2_PDN; break;        case VSN_SIF_GPIO_OUTLOW:   val = GPIO_GP2_LOW; break;        case VSN_SIF_GPIO_OUTHIGH:  val = GPIO_GP2_HIGH;break;        default: return;    }    if (stm32_configgpio(val) == ERROR)        printf("Error updating2/n");    if (stm32_gpioread(val))        vsn_sif.gpio[1] |= VSN_SIF_GPIO_READ_MASK;    else vsn_sif.gpio[1] &= ~VSN_SIF_GPIO_READ_MASK;}

uint8_t up_buttons(void){  uint8_t ret = 0;  int i;  /* Check that state of each key */  for (i = 0; i < NUM_BUTTONS; i++)    {       /* A LOW value means that the key is pressed */       if (!stm32_gpioread(g_buttons[i]))         {           ret |= (1 << i);         }    }  return ret;}

static ajoy_buttonset_t ajoy_buttons(FAR const struct ajoy_lowerhalf_s *lower){  ajoy_buttonset_t ret = 0;  int i;  /* Read each joystick GPIO value */  for (i = 0; i < AJOY_NGPIOS; i++)    {      /* Button outputs are pulled high. So a sensed low level means that the       * button is pressed.       */      if (!stm32_gpioread(g_joygpio[i]))        {          ret |= (1 << i);        }    }  iinfo("Returning: %02x/n", ret);  return ret;}

static bool read_hwid_bit(uint32_t gpio){    bool level;    /*     * Configure the pin as input pull-up. A '0' state if forced by installing     * a pull-down resistor.     */    stm32_configgpio(gpio | GPIO_PULLUP);    /* Read level */    level = stm32_gpioread(gpio);    /*     * To minimize power consumption, if level reads '0' configure the pin     * as input pull-down.     */    if (!level) {        stm32_configgpio(gpio | GPIO_PULLDOWN);    }    return level;}

uint8_t up_buttons(void){  uint8_t ret = 0;  int i;  /* Check that state of each key */  for (i = 0; i < NUM_BUTTONS; i++)    {       /* A LOW value means that the key is pressed.        */       bool released = stm32_gpioread(g_buttons[i]);       /* Accumulate the set of depressed (not released) keys */       if (!released)         {            ret |= (1 << i);         }    }  return ret;}