C++ palReadPad函数代码示例

/*
 * Application entry point.
 */
int main(void) {

  /*
   * System initializations.
   * - HAL initialization, this also initializes the configured device drivers
   *   and performs the board-specific initializations.
   * - Kernel initialization, the main() function becomes a thread and the
   *   RTOS is active.
   */
  halInit();
  chSysInit();

  palSetPad(IOPORT1, LED1);

  WDGConfig WDG_config = {
    .pause_on_sleep = 0,
    .pause_on_halt  = 0,
    .timeout_ms     = 5000,
    .callback       = timeout_callback
  };

  wdgStart(&WDGD1, &WDG_config);

  /*
   * Normal main() thread activity, in this demo it does nothing.
   */
  while (true) {
    if (palReadPad(IOPORT1, BTN1) == 0) {
      palTogglePad(IOPORT1, LED1);
      wdgReset(&WDGD1);
    }
    chThdSleepMilliseconds(500);
  }
}

/**
 * @brief Single word read from the SSI encoder
 * @return Most recent SSI byte (may also be buffered in stream mode)
 */
uint32_t ssi_read(void)
{
	uint8_t bit = SSI_LENGTH; // Set length counter
	uint32_t working_buffer = 0;
	if(ssi_mode == SSI_MODE_STREAM)
	{
		led_count = (led_count+1)%25;// LED handling
		if(!led_count)
			led_toggle();
	}
	while(bit > 0)
	{
		// Falling edge
		palClearPad(SSI_SIGNAL_PORT, SSI_CLK_PIN);	// Toggle clock
		ssi_delay();
		ssi_delay();
		ssi_delay();
		// Rising edge
		palSetPad(SSI_SIGNAL_PORT, SSI_CLK_PIN);	// Toggle clock
		working_buffer = (working_buffer << 1) + palReadPad(SSI_SIGNAL_PORT, SSI_DATA_PIN);
		ssi_delay();
		bit--;	// Decrement bit counter
	}
	working_buffer = ((1<<SSI_LENGTH) - 1) & (~working_buffer); // Invert bits in buffer to simulate 
	return working_buffer;
}

static msg_t Th2(void *p) {
  (void)p;
  chRegSetThreadName("Th2");

  while (TRUE) {


    /////DEVICE 2///////////
    if(palReadPad(GPIO1_PORT, GPIO1_PAD) != PAL_HIGH)
    {
      palWritePad(GPIO22_PORT,GPIO22_PAD,PAL_HIGH);
      chSemWait(&mySemaphore);
      	chprintf((BaseSequentialStream *)&SD1, "D2ON\r\n");
      chSemSignal(&mySemaphore);

    }else{
      palWritePad(GPIO22_PORT,GPIO22_PAD,PAL_LOW);
      chSemWait(&mySemaphore);
	    chprintf((BaseSequentialStream *)&SD1, "D2OFF\r\n");
	   chSemSignal(&mySemaphore);
    }

      chThdSleepMilliseconds(1000);
  }

  return 0;

}

/*
 * Application entry point.
 */
int main(void) {
  halInit();
  chSysInit();

  /*
   * Serial port initialization.
   */
  sdStart(&SD1, NULL); 
  chprintf((BaseSequentialStream *)&SD1, "BCM2835 GPIO Demonstration\r\n");

  ioportid_t ledPort = ONBOARD_LED_PORT;
  uint32_t ledPad = ONBOARD_LED_PAD;

  palSetPadMode(ledPort, ledPad, PAL_MODE_OUTPUT);
  palSetPad(ledPort, ledPad);

  palSetPadMode(GPIO4_PORT, GPIO4_PAD, PAL_MODE_INPUT_PULLUP);

  for (;;) {
    uint32_t button_state = palReadPad(GPIO4_PORT, GPIO4_PAD);
    if (button_state) {
      palSetPad(ledPort, ledPad);
    }
    else {
      palClearPad(ledPort, ledPad);
    }
  }

  /*
   * Events servicing loop.
   */
  chThdWait(chThdSelf());

  return 0;
}

/*
 * Application entry point.
 */
