(reg) |= (mask); \
} while (0)
-#define ao_spi_get_bit(reg,bit,pin,bus,speed) ao_spi_get_mask(reg,(1<<(bit)),bus,speed)
+#define ao_spi_get_bit(reg,bit,bus,speed) ao_spi_get_mask(reg,(1<<(bit)),bus,speed)
-#define ao_spi_put_bit(reg,bit,pin,bus) ao_spi_put_mask(reg,(1<<(bit)),bus)
+#define ao_spi_put_bit(reg,bit,bus) ao_spi_put_mask(reg,(1<<(bit)),bus)
#define ao_gpio_token_paster(x,y) x ## y
#define ao_gpio_token_evaluator(x,y) ao_gpio_token_paster(x,y)
-#define ao_gpio_set(port, bit, pin, v) do { \
+#define ao_gpio_set(port, bit, v) do { \
if (v) \
PORTB |= (1 << bit); \
else \
PORTB &= ~(1 << bit); \
} while (0)
-#define ao_gpio_get(port, bit, pin) ((PORTB >> (bit)) & 1)
+#define ao_gpio_get(port, bit) ((PORTB >> (bit)) & 1)
/*
* The SPI mutex must be held to call either of these
* from chip select low to chip select high
*/
-#define ao_enable_output(port, bit, pin, v) do { \
- ao_gpio_set(port, bit, pin, v); \
+#define ao_enable_output(port, bit, v) do { \
+ ao_gpio_set(port, bit, v); \
ao_gpio_token_evaluator(DDR,port) |= (1 << bit); \
} while (0)
ao_mutex_put(&ao_spi_mutex); \
} while (0)
-#define ao_spi_get_bit(reg,bit,pin,bus,speed) do { \
+#define ao_spi_get_bit(reg,bit,bus,speed) do { \
ao_mutex_get(&ao_spi_mutex); \
(pin) = 0; \
} while (0)
-#define ao_spi_put_bit(reg,bit,pin,bus) do { \
+#define ao_spi_put_bit(reg,bit,bus) do { \
(pin) = 1; \
ao_mutex_put(&ao_spi_mutex); \
} while (0)
#define ao_gpio_token_paster(x,y) x ## y
#define ao_gpio_token_evaluator(x,y) ao_gpio_token_paster(x,y)
-#define ao_gpio_set(port, bit, pin, v) do { \
+#define ao_gpio_set(port, bit, v) do { \
if (v) \
(ao_gpio_token_evaluator(PORT,port)) |= (1 << bit); \
else \
* from chip select low to chip select high
*/
-#define ao_enable_output(port, bit, pin, v) do { \
- ao_gpio_set(port, bit, pin, v); \
+#define ao_enable_output(port, bit, v) do { \
+ ao_gpio_set(port, bit, v); \
ao_gpio_token_evaluator(DDR,port) |= (1 << bit); \
} while (0)
);
#else
ao_arch_block_interrupts();
- if (ao_gpio_get(AO_BTM_INT_PORT, AO_BTM_INT_PIN, AO_BTM_INT) == 0) {
+ if (ao_gpio_get(AO_BTM_INT_PORT, AO_BTM_INT_PIN) == 0) {
ao_btm_connected = 1;
} else {
ao_btm_connected = 0;
ao_serial_btm_set_speed(AO_SERIAL_SPEED_19200);
#ifdef AO_BTM_RESET_PORT
- ao_enable_output(AO_BTM_RESET_PORT,AO_BTM_RESET_PIN,AO_BTM_RESET,0);
+ ao_enable_output(AO_BTM_RESET_PORT,AO_BTM_RESET_PIN,0);
#endif
#ifdef AO_BTM_INT_PORT
#define port(q) AO_BUTTON_ ## q ## _PORT
#define bit(q) AO_BUTTON_ ## q
-#define pin(q) AO_BUTTON_ ## q ## _PIN
#ifndef AO_BUTTON_INVERTED
#define AO_BUTTON_INVERTED 1
#if AO_BUTTON_INVERTED
/* pins are inverted */
-#define ao_button_value(b) !ao_gpio_get(port(b), bit(b), pin(b))
+#define ao_button_value(b) !ao_gpio_get(port(b), bit(b))
#else
-#define ao_button_value(b) ao_gpio_get(port(b), bit(b), pin(b))
+#define ao_button_value(b) ao_gpio_get(port(b), bit(b))
#endif
static uint8_t
static uint8_t
ao_radio_int_pin(void)
{
- return ao_gpio_get(AO_CC1120_INT_PORT, AO_CC1120_INT_PIN, AO_CC1120_INT);
+ return ao_gpio_get(AO_CC1120_INT_PORT, AO_CC1120_INT_PIN);
}
#if CC1120_DEBUG
static uint8_t
ao_radio_int_pin(void)
{
- return ao_gpio_get(AO_CC1200_INT_PORT, AO_CC1200_INT_PIN, AO_CC1200_INT);
+ return ao_gpio_get(AO_CC1200_INT_PORT, AO_CC1200_INT_PIN);
}
static uint8_t
#define COMPANION_SELECT() do { \
ao_spi_get_bit(AO_COMPANION_CS_PORT, \
AO_COMPANION_CS_PIN, \
- AO_COMPANION_CS, \
AO_COMPANION_SPI_BUS, \
AO_SPI_SPEED_200kHz); \
} while (0)
#define COMPANION_DESELECT() do { \
ao_spi_put_bit(AO_COMPANION_CS_PORT, \
AO_COMPANION_CS_PIN, \
- AO_COMPANION_CS, \
AO_COMPANION_SPI_BUS); \
} while (0)
void
ao_companion_init(void)
{
- ao_enable_output(AO_COMPANION_CS_PORT, AO_COMPANION_CS_PIN, AO_COMPANION_CS, 1);
+ ao_enable_output(AO_COMPANION_CS_PORT, AO_COMPANION_CS_PIN, 1);
ao_cmd_register(&ao_companion_cmds[0]);
ao_add_task(&ao_companion_task, ao_companion, "companion");
}
ao_mma655x_start(void) {
ao_spi_get_bit(AO_MMA655X_CS_PORT,
AO_MMA655X_CS_PIN,
- AO_MMA655X_CS,
AO_MMA655X_SPI_INDEX,
AO_SPI_SPEED_FAST);
}
ao_mma655x_stop(void) {
ao_spi_put_bit(AO_MMA655X_CS_PORT,
AO_MMA655X_CS_PIN,
- AO_MMA655X_CS,
AO_MMA655X_SPI_INDEX);
}
static void
ao_mma655x_restart(void) {
uint8_t i;
- ao_gpio_set(AO_MMA655X_CS_PORT, AO_MMA655X_CS_PIN, AO_MMA655X_CS, 1);
+ ao_gpio_set(AO_MMA655X_CS_PORT, AO_MMA655X_CS_PIN, 1);
/* Emperical testing on STM32L151 at 32MHz for this delay amount */
for (i = 0; i < 10; i++)
ao_arch_nop();
- ao_gpio_set(AO_MMA655X_CS_PORT, AO_MMA655X_CS_PIN, AO_MMA655X_CS, 0);
+ ao_gpio_set(AO_MMA655X_CS_PORT, AO_MMA655X_CS_PIN, 0);
}
static uint8_t
static void
ao_ms5607_start(void) {
- ao_spi_get_bit(AO_MS5607_CS_PORT, AO_MS5607_CS_PIN, AO_MS5607_CS, AO_MS5607_SPI_INDEX, AO_MS5607_SPI_SPEED);
+ ao_spi_get_bit(AO_MS5607_CS_PORT, AO_MS5607_CS_PIN, AO_MS5607_SPI_INDEX, AO_MS5607_SPI_SPEED);
}
static void
ao_ms5607_stop(void) {
- ao_spi_put_bit(AO_MS5607_CS_PORT, AO_MS5607_CS_PIN, AO_MS5607_CS, AO_MS5607_SPI_INDEX);
+ ao_spi_put_bit(AO_MS5607_CS_PORT, AO_MS5607_CS_PIN, AO_MS5607_SPI_INDEX);
}
static void
ao_spi_put(AO_MS5607_SPI_INDEX);
#endif
ao_arch_block_interrupts();
- while (!ao_gpio_get(AO_MS5607_MISO_PORT, AO_MS5607_MISO_PIN, AO_MS5607_MISO) &&
+ while (!ao_gpio_get(AO_MS5607_MISO_PORT, AO_MS5607_MISO_PIN) &&
!ao_ms5607_done)
ao_sleep((void *) &ao_ms5607_done);
ao_arch_release_interrupts();
ao_siren(uint8_t v)
{
#ifdef AO_SIREN
- ao_gpio_set(AO_SIREN_PORT, AO_SIREN_PIN, AO_SIREN, v);
+ ao_gpio_set(AO_SIREN_PORT, AO_SIREN_PIN, v);
#else
#if HAS_BEEP
ao_beep(v ? AO_BEEP_MID : 0);
ao_strobe(uint8_t v)
{
#ifdef AO_STROBE
- ao_gpio_set(AO_STROBE_PORT, AO_STROBE_PIN, AO_STROBE, v);
+ ao_gpio_set(AO_STROBE_PORT, AO_STROBE_PIN, v);
#else
(void) v;
#endif
}
#endif
#if AO_PAD_NUM > 0
- ao_enable_output(AO_PAD_0_PORT, AO_PAD_PIN_0, AO_PAD_0, 0);
+ ao_enable_output(AO_PAD_0_PORT, AO_PAD_PIN_0, 0);
#endif
#if AO_PAD_NUM > 1
- ao_enable_output(AO_PAD_1_PORT, AO_PAD_PIN_1, AO_PAD_1, 0);
+ ao_enable_output(AO_PAD_1_PORT, AO_PAD_PIN_1, 0);
#endif
#if AO_PAD_NUM > 2
- ao_enable_output(AO_PAD_2_PORT, AO_PAD_PIN_2, AO_PAD_2, 0);
+ ao_enable_output(AO_PAD_2_PORT, AO_PAD_PIN_2, 0);
#endif
#if AO_PAD_NUM > 3
- ao_enable_output(AO_PAD_3_PORT, AO_PAD_PIN_3, AO_PAD_3, 0);
+ ao_enable_output(AO_PAD_3_PORT, AO_PAD_PIN_3, 0);
#endif
#if AO_PAD_NUM > 4
- ao_enable_output(AO_PAD_4_PORT, AO_PAD_PIN_4, AO_PAD_4, 0);
+ ao_enable_output(AO_PAD_4_PORT, AO_PAD_PIN_4, 0);
#endif
#if AO_PAD_NUM > 5
- ao_enable_output(AO_PAD_5_PORT, AO_PAD_PIN_5, AO_PAD_5, 0);
+ ao_enable_output(AO_PAD_5_PORT, AO_PAD_PIN_5, 0);
#endif
#if AO_PAD_NUM > 5
- ao_enable_output(AO_PAD_6_PORT, AO_PAD_PIN_6, AO_PAD_6, 0);
+ ao_enable_output(AO_PAD_6_PORT, AO_PAD_PIN_6, 0);
#endif
#if AO_PAD_NUM > 7
- ao_enable_output(AO_PAD_7_PORT, AO_PAD_PIN_7, AO_PAD_7, 0);
+ ao_enable_output(AO_PAD_7_PORT, AO_PAD_PIN_7, 0);
#endif
#ifdef AO_STROBE
- ao_enable_output(AO_STROBE_PORT, AO_STROBE_PIN, AO_STROBE, 0);
+ ao_enable_output(AO_STROBE_PORT, AO_STROBE_PIN, 0);
#endif
#ifdef AO_SIREN
- ao_enable_output(AO_SIREN_PORT, AO_SIREN_PIN, AO_SIREN, 0);
+ ao_enable_output(AO_SIREN_PORT, AO_SIREN_PIN, 0);
#endif
ao_cmd_register(&ao_pad_cmds[0]);
ao_add_task(&ao_pad_task, ao_pad, "pad listener");
ao_arch_release_interrupts();
/* pull the clock pin down */
- ao_enable_output(AO_PS2_CLOCK_PORT, AO_PS2_CLOCK_BIT, AO_PS2_CLOCK_PIN, 0);
+ ao_enable_output(AO_PS2_CLOCK_PORT, AO_PS2_CLOCK_BIT, 0);
ao_delay(0);
/* pull the data pin down for the start bit */
- ao_enable_output(AO_PS2_DATA_PORT, AO_PS2_DATA_BIT, AO_PS2_DATA_PIN, 0);
+ ao_enable_output(AO_PS2_DATA_PORT, AO_PS2_DATA_BIT, 0);
ao_delay(0);
/* switch back to input mode for the interrupt to work */
uint8_t bit;
if (ao_ps2_tx_count) {
- ao_gpio_set(AO_PS2_DATA_PORT, AO_PS2_DATA_BIT, AO_PS2_DATA_PIN, ao_ps2_tx&1);
+ ao_gpio_set(AO_PS2_DATA_PORT, AO_PS2_DATA_BIT, ao_ps2_tx&1);
ao_ps2_tx >>= 1;
ao_ps2_tx_count--;
if (!ao_ps2_tx_count) {
ao_ps2_count = 0;
ao_ps2_tick = ao_tick_count;
- bit = ao_gpio_get(AO_PS2_DATA_PORT, AO_PS2_DATA_BIT, AO_PS2_DATA_PIN);
+ bit = ao_gpio_get(AO_PS2_DATA_PORT, AO_PS2_DATA_BIT);
if (ao_ps2_count == 0) {
/* check for start bit, ignore if not zero */
if (bit)
static void
ao_rn_check_link(void)
{
- ao_rn_connected = 1 - ao_gpio_get(AO_RN_CONNECTED_PORT, AO_RN_CONNECTED_PIN, foo);
+ ao_rn_connected = 1 - ao_gpio_get(AO_RN_CONNECTED_PORT, AO_RN_CONNECTED_PIN);
}
static void
ao_rn_dbg("ao_rn top\n");
/* Select CMD mode after the device gets out of reset */
- ao_gpio_set(AO_RN_CMD_PORT, AO_RN_CMD_PIN, foo, AO_RN_CMD_CMD);
+ ao_gpio_set(AO_RN_CMD_PORT, AO_RN_CMD_PIN, AO_RN_CMD_CMD);
for (i = 0; i < 3; i++) {
ao_rn_dbg("reset device\n");
- ao_gpio_set(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, foo, 0);
+ ao_gpio_set(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, 0);
ao_delay(AO_MS_TO_TICKS(100));
/* Reboot the RN4678 and wait for it to start talking */
ao_rn_drain();
- ao_gpio_set(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, foo, 1);
+ ao_gpio_set(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, 1);
status = ao_rn_wait_for(AO_RN_REBOOT_TIMEOUT, AO_RN_REBOOT_MSG);
if (status != AO_RN_OK) {
ao_rn_dbg("reboot failed\n");
if (status != AO_RN_OK)
ao_bt_panic(4);
- ao_gpio_set(AO_RN_CMD_PORT, AO_RN_CMD_PIN, foo, AO_RN_CMD_DATA);
+ ao_gpio_set(AO_RN_CMD_PORT, AO_RN_CMD_PIN, AO_RN_CMD_DATA);
/* Wait for the hardware to finish sending messages, then clear the queue */
ao_delay(AO_MS_TO_TICKS(200));
*/
/* Select our target output pin */
- ao_enable_output(AO_RN_P3_1_PORT, AO_RN_P3_1_PIN, foo, v);
+ ao_enable_output(AO_RN_P3_1_PORT, AO_RN_P3_1_PIN, v);
/* Turn off the BT device using the SW_BTN pin */
printf("Power down BT\n"); flush();
- ao_gpio_set(AO_RN_SW_BTN_PORT, AO_RN_SW_BTN_PIN, foo, 0);
+ ao_gpio_set(AO_RN_SW_BTN_PORT, AO_RN_SW_BTN_PIN, 0);
ao_delay(AO_MS_TO_TICKS(1000));
/* And turn it back on */
printf("Power up BT\n"); flush();
- ao_gpio_set(AO_RN_SW_BTN_PORT, AO_RN_SW_BTN_PIN, foo, 1);
+ ao_gpio_set(AO_RN_SW_BTN_PORT, AO_RN_SW_BTN_PIN, 1);
/* Right after power on, poke P3_1 five times to force a
* factory reset
for (i = 0; i < 20; i++) {
v = 1-v;
ao_delay(AO_MS_TO_TICKS(50));
- ao_gpio_set(AO_RN_P3_1_PORT, AO_RN_P3_1_PIN, foo, v);
+ ao_gpio_set(AO_RN_P3_1_PORT, AO_RN_P3_1_PIN, v);
ao_led_toggle(AO_BT_LED);
}
printf("Reboot BT\n"); flush();
ao_delay(AO_MS_TO_TICKS(100));
- ao_gpio_set(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, foo, 0);
+ ao_gpio_set(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, 0);
ao_delay(AO_MS_TO_TICKS(100));
- ao_gpio_set(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, foo, 1);
+ ao_gpio_set(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, 1);
}
#if AO_RN_DEBUG
ao_serial_rn_set_speed(AO_SERIAL_SPEED_115200);
/* Reset line */
- ao_enable_output(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, foo, 0);
+ ao_enable_output(AO_RN_RST_N_PORT, AO_RN_RST_N_PIN, 0);
/* SW_BTN */
- ao_enable_output(AO_RN_SW_BTN_PORT, AO_RN_SW_BTN_PIN, foo, 1);
+ ao_enable_output(AO_RN_SW_BTN_PORT, AO_RN_SW_BTN_PIN, 1);
/* P3_7 command/data selector */
- ao_enable_output(AO_RN_CMD_PORT, AO_RN_CMD_PIN, foo, AO_RN_CMD_CMD);
+ ao_enable_output(AO_RN_CMD_PORT, AO_RN_CMD_PIN, AO_RN_CMD_CMD);
ao_enable_input(AO_RN_CONNECTED_PORT, AO_RN_CONNECTED_PIN, AO_EXTI_MODE_PULL_NONE);
ao_exti_setup(AO_RN_CONNECTED_PORT, AO_RN_CONNECTED_PIN,
#define ao_sdcard_send_fixed(d,l) ao_spi_send_fixed((d), (l), AO_SDCARD_SPI_BUS)
#define ao_sdcard_send(d,l) ao_spi_send((d), (l), AO_SDCARD_SPI_BUS)
#define ao_sdcard_recv(d,l) ao_spi_recv((d), (l), AO_SDCARD_SPI_BUS)
-#define ao_sdcard_select() ao_gpio_set(AO_SDCARD_SPI_CS_PORT,AO_SDCARD_SPI_CS_PIN,AO_SDCARD_SPI_CS,0)
-#define ao_sdcard_deselect() ao_gpio_set(AO_SDCARD_SPI_CS_PORT,AO_SDCARD_SPI_CS_PIN,AO_SDCARD_SPI_CS,1)
+#define ao_sdcard_select() ao_gpio_set(AO_SDCARD_SPI_CS_PORT,AO_SDCARD_SPI_CS_PIN,0)
+#define ao_sdcard_deselect() ao_gpio_set(AO_SDCARD_SPI_CS_PORT,AO_SDCARD_SPI_CS_PIN,1)
/* Include SD card commands */
#ifndef SDCARD_DEBUG
usb_buf_id = ao_usb_alloc(buffer);
#ifdef AO_TRNG_ENABLE_PORT
- ao_gpio_set(AO_TRNG_ENABLE_PORT, AO_TRNG_ENABLE_BIT, AO_TRNG_ENABLE_PIN, 1);
+ ao_gpio_set(AO_TRNG_ENABLE_PORT, AO_TRNG_ENABLE_BIT, 1);
#endif
trng_power_time = ao_time();
{
(void) arg;
#ifdef AO_TRNG_ENABLE_PORT
- ao_gpio_set(AO_TRNG_ENABLE_PORT, AO_TRNG_ENABLE_BIT, AO_TRNG_ENABLE_PIN, 0);
+ ao_gpio_set(AO_TRNG_ENABLE_PORT, AO_TRNG_ENABLE_BIT, 0);
#endif
trng_running = false;
}
{
(void) arg;
#ifdef AO_TRNG_ENABLE_PORT
- ao_gpio_set(AO_TRNG_ENABLE_PORT, AO_TRNG_ENABLE_BIT, AO_TRNG_ENABLE_PIN, 1);
+ ao_gpio_set(AO_TRNG_ENABLE_PORT, AO_TRNG_ENABLE_BIT, 1);
#endif
trng_power_time = ao_time();
}
ao_trng_send_init(void)
{
#ifdef AO_TRNG_ENABLE_PORT
- ao_enable_output(AO_TRNG_ENABLE_PORT, AO_TRNG_ENABLE_BIT, AO_TRNG_ENABLE_PIN, 0);
+ ao_enable_output(AO_TRNG_ENABLE_PORT, AO_TRNG_ENABLE_BIT, 0);
ao_power_register(&ao_trng_power);
#endif
ao_enable_input(AO_RAW_PORT, AO_RAW_BIT, AO_EXTI_MODE_PULL_UP);
ao_sleep(&ao_watchdog_enabled);
while (ao_watchdog_enabled) {
ao_delay(AO_WATCHDOG_INTERVAL);
- ao_gpio_set(AO_WATCHDOG_PORT, AO_WATCHDOG_BIT, AO_WATCHDOG_PIN, 1);
+ ao_gpio_set(AO_WATCHDOG_PORT, AO_WATCHDOG_BIT, 1);
ao_delay(1);
- ao_gpio_set(AO_WATCHDOG_PORT, AO_WATCHDOG_BIT, AO_WATCHDOG_PIN, 0);
+ ao_gpio_set(AO_WATCHDOG_PORT, AO_WATCHDOG_BIT, 0);
}
}
}
void
ao_watchdog_init(void)
{
- ao_enable_output(AO_WATCHDOG_PORT, AO_WATCHDOG_BIT, AO_WATCHDOG, 0);
+ ao_enable_output(AO_WATCHDOG_PORT, AO_WATCHDOG_BIT, 0);
ao_cmd_register(&ao_watchdog_cmds[0]);
ao_add_task(&watchdog_task, ao_watchdog, "watchdog");
}
/* Number of general purpose pyro channels available */
#define AO_PYRO_NUM 4
-#define AO_IGNITER_SET_DROGUE(v) stm_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, v)
-#define AO_IGNITER_SET_MAIN(v) stm_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, v)
-
/*
* ADC
*/
#define AO_IGNITER_DROGUE_PORT 0
#define AO_IGNITER_DROGUE_PIN 2
-#define AO_IGNITER_SET_DROGUE(v) ao_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, AO_IGNITER_DROGUE, v)
#define AO_IGNITER_MAIN_PORT 0
#define AO_IGNITER_MAIN_PIN 3
-#define AO_IGNITER_SET_MAIN(v) ao_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, AO_IGNITER_MAIN, v)
#define AO_SENSE_DROGUE(p) ((p)->adc.sense_a)
#define AO_SENSE_MAIN(p) ((p)->adc.sense_m)
#define AO_IGNITER_DROGUE_PORT (&stm_gpioa)
#define AO_IGNITER_DROGUE_PIN 3
-#define AO_IGNITER_SET_DROGUE(v) ao_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, AO_IGNITER_DROGUE, v)
#define AO_IGNITER_MAIN_PORT (&stm_gpiob)
#define AO_IGNITER_MAIN_PIN 7
-#define AO_IGNITER_SET_MAIN(v) ao_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, AO_IGNITER_MAIN, v)
#define AO_SENSE_DROGUE(p) ((p)->adc.sense_a)
#define AO_SENSE_MAIN(p) ((p)->adc.sense_m)
return ao_igniter_unknown;
}
-#ifndef AO_IGNITER_SET_DROGUE
-#define AO_IGNITER_SET_DROGUE(v) AO_IGNITER_DROGUE = (v)
-#define AO_IGNITER_SET_MAIN(v) AO_IGNITER_MAIN = (v)
-#endif
+#define AO_IGNITER_SET_DROGUE(v) ao_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, v)
+#define AO_IGNITER_SET_MAIN(v) ao_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, v)
#ifndef AO_IGNITER_FIRE_TIME
#define AO_IGNITER_FIRE_TIME AO_MS_TO_TICKS(50)
void
ao_ignite_set_pins(void)
{
- ao_enable_output(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, AO_IGNITER_DROGUE, 0);
- ao_enable_output(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, AO_IGNITER_MAIN, 0);
+ ao_enable_output(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, 0);
+ ao_enable_output(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, 0);
}
#endif
{
switch (p) {
#if AO_PYRO_NUM > 0
- case 0: ao_gpio_set(AO_PYRO_PORT_0, AO_PYRO_PIN_0, AO_PYRO_0, v); break;
+ case 0: ao_gpio_set(AO_PYRO_PORT_0, AO_PYRO_PIN_0, v); break;
#endif
#if AO_PYRO_NUM > 1
- case 1: ao_gpio_set(AO_PYRO_PORT_1, AO_PYRO_PIN_1, AO_PYRO_1, v); break;
+ case 1: ao_gpio_set(AO_PYRO_PORT_1, AO_PYRO_PIN_1, v); break;
#endif
#if AO_PYRO_NUM > 2
- case 2: ao_gpio_set(AO_PYRO_PORT_2, AO_PYRO_PIN_2, AO_PYRO_2, v); break;
+ case 2: ao_gpio_set(AO_PYRO_PORT_2, AO_PYRO_PIN_2, v); break;
#endif
#if AO_PYRO_NUM > 3
- case 3: ao_gpio_set(AO_PYRO_PORT_3, AO_PYRO_PIN_3, AO_PYRO_3, v); break;
+ case 3: ao_gpio_set(AO_PYRO_PORT_3, AO_PYRO_PIN_3, v); break;
#endif
#if AO_PYRO_NUM > 4
- case 4: ao_gpio_set(AO_PYRO_PORT_4, AO_PYRO_PIN_4, AO_PYRO_4, v); break;
+ case 4: ao_gpio_set(AO_PYRO_PORT_4, AO_PYRO_PIN_4, v); break;
#endif
#if AO_PYRO_NUM > 5
- case 5: ao_gpio_set(AO_PYRO_PORT_5, AO_PYRO_PIN_5, AO_PYRO_5, v); break;
+ case 5: ao_gpio_set(AO_PYRO_PORT_5, AO_PYRO_PIN_5, v); break;
#endif
#if AO_PYRO_NUM > 6
- case 6: ao_gpio_set(AO_PYRO_PORT_6, AO_PYRO_PIN_6, AO_PYRO_6, v); break;
+ case 6: ao_gpio_set(AO_PYRO_PORT_6, AO_PYRO_PIN_6, v); break;
#endif
#if AO_PYRO_NUM > 7
- case 7: ao_gpio_set(AO_PYRO_PORT_7, AO_PYRO_PIN_7, AO_PYRO_7, v); break;
+ case 7: ao_gpio_set(AO_PYRO_PORT_7, AO_PYRO_PIN_7, v); break;
#endif
default: break;
}
ao_pyro_init(void)
{
#if AO_PYRO_NUM > 0
- ao_enable_output(AO_PYRO_PORT_0, AO_PYRO_PIN_0, AO_PYRO_0, 0);
+ ao_enable_output(AO_PYRO_PORT_0, AO_PYRO_PIN_0, 0);
#endif
#if AO_PYRO_NUM > 1
- ao_enable_output(AO_PYRO_PORT_1, AO_PYRO_PIN_1, AO_PYRO_1, 0);
+ ao_enable_output(AO_PYRO_PORT_1, AO_PYRO_PIN_1, 0);
#endif
#if AO_PYRO_NUM > 2
- ao_enable_output(AO_PYRO_PORT_2, AO_PYRO_PIN_2, AO_PYRO_2, 0);
+ ao_enable_output(AO_PYRO_PORT_2, AO_PYRO_PIN_2, 0);
#endif
#if AO_PYRO_NUM > 3
- ao_enable_output(AO_PYRO_PORT_3, AO_PYRO_PIN_3, AO_PYRO_3, 0);
+ ao_enable_output(AO_PYRO_PORT_3, AO_PYRO_PIN_3, 0);
#endif
#if AO_PYRO_NUM > 4
- ao_enable_output(AO_PYRO_PORT_4, AO_PYRO_PIN_4, AO_PYRO_4, 0);
+ ao_enable_output(AO_PYRO_PORT_4, AO_PYRO_PIN_4, 0);
#endif
#if AO_PYRO_NUM > 5
- ao_enable_output(AO_PYRO_PORT_5, AO_PYRO_PIN_5, AO_PYRO_5, 0);
+ ao_enable_output(AO_PYRO_PORT_5, AO_PYRO_PIN_5, 0);
#endif
#if AO_PYRO_NUM > 6
- ao_enable_output(AO_PYRO_PORT_6, AO_PYRO_PIN_6, AO_PYRO_6, 0);
+ ao_enable_output(AO_PYRO_PORT_6, AO_PYRO_PIN_6, 0);
#endif
#if AO_PYRO_NUM > 7
- ao_enable_output(AO_PYRO_PORT_7, AO_PYRO_PIN_7, AO_PYRO_7, 0);
+ ao_enable_output(AO_PYRO_PORT_7, AO_PYRO_PIN_7, 0);
#endif
ao_add_task(&ao_pyro_task, ao_pyro, "pyro");
}
static inline uint8_t
ao_usb_connected(void)
{
- return ao_gpio_get(AO_USB_CONNECT_PORT, AO_USB_CONNECT_PIN, AO_USB_CONNECT) != 0;
+ return ao_gpio_get(AO_USB_CONNECT_PORT, AO_USB_CONNECT_PIN) != 0;
}
#else
#define ao_usb_connected() 1
#ifndef _AO_ARCH_FUNCS_H_
#define _AO_ARCH_FUNCS_H_
-#define ao_spi_get_bit(reg,bit,pin,bus,speed) ao_spi_get_mask(reg,(1<<bit),bus,speed)
-#define ao_spi_put_bit(reg,bit,pin,bus) ao_spi_put_mask(reg,(1<<bit),bus)
+#define ao_spi_get_bit(reg,bit,bus,speed) ao_spi_get_mask(reg,(1<<bit),bus,speed)
+#define ao_spi_put_bit(reg,bit,bus) ao_spi_put_mask(reg,(1<<bit),bus)
#define ao_enable_port(port) (lpc_scb.sysahbclkctrl |= (1 << LPC_SCB_SYSAHBCLKCTRL_GPIO))
#define ao_disable_port(port) (lpc_scb.sysahbclkctrl &= ~(1 << LPC_SCB_SYSAHBCLKCTRL_GPIO))
#define lpc_all_bit(port,bit) (((port) << 5) | (bit))
-#define ao_gpio_set(port, bit, pin, v) (lpc_gpio.byte[lpc_all_bit(port,bit)] = (v))
+#define ao_gpio_set(port, bit, v) (lpc_gpio.byte[lpc_all_bit(port,bit)] = (v))
-#define ao_gpio_get(port, bit, pin) (lpc_gpio.byte[lpc_all_bit(port,bit)])
+#define ao_gpio_get(port, bit) (lpc_gpio.byte[lpc_all_bit(port,bit)])
#define PORT0_JTAG_REGS ((1 << 11) | (1 << 12) | (1 << 14))
}
}
-#define ao_enable_output(port,bit,pin,v) do { \
+#define ao_enable_output(port,bit,v) do { \
ao_enable_port(port); \
lpc_set_gpio(port,bit); \
- ao_gpio_set(port, bit, pin, v); \
+ ao_gpio_set(port, bit, v); \
lpc_gpio.dir[port] |= (1 << bit); \
} while (0)
ao_spi_put(bus); \
} while (0)
-#define ao_spi_get_bit(reg,bit,pin,bus,speed) ao_spi_get_mask(reg,(1<<bit),bus,speed)
-#define ao_spi_put_bit(reg,bit,pin,bus) ao_spi_put_mask(reg,(1<<bit),bus)
+#define ao_spi_get_bit(reg,bit,bus,speed) ao_spi_get_mask(reg,(1<<bit),bus,speed)
+#define ao_spi_put_bit(reg,bit,bus) ao_spi_put_mask(reg,(1<<bit),bus)
void
ao_spi_get(uint8_t spi_index, uint32_t speed);
uint8_t __bit__; \
for (__bit__ = 0; __bit__ < 32; __bit__++) { \
if (mask & (1 << __bit__)) \
- ao_enable_output(port, __bit__, PIN, 1); \
+ ao_enable_output(port, __bit__, 1); \
} \
} while (0)
ao_arch_nop();
/* Read the value */
- v = ao_gpio_get(AO_BOOT_APPLICATION_GPIO, AO_BOOT_APPLICATION_PIN, AO_BOOT_APPLICATION);
+ v = ao_gpio_get(AO_BOOT_APPLICATION_GPIO, AO_BOOT_APPLICATION_PIN);
/* Reset the chip to turn off the port and the power interface clock */
ao_gpio_set_mode(AO_BOOT_APPLICATION_GPIO, AO_BOOT_APPLICATION_PIN, 0);
ao_arch_block_interrupts();
#if HAS_USB_PULLUP
- ao_gpio_set(AO_USB_PULLUP_PORT, AO_USB_PULLUP_PIN, AO_USB_PULLUP, 0);
+ ao_gpio_set(AO_USB_PULLUP_PORT, AO_USB_PULLUP_PIN, 0);
#endif
/* Disable interrupts */
lpc_usb.inten = 0;
ao_usb_set_ep0();
#if HAS_USB_PULLUP
- ao_gpio_set(AO_USB_PULLUP_PORT, AO_USB_PULLUP_PIN, AO_USB_PULLUP, 1);
+ ao_gpio_set(AO_USB_PULLUP_PORT, AO_USB_PULLUP_PIN, 1);
#endif
}
{
#if HAS_USB_PULLUP
int i;
- ao_enable_output(AO_USB_PULLUP_PORT, AO_USB_PULLUP_PIN, AO_USB_PULLUP, 0);
+ ao_enable_output(AO_USB_PULLUP_PORT, AO_USB_PULLUP_PIN, 0);
for (i = 0; i < 40000; i++)
ao_arch_nop();
ao_spi_put(bus); \
} while (0)
-#define ao_spi_get_bit(reg,bit,pin,bus,speed) ao_spi_get_mask(reg,(1<<bit),bus,speed)
-#define ao_spi_put_bit(reg,bit,pin,bus) ao_spi_put_mask(reg,(1<<bit),bus)
+#define ao_spi_get_bit(reg,bit,bus,speed) ao_spi_get_mask(reg,(1<<bit),bus,speed)
+#define ao_spi_put_bit(reg,bit,bus) ao_spi_put_mask(reg,(1<<bit),bus)
#define ao_enable_port(port) do { \
if ((port) == &stm_gpioa) \
} while (0)
-#define ao_gpio_set(port, bit, pin, v) stm_gpio_set(port, bit, v)
+#define ao_gpio_set(port, bit, v) stm_gpio_set(port, bit, v)
-#define ao_gpio_get(port, bit, pin) stm_gpio_get(port, bit)
+#define ao_gpio_get(port, bit) stm_gpio_get(port, bit)
#define ao_gpio_set_bits(port, bits) stm_gpio_set_bits(port, bits)
#define ao_gpio_get_all(port) stm_gpio_get_all(port)
-#define ao_enable_output(port,bit,pin,v) do { \
+#define ao_enable_output(port,bit,v) do { \
ao_enable_port(port); \
- ao_gpio_set(port, bit, pin, v); \
+ ao_gpio_set(port, bit, v); \
stm_moder_set(port, bit, STM_MODER_OUTPUT);\
} while (0)
#define AO_OUTPUT_PUSH_PULL STM_OTYPER_PUSH_PULL
#define AO_OUTPUT_OPEN_DRAIN STM_OTYPER_OPEN_DRAIN
-#define ao_gpio_set_output_mode(port,bit,pin,mode) \
+#define ao_gpio_set_output_mode(port,bit,mode) \
stm_otyper_set(port, pin, mode)
#define ao_gpio_set_mode(port,bit,mode) do { \
stm_moder_set(port, bit, STM_MODER_INPUT); \
} while (0)
-#define ao_set_output(port, bit, pin, v) do { \
- ao_gpio_set(port, bit, pin, v); \
+#define ao_set_output(port, bit, v) do { \
+ ao_gpio_set(port, bit, v); \
stm_moder_set(port, bit, STM_MODER_OUTPUT); \
} while (0)
AO_LED_TYPE i;
for (i = 0; i < N_LED; i++)
if (colors & (1 << i))
- ao_gpio_set(ao_leds[i].port, ao_leds[i].pin, foo, 1);
+ ao_gpio_set(ao_leds[i].port, ao_leds[i].pin, 1);
#else
#ifdef LED_PORT
LED_PORT->bsrr = (colors & ao_led_enable);
AO_LED_TYPE i;
for (i = 0; i < N_LED; i++)
if (colors & (1 << i))
- ao_gpio_set(ao_leds[i].port, ao_leds[i].pin, foo, 0);
+ ao_gpio_set(ao_leds[i].port, ao_leds[i].pin, 0);
#else
#ifdef LED_PORT
LED_PORT->bsrr = (uint32_t) (colors & ao_led_enable) << 16;
AO_LED_TYPE i;
for (i = 0; i < N_LED; i++)
if (colors & (1 << i))
- ao_gpio_set(ao_leds[i].port, ao_leds[i].pin, foo, ~ao_gpio_get(ao_leds[i].port, ao_leds[i].pin, foo));
+ ao_gpio_set(ao_leds[i].port, ao_leds[i].pin, ~ao_gpio_get(ao_leds[i].port, ao_leds[i].pin));
#else
#ifdef LED_PORT
LED_PORT->odr ^= (colors & ao_led_enable);
ao_led_enable = enable;
#if LED_PER_LED
for (bit = 0; bit < N_LED; bit++)
- ao_enable_output(ao_leds[bit].port, ao_leds[bit].pin, foo, 0);
+ ao_enable_output(ao_leds[bit].port, ao_leds[bit].pin, 0);
#else
#ifdef LED_PORT
stm_rcc.ahbenr |= (1 << LED_PORT_ENABLE);
{
if (!ao_fifo_empty(usart->tx_fifo)) {
#if HAS_SERIAL_SW_FLOW
- if (usart->gpio_cts && ao_gpio_get(usart->gpio_cts, usart->pin_cts, foo) == 1) {
+ if (usart->gpio_cts && ao_gpio_get(usart->gpio_cts, usart->pin_cts) == 1) {
ao_exti_enable(usart->gpio_cts, usart->pin_cts);
return 0;
}
* for it to drain a bunch
*/
if (usart->gpio_rts && ao_fifo_mostly(usart->rx_fifo)) {
- ao_gpio_set(usart->gpio_rts, usart->pin_rts, usart->pin_rts, 1);
+ ao_gpio_set(usart->gpio_rts, usart->pin_rts, 1);
usart->rts = 0;
}
#endif
#if HAS_SERIAL_SW_FLOW
/* If we've cleared RTS, check if there's space now and turn it back on */
if (usart->gpio_rts && usart->rts == 0 && ao_fifo_barely(usart->rx_fifo)) {
- ao_gpio_set(usart->gpio_rts, usart->pin_rts, foo, 0);
+ ao_gpio_set(usart->gpio_rts, usart->pin_rts, 0);
usart->rts = 1;
}
#endif
{
/* Pull RTS low to note that there's space in the FIFO
*/
- ao_enable_output(port_rts, pin_rts, foo, 0);
+ ao_enable_output(port_rts, pin_rts, 0);
usart->gpio_rts = port_rts;
usart->pin_rts = pin_rts;
usart->rts = 1;
ao_spi_put(bus); \
} while (0)
-#define ao_spi_get_bit(reg,bit,pin,bus,speed) ao_spi_get_mask(reg,(1<<bit),bus,speed)
-#define ao_spi_put_bit(reg,bit,pin,bus) ao_spi_put_mask(reg,(1<<bit),bus)
+#define ao_spi_get_bit(reg,bit,bus,speed) ao_spi_get_mask(reg,(1<<bit),bus,speed)
+#define ao_spi_put_bit(reg,bit,bus) ao_spi_put_mask(reg,(1<<bit),bus)
#if AO_POWER_MANAGEMENT
extern struct ao_power ao_power_gpioa;
}
}
-#define ao_gpio_set(port, bit, pin, v) stm_gpio_set(port, bit, v)
+#define ao_gpio_set(port, bit, v) stm_gpio_set(port, bit, v)
-#define ao_gpio_get(port, bit, pin) stm_gpio_get(port, bit)
+#define ao_gpio_get(port, bit) stm_gpio_get(port, bit)
-#define ao_enable_output(port,bit,pin,v) do { \
+#define ao_enable_output(port,bit,v) do { \
ao_enable_port(port); \
- ao_gpio_set(port, bit, pin, v); \
+ ao_gpio_set(port, bit, v); \
stm_moder_set(port, bit, STM_MODER_OUTPUT);\
} while (0)
} while (0)
#define ao_enable_cs(port,bit) do { \
- ao_enable_output(port, bit, pin, 1); \
+ ao_enable_output(port, bit, 1); \
} while (0)
#define ao_spi_init_cs(port, mask) do { \
void
ao_beep_init(void)
{
- ao_enable_output(BEEPER_PORT, BEEPER_PIN, BEEPER, 0);
+ ao_enable_output(BEEPER_PORT, BEEPER_PIN, 0);
/* Leave the timer off until requested */
stm_rcc_enr &= ~(1 << STM_RCC_TIMER);
#define AO_IGNITER_MAIN_PORT (&stm_gpioa)
#define AO_IGNITER_MAIN_PIN 9
-#define AO_IGNITER_SET_DROGUE(v) stm_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, v)
-#define AO_IGNITER_SET_MAIN(v) stm_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, v)
-
/*
* ADC
*/
/* Number of general purpose pyro channels available */
#define AO_PYRO_NUM 4
-#define AO_IGNITER_SET_DROGUE(v) stm_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, v)
-#define AO_IGNITER_SET_MAIN(v) stm_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, v)
-
/*
* ADC
*/
/* Number of general purpose pyro channels available */
#define AO_PYRO_NUM 4
-#define AO_IGNITER_SET_DROGUE(v) stm_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, v)
-#define AO_IGNITER_SET_MAIN(v) stm_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, v)
-
/*
* ADC
*/
/* Number of general purpose pyro channels available */
#define AO_PYRO_NUM 4
-#define AO_IGNITER_SET_DROGUE(v) stm_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, v)
-#define AO_IGNITER_SET_MAIN(v) stm_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, v)
-
/*
* ADC
*/
/* Number of general purpose pyro channels available */
#define AO_PYRO_NUM 4
-#define AO_IGNITER_SET_DROGUE(v) stm_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, v)
-#define AO_IGNITER_SET_MAIN(v) stm_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, v)
-
/*
* ADC
*/
#define AO_IGNITER_MAIN_PORT (&stm_gpioa)
#define AO_IGNITER_MAIN_PIN 9
-#define AO_IGNITER_SET_DROGUE(v) stm_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, v)
-#define AO_IGNITER_SET_MAIN(v) stm_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, v)
-
/*
* ADC
*/
#define AO_IGNITER_MAIN_PORT (&stm_gpioa)
#define AO_IGNITER_MAIN_PIN 9
-#define AO_IGNITER_SET_DROGUE(v) stm_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, v)
-#define AO_IGNITER_SET_MAIN(v) stm_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, v)
-
/*
* ADC
*/
#define AO_IGNITER_DROGUE_PORT (&stm_gpiob)
#define AO_IGNITER_DROGUE_PIN 7
-#define AO_IGNITER_SET_DROGUE(v) ao_gpio_set(AO_IGNITER_DROGUE_PORT, AO_IGNITER_DROGUE_PIN, AO_IGNITER_DROGUE, v)
#define AO_IGNITER_MAIN_PORT (&stm_gpiob)
#define AO_IGNITER_MAIN_PIN 6
-#define AO_IGNITER_SET_MAIN(v) ao_gpio_set(AO_IGNITER_MAIN_PORT, AO_IGNITER_MAIN_PIN, AO_IGNITER_MAIN, v)
#define AO_SENSE_DROGUE(p) ((p)->adc.sense_a)
#define AO_SENSE_MAIN(p) ((p)->adc.sense_m)
ao_enable_input(AO_RECOVERY_PORT, AO_RECOVERY_PIN, AO_RECOVERY_MODE);
for (i = 0; i < 100; i++)
ao_arch_nop();
- if (ao_gpio_get(AO_RECOVERY_PORT, AO_RECOVERY_PIN, AO_RECOVERY) == AO_RECOVERY_VALUE) {
+ if (ao_gpio_get(AO_RECOVERY_PORT, AO_RECOVERY_PIN) == AO_RECOVERY_VALUE) {
ao_flight_force_idle = 1;
ao_force_freq = 1;
}