int main(void) {

  /*
   * System initializations.
   * - HAL initialization, this also initializes the configured device drivers
   *   and performs the board-specific initializations.
   * - Kernel initialization, the main() function becomes a thread and the
   *   RTOS is active.
   */
  halInit();
  chSysInit();

  /*
   * Activates the serial driver 2 using the driver default configuration.
   */
  sdStart(&SD2, NULL);

  /*
   * Starts the LED blinker thread.
   */
  chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);

  while(TRUE) {
    if (!palReadPad(IOPORT5, PORTE_BUTTON))
      TestThread(&SD2);
    chThdSleepMilliseconds(500);
  }

  return 0;
}

/*
 * Application entry point.
 */
int main(void) {

  /*
   * System initializations.
   * - HAL initialization, this also initializes the configured device drivers
   *   and performs the board-specific initializations.
   * - Kernel initialization, the main() function becomes a thread and the
   *   RTOS is active.
   */
  halInit();
  chSysInit();

  /*
   * Activates the serial driver 2 using the driver default configuration.
   * PA2(TX) and PA3(RX) are routed to USART2.
   */
  sdStart(&SD2, NULL);
  palSetPadMode(GPIOA, 2, PAL_MODE_ALTERNATE(7));
  palSetPadMode(GPIOA, 3, PAL_MODE_ALTERNATE(7));

  /*
   * Creates the example thread.
   */
  chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);

  /*
   * Normal main() thread activity, in this demo it just performs
   * a shell respawn upon its termination.
   */
  while (TRUE) {
    if (palReadPad(GPIOA, GPIOA_BUTTON))
      TestThread(&SD2);
    chThdSleepMilliseconds(500);
  }
}

/**
 * @brief   SDC card detection.
 */
bool_t sdc_lld_is_card_inserted(SDCDriver *sdcp) {
  static bool_t last_status = FALSE;

  if (blkIsTransferring(sdcp))
    return last_status;
  return last_status = (bool_t)palReadPad(GPIOC, GPIOC_SD_D3);
}

/*Callback function for the interrupt on RC Channel 4.
 */
static void extcb4(EXTDriver *extp, expchannel_t channel) {
  (void)extp ;
  (void)channel ;

  chSysLockFromIsr() ;
  if(palReadPad(RC4_PORT, RC4_PIN) == PAL_HIGH) {
    start[3] = halGetCounterValue() ;
  }
  else if(start[3] && (palReadPad(RC4_PORT, RC4_PIN) == PAL_LOW)) {
    float tmp = convertCounterToMilliseconds(start[3], halGetCounterValue()) ;
    if(RC_IN_RANGE(tmp))
      RCInput[3] = tmp ;
    start[3] = 0 ;
  }
  chSysUnlockFromIsr() ;
}

/*
 * Entry point, note, the main() function is already a thread in the system
 * on entry.
 */
int main(int argc, char **argv) {

  (void)argc;
  (void)argv;

  /*
   * Activates the serial driver 2 using the driver default configuration.
   */
  sdStart(&SD2, NULL);

  /*
   * Creates the blinker thread.
   */
  chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);

  /*
   * Normal main() thread activity, in this demo it does nothing except
   * sleeping in a loop and check the button state.
   */
  while (TRUE) {
    if (palReadPad(IOPORT1, GPIOA_BUTTON))
      TestThread(&SD2);
    chThdSleepMilliseconds(500);
  }
  return 0;
}

/*
 * Application entry point.
 */
void main(void) {

  /*
   * System initializations.
   * - HAL initialization, this also initializes the configured device drivers
   *   and performs the board-specific initializations.
   * - Kernel initialization, the main() function becomes a thread and the
   *   RTOS is active.
   */
  halInit();
  chSysInit();

  /*
   * Activates the serial driver 1 using the driver default configuration.
   * The STM8L-Discovery requires USART1 pins remapping on PA2 and PA3.
   */
  SYSCFG->RMPCR1 = 0x1C;
  sdStart(&SD1, NULL);

  /*
   * Creates the blinker thread.
   */
  chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);

  /*
   * Normal main() thread activity.
   */
  while (TRUE) {
    if (palReadPad(GPIOC, PC_BUTTON) == PAL_LOW)
      TestThread(&SD1);
    chThdSleepMilliseconds(1000);
  }
}

/**
 * @brief Function for detecting stuck slaves (SDA = 0 and SCL = 1) and tries to clear the bus.
 *
 * @return
 * @retval false Bus is stuck.
 * @retval true Bus is clear.
 */
static void i2c_clear_bus(I2CDriver *i2cp) {
  const I2CConfig *cfg = i2cp->config;
  uint8_t i;

  IOPORT1->PIN_CNF[cfg->scl_pad] = I2C_PIN_CNF;
  IOPORT1->PIN_CNF[cfg->sda_pad] = I2C_PIN_CNF;

  I2C_HIGH(cfg->sda_pad);
  I2C_HIGH(cfg->scl_pad);

  IOPORT1->PIN_CNF[cfg->scl_pad] = I2C_PIN_CNF_CLR;
  IOPORT1->PIN_CNF[cfg->sda_pad] = I2C_PIN_CNF_CLR;

  nrf_delay_us(4);

  for(i = 0; i < 9; i++) {
    if (palReadPad(IOPORT1, cfg->sda_pad)) {
      if(i > 0)
        break;
      else
        return;
    }

    I2C_LOW(cfg->scl_pad);
    nrf_delay_us(4);
    I2C_HIGH(cfg->scl_pad);
    nrf_delay_us(4);
  }

  I2C_LOW(cfg->sda_pad);
  nrf_delay_us(4);
  I2C_HIGH(cfg->sda_pad);
}

/*
 * Application entry point.
 */
int main(void) {

  /*
   * System initializations.
   * - HAL initialization, this also initializes the configured device drivers
   *   and performs the board-specific initializations.
   * - Kernel initialization, the main() function becomes a thread and the
   *   RTOS is active.
   */
  halInit();
  chSysInit();

  /*
   * Activates the serial driver 2 using the driver default configuration.
   */
  sdStart(&SD2, NULL);

  /*
   * Creates the blinker thread.
   */
  chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);

  /*
   * Normal main() thread activity, in this demo it does nothing except
   * sleeping in a loop and check the button state.
   */
  while (true) {
    if (!palReadPad(GPIOC, GPIOC_BUTTON))
      TestThread(&SD2);
    chThdSleepMilliseconds(500);
  }
}

/**
 * Reset the encoder counter. Should be called from the index interrupt.
 */
void encoder_reset(void) {
	// Only reset if the pin is still high to avoid too short pulses, which
	// most likely are noise.
	__NOP();
	__NOP();
	__NOP();
	__NOP();
	if (palReadPad(HW_HALL_ENC_GPIO3, HW_HALL_ENC_PIN3)) {
		const unsigned int cnt = HW_ENC_TIM->CNT;
		static int bad_pulses = 0;
		const unsigned int lim = enc_counts / 20;

		if (index_found) {
			// Some plausibility filtering.
			if (cnt > (enc_counts - lim) || cnt < lim) {
				HW_ENC_TIM->CNT = 0;
				bad_pulses = 0;
			} else {
				bad_pulses++;

				if (bad_pulses > 5) {
					index_found = 0;
				}
			}
		} else {
			HW_ENC_TIM->CNT = 0;
			index_found = true;
			bad_pulses = 0;
		}
	}
}

/*
 * Application entry point.
 */
int main(void) {

  /*
   * System initializations.
   * - HAL initialization, this also initializes the configured device drivers
   *   and performs the board-specific initializations.
   * - Kernel initialization, the main() function becomes a thread and the
   *   RTOS is active.
   */
  halInit();
  chSysInit();

  /*
   * Activates the SD1 and SPI1 drivers.
   */
  sdStart(&SD4, NULL);                  /* Default: 38400,8,N,1.            */

  /*
   * Creates the blinker threads.
   */
  chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);

  /*
   * Normal main() thread activity.
   */

  while (TRUE) {
    if (!palReadPad(GPIO3, GPIO3_SW_USER1)) {
      TestThread(&SD4);
    }
    chThdSleepMilliseconds(100);
  }
}

bool_t pyro_continuity(uint8_t pad)
{
    if((palReadPad(GPIOE, pad)) == PAL_LOW)
        return TRUE;
    else
        return FALSE;
}