altos: Replace ao_alarm/ao_clear_alarm with ao_sleep_for

Having arbitrary alarms firing in the middle of complicated device
logic makes no sense at all. Therefore only correct use of ao_alarm
and ao_clear_alarm was around a specific ao_sleep call, with correct
recovery in case the alarm fires.

This patch replaces all uses of ao_alarm/ao_sleep/ao_clear_alarm with
ao_sleep_for, a new function which takes the alarm timeout directly.

A few cases which weren't simply calling ao_sleep have been reworked
to pass the timeout value down to the place where sleep *is* being
called, and having that code deal with the return correctly.

Signed-off-by: Keith Packard <keithp@keithp.com>

diff --git a/src/cc1111/ao_arch.h b/src/cc1111/ao_arch.h
index b3c6b5dcce6fd29ffa7710ec47c1ecb5293a950d..6eb1a11101c6f473d09b950b60ae0d8ee386ff28 100644 (file)
--- a/src/cc1111/ao_arch.h
+++ b/src/cc1111/ao_arch.h
@@ -228,7 +228,7 @@ void
 ao_button_init(void);
 
 char
 ao_button_init(void);
 
 char

-ao_button_get(void) __critical;
+ao_button_get(uint16_t timeout) __critical;

 
 void
 ao_button_clear(void) __critical;
 
 void
 ao_button_clear(void) __critical;

diff --git a/src/cc1111/ao_button.c b/src/cc1111/ao_button.c
index 69f3475fe660d43125073a40b19118f3f545c07d..a0f221c2780ce0c6df18935f2996aaab8200159c 100644 (file)
--- a/src/cc1111/ao_button.c
+++ b/src/cc1111/ao_button.c
@@ -72,12 +72,12 @@ ao_button_mask(uint8_t reg)
 }
 
 char
 }
 
 char

-ao_button_get(void) __critical
+ao_button_get(uint16_t timeout) __critical

 {
        char    b;
 
        while (ao_fifo_empty(ao_button_fifo))
 {
        char    b;
 
        while (ao_fifo_empty(ao_button_fifo))

-               if (ao_sleep(&ao_button_fifo))
+               if (ao_sleep_for(&ao_button_fifo, timeout))

                        return 0;
        ao_fifo_remove(ao_button_fifo, b);
        return b;
                        return 0;
        ao_fifo_remove(ao_button_fifo, b);
        return b;

diff --git a/src/cc1111/ao_radio.c b/src/cc1111/ao_radio.c
index b9821a4237ab950caecebb6bac85defb30ccbff2..cead036419f18c97a9ae7277564a849242d5866e 100644 (file)
--- a/src/cc1111/ao_radio.c
+++ b/src/cc1111/ao_radio.c
@@ -451,13 +451,9 @@ ao_radio_recv(__xdata void *packet, uint8_t size, uint8_t timeout) __reentrant
        /* Wait for DMA to be done, for the radio receive process to
         * get aborted or for a receive timeout to fire
         */
        /* Wait for DMA to be done, for the radio receive process to
         * get aborted or for a receive timeout to fire
         */

-       if (timeout)
-               ao_alarm(timeout);

        __critical while (!ao_radio_dma_done && !ao_radio_abort)
        __critical while (!ao_radio_dma_done && !ao_radio_abort)

-                          if (ao_sleep(&ao_radio_dma_done))
+                          if (ao_sleep_for(&ao_radio_dma_done, timeout))

                                   break;
                                   break;

-       if (timeout)
-               ao_clear_alarm();

 
        /* If recv was aborted, clean up by stopping the DMA engine
         * and idling the radio
 
        /* If recv was aborted, clean up by stopping the DMA engine
         * and idling the radio

diff --git a/src/drivers/ao_btm.c b/src/drivers/ao_btm.c
index e6b286881e778a13e54049c849f91f4f0f714e61..93d9dd9d341313d54fa927ca496ff8544374b894 100644 (file)
--- a/src/drivers/ao_btm.c
+++ b/src/drivers/ao_btm.c
@@ -23,7 +23,7 @@
 #ifndef ao_serial_btm_getchar
 #define ao_serial_btm_putchar  ao_serial1_putchar
 #define _ao_serial_btm_pollchar        _ao_serial1_pollchar
 #ifndef ao_serial_btm_getchar
 #define ao_serial_btm_putchar  ao_serial1_putchar
 #define _ao_serial_btm_pollchar        _ao_serial1_pollchar

-#define _ao_serial_btm_sleep() ao_sleep((void *) &ao_serial1_rx_fifo)
+#define _ao_serial_btm_sleep_for(timeout)      ao_sleep_for((void *) &ao_serial1_rx_fifo, timeout)

 #define ao_serial_btm_set_speed ao_serial1_set_speed
 #define ao_serial_btm_drain    ao_serial1_drain
 #endif
 #define ao_serial_btm_set_speed ao_serial1_set_speed
 #define ao_serial_btm_drain    ao_serial1_drain
 #endif


@@ -111,7 +111,7 @@ ao_btm_do_echo(void)
        while (ao_btm_enable) {
                ao_arch_block_interrupts();
                while ((c = _ao_serial_btm_pollchar()) == AO_READ_AGAIN && ao_btm_enable)
        while (ao_btm_enable) {
                ao_arch_block_interrupts();
                while ((c = _ao_serial_btm_pollchar()) == AO_READ_AGAIN && ao_btm_enable)

-                       _ao_serial_btm_sleep();
+                       _ao_serial_btm_sleep_for(0);

                ao_arch_release_interrupts();
                if (c != AO_READ_AGAIN) {
                        putchar(c);
                ao_arch_release_interrupts();
                if (c != AO_READ_AGAIN) {
                        putchar(c);


@@ -166,9 +166,7 @@ ao_btm_getchar(void)
 
        ao_arch_block_interrupts();
        while ((c = _ao_serial_btm_pollchar()) == AO_READ_AGAIN) {
 
        ao_arch_block_interrupts();
        while ((c = _ao_serial_btm_pollchar()) == AO_READ_AGAIN) {

-               ao_alarm(AO_MS_TO_TICKS(10));
-               c = _ao_serial_btm_sleep();
-               ao_clear_alarm();
+               c = _ao_serial_btm_sleep_for(AO_MS_TO_TICKS(10));

                if (c) {
                        c = AO_READ_AGAIN;
                        break;
                if (c) {
                        c = AO_READ_AGAIN;
                        break;

diff --git a/src/drivers/ao_cc1120.c b/src/drivers/ao_cc1120.c
index 90d6cc75ab5f76eb5677a052203a44e85eb6b94d..5b814667fccf8f18e67d9e7aec557489bfae915a 100644 (file)
--- a/src/drivers/ao_cc1120.c
+++ b/src/drivers/ao_cc1120.c
@@ -837,15 +837,11 @@ ao_radio_test_cmd(void)
 static void
 ao_radio_wait_isr(uint16_t timeout)
 {
 static void
 ao_radio_wait_isr(uint16_t timeout)
 {

-       if (timeout)
-               ao_alarm(timeout);

        ao_arch_block_interrupts();
        while (!ao_radio_wake && !ao_radio_mcu_wake && !ao_radio_abort)
        ao_arch_block_interrupts();
        while (!ao_radio_wake && !ao_radio_mcu_wake && !ao_radio_abort)

-               if (ao_sleep(&ao_radio_wake))
+               if (ao_sleep_for(&ao_radio_wake, timeout))

                        ao_radio_abort = 1;
        ao_arch_release_interrupts();
                        ao_radio_abort = 1;
        ao_arch_release_interrupts();

-       if (timeout)
-               ao_clear_alarm();

        if (ao_radio_mcu_wake)
                ao_radio_check_marc_status();
 }
        if (ao_radio_mcu_wake)
                ao_radio_check_marc_status();
 }


@@ -1060,19 +1056,17 @@ ao_radio_rx_isr(void)
 static uint16_t
 ao_radio_rx_wait(void)
 {
 static uint16_t
 ao_radio_rx_wait(void)
 {

-       ao_alarm(AO_MS_TO_TICKS(100));

        ao_arch_block_interrupts();
        rx_waiting = 1;
        while (rx_data_cur - rx_data_consumed < AO_FEC_DECODE_BLOCK &&
               !ao_radio_abort &&
               !ao_radio_mcu_wake)
        {
        ao_arch_block_interrupts();
        rx_waiting = 1;
        while (rx_data_cur - rx_data_consumed < AO_FEC_DECODE_BLOCK &&
               !ao_radio_abort &&
               !ao_radio_mcu_wake)
        {

-               if (ao_sleep(&ao_radio_wake))
+               if (ao_sleep_for(&ao_radio_wake, AO_MS_TO_TICKS(100)))

                        ao_radio_abort = 1;
        }
        rx_waiting = 0;
        ao_arch_release_interrupts();
                        ao_radio_abort = 1;
        }
        rx_waiting = 0;
        ao_arch_release_interrupts();

-       ao_clear_alarm();

        if (ao_radio_abort || ao_radio_mcu_wake)
                return 0;
        rx_data_consumed += AO_FEC_DECODE_BLOCK;
        if (ao_radio_abort || ao_radio_mcu_wake)
                return 0;
        rx_data_consumed += AO_FEC_DECODE_BLOCK;


@@ -1133,19 +1127,15 @@ ao_radio_recv(__xdata void *d, uint8_t size, uint8_t timeout)
 
        ao_radio_strobe(CC1120_SRX);
 
 
        ao_radio_strobe(CC1120_SRX);
 

-       if (timeout)
-               ao_alarm(timeout);

        ao_arch_block_interrupts();
        while (rx_starting && !ao_radio_abort) {
        ao_arch_block_interrupts();
        while (rx_starting && !ao_radio_abort) {

-               if (ao_sleep(&ao_radio_wake))
+               if (ao_sleep_for(&ao_radio_wake, timeout))

                        ao_radio_abort = 1;
        }
        uint8_t rx_task_id_save = rx_task_id;
        rx_task_id = 0;
        rx_starting = 0;
        ao_arch_release_interrupts();
                        ao_radio_abort = 1;
        }
        uint8_t rx_task_id_save = rx_task_id;
        rx_task_id = 0;
        rx_starting = 0;
        ao_arch_release_interrupts();

-       if (timeout)
-               ao_clear_alarm();

 
        if (ao_radio_abort) {
                if (rx_task_id_save == 0)
 
        if (ao_radio_abort) {
                if (rx_task_id_save == 0)

diff --git a/src/drivers/ao_cc1200.c b/src/drivers/ao_cc1200.c
index 8546900e830246650b49e31147abf05a20783707..df4bd335a974ba3d6df76143f4faf9b67de14d58 100644 (file)
--- a/src/drivers/ao_cc1200.c
+++ b/src/drivers/ao_cc1200.c
@@ -715,17 +715,11 @@ ao_radio_show_state(char *where)
 static void
 ao_radio_wait_isr(uint16_t timeout)
 {
 static void
 ao_radio_wait_isr(uint16_t timeout)
 {

-       if (timeout)
-               ao_alarm(timeout);
-

        ao_arch_block_interrupts();
        while (!ao_radio_wake && !ao_radio_abort)
        ao_arch_block_interrupts();
        while (!ao_radio_wake && !ao_radio_abort)

-               if (ao_sleep(&ao_radio_wake))
+               if (ao_sleep_for(&ao_radio_wake, timeout))

                        ao_radio_abort = 1;
        ao_arch_release_interrupts();
                        ao_radio_abort = 1;
        ao_arch_release_interrupts();

-
-       if (timeout)
-               ao_clear_alarm();

 }
 
 static void
 }
 
 static void

diff --git a/src/drivers/ao_companion.c b/src/drivers/ao_companion.c
index 570b9e409bbdd7f1245900d383a344d8a4b53a67..7e02939bf7bc0c01bca788bce526da7ee1172115 100644 (file)
--- a/src/drivers/ao_companion.c
+++ b/src/drivers/ao_companion.c
@@ -102,8 +102,7 @@ ao_companion(void)
                    break;
        }
        while (ao_companion_running) {
                    break;
        }
        while (ao_companion_running) {

-               ao_alarm(ao_companion_setup.update_period);
-               if (ao_sleep(DATA_TO_XDATA(&ao_flight_state)))
+               if (ao_sleep_for(DATA_TO_XDATA(&ao_flight_state), ao_companion_setup.update_period))

                        ao_companion_get_data();
                else
                        ao_companion_notify();
                        ao_companion_get_data();
                else
                        ao_companion_notify();

diff --git a/src/drivers/ao_hmc5883.c b/src/drivers/ao_hmc5883.c
index 2d217bcf9d392fbd70099beaa3f21eee6ff8f871..f761671a1d3e0dac1cbbe90be7a0408e6ae928d0 100644 (file)
--- a/src/drivers/ao_hmc5883.c
+++ b/src/drivers/ao_hmc5883.c
@@ -75,13 +75,11 @@ ao_hmc5883_sample(struct ao_hmc5883_sample *sample)
        ao_exti_enable(AO_HMC5883_INT_PORT, AO_HMC5883_INT_PIN);
        ao_hmc5883_reg_write(HMC5883_MODE, HMC5883_MODE_SINGLE);
 
        ao_exti_enable(AO_HMC5883_INT_PORT, AO_HMC5883_INT_PIN);
        ao_hmc5883_reg_write(HMC5883_MODE, HMC5883_MODE_SINGLE);
 

-       ao_alarm(AO_MS_TO_TICKS(10));

        ao_arch_block_interrupts();
        while (!ao_hmc5883_done)
        ao_arch_block_interrupts();
        while (!ao_hmc5883_done)

-               if (ao_sleep(&ao_hmc5883_done))
+               if (ao_sleep_for(&ao_hmc5883_done, AO_MS_TO_TICKS(10)))

                        ++ao_hmc5883_missed_irq;
        ao_arch_release_interrupts();
                        ++ao_hmc5883_missed_irq;
        ao_arch_release_interrupts();

-       ao_clear_alarm();

 
        ao_hmc5883_read(HMC5883_X_MSB, (uint8_t *) sample, sizeof (struct ao_hmc5883_sample));
 #if __BYTE_ORDER == __LITTLE_ENDIAN
 
        ao_hmc5883_read(HMC5883_X_MSB, (uint8_t *) sample, sizeof (struct ao_hmc5883_sample));
 #if __BYTE_ORDER == __LITTLE_ENDIAN

diff --git a/src/drivers/ao_packet.c b/src/drivers/ao_packet.c
index 8cdf85a94f9036648acf1332bfc94cb158567afd..18330eadbec53deb7faf4f8468227f5cdc494bd7 100644 (file)
--- a/src/drivers/ao_packet.c
+++ b/src/drivers/ao_packet.c
@@ -54,14 +54,14 @@ ao_packet_send(void)
 }
 
 uint8_t
 }
 
 uint8_t

-ao_packet_recv(void)
+ao_packet_recv(uint16_t timeout)

 {
        uint8_t dma_done;
 
 #ifdef AO_LED_GREEN
        ao_led_on(AO_LED_GREEN);
 #endif
 {
        uint8_t dma_done;
 
 #ifdef AO_LED_GREEN
        ao_led_on(AO_LED_GREEN);
 #endif

-       dma_done = ao_radio_recv(&ao_rx_packet, sizeof (struct ao_packet_recv), 0);
+       dma_done = ao_radio_recv(&ao_rx_packet, sizeof (struct ao_packet_recv), timeout);

 #ifdef AO_LED_GREEN
        ao_led_off(AO_LED_GREEN);
 #endif
 #ifdef AO_LED_GREEN
        ao_led_off(AO_LED_GREEN);
 #endif

diff --git a/src/drivers/ao_packet_master.c b/src/drivers/ao_packet_master.c
index 42a4f5bfd35f064f22aa9cd682aa5295a897fe3b..5e440db04776442dc0c516bdcdadb69f4ed8ce12 100644 (file)
--- a/src/drivers/ao_packet_master.c
+++ b/src/drivers/ao_packet_master.c
@@ -97,9 +97,7 @@ ao_packet_master(void)
                if (ao_tx_packet.len)
                        ao_packet_master_busy();
                ao_packet_master_check_busy();
                if (ao_tx_packet.len)
                        ao_packet_master_busy();
                ao_packet_master_check_busy();

-               ao_alarm(AO_PACKET_MASTER_RECV_DELAY);
-               r = ao_packet_recv();
-               ao_clear_alarm();
+               r = ao_packet_recv(AO_PACKET_MASTER_RECV_DELAY);

                if (r) {
                        /* if we can transmit data, do so */
                        if (ao_packet_tx_used && ao_tx_packet.len == 0)
                if (r) {
                        /* if we can transmit data, do so */
                        if (ao_packet_tx_used && ao_tx_packet.len == 0)


@@ -107,9 +105,7 @@ ao_packet_master(void)
                        if (ao_rx_packet.packet.len)
                                ao_packet_master_busy();
                        ao_packet_master_sleeping = 1;
                        if (ao_rx_packet.packet.len)
                                ao_packet_master_busy();
                        ao_packet_master_sleeping = 1;

-                       ao_alarm(ao_packet_master_delay);
-                       ao_sleep(&ao_packet_master_sleeping);
-                       ao_clear_alarm();
+                       ao_sleep_for(&ao_packet_master_sleeping, ao_packet_master_delay);

                        ao_packet_master_sleeping = 0;
                }
        }
                        ao_packet_master_sleeping = 0;
                }
        }

diff --git a/src/drivers/ao_packet_slave.c b/src/drivers/ao_packet_slave.c
index e75df0d619fb92509d0a76011757cb7e8b2d75b4..0872682fa1c307b237a7f6b82b39422f942270d7 100644 (file)
--- a/src/drivers/ao_packet_slave.c
+++ b/src/drivers/ao_packet_slave.c
@@ -24,7 +24,7 @@ ao_packet_slave(void)
        ao_tx_packet.len = AO_PACKET_SYN;
        ao_packet_restart = 1;
        while (ao_packet_enable) {
        ao_tx_packet.len = AO_PACKET_SYN;
        ao_packet_restart = 1;
        while (ao_packet_enable) {

-               if (ao_packet_recv()) {
+               if (ao_packet_recv(0)) {

                        ao_xmemcpy(&ao_tx_packet.callsign, &ao_rx_packet.packet.callsign, AO_MAX_CALLSIGN);
 #if HAS_FLIGHT
                        ao_flight_force_idle = TRUE;
                        ao_xmemcpy(&ao_tx_packet.callsign, &ao_rx_packet.packet.callsign, AO_MAX_CALLSIGN);
 #if HAS_FLIGHT
                        ao_flight_force_idle = TRUE;

diff --git a/src/kernel/ao_packet.h b/src/kernel/ao_packet.h
index b8426cf90d7d8cdd7397dfe406bbbdf344cdd626..136609c3b0865c7dbc3772f2997cadc3acb173bf 100644 (file)
--- a/src/kernel/ao_packet.h
+++ b/src/kernel/ao_packet.h
@@ -54,7 +54,7 @@ void
 ao_packet_send(void);
 
 uint8_t
 ao_packet_send(void);
 
 uint8_t

-ao_packet_recv(void);
+ao_packet_recv(uint16_t timeout);

 
 void
 ao_packet_flush(void);
 
 void
 ao_packet_flush(void);

diff --git a/src/kernel/ao_pyro.c b/src/kernel/ao_pyro.c
index 3044d56517aa06fceaf198fb31a4165e5d6b9370..43e73de4a897cfa97ee6cdc851f4c7ef373727f1 100644 (file)
--- a/src/kernel/ao_pyro.c
+++ b/src/kernel/ao_pyro.c
@@ -375,9 +375,7 @@ ao_pyro(void)
                ao_sleep(&ao_flight_state);
 
        for (;;) {
                ao_sleep(&ao_flight_state);
 
        for (;;) {

-               ao_alarm(AO_MS_TO_TICKS(100));
-               ao_sleep(&ao_pyro_wakeup);
-               ao_clear_alarm();
+               ao_sleep_for(&ao_pyro_wakeup, AO_MS_TO_TICKS(100));

                if (ao_flight_state >= ao_flight_landed)
                        break;
                any_waiting = ao_pyro_check();
                if (ao_flight_state >= ao_flight_landed)
                        break;
                any_waiting = ao_pyro_check();

diff --git a/src/kernel/ao_serial.h b/src/kernel/ao_serial.h
index dbc9f8e4121c36ec0f4ed3c873b742f28b7122fd..e21643ac008f9da659cb72e64a9f316bb7934622 100644 (file)
--- a/src/kernel/ao_serial.h
+++ b/src/kernel/ao_serial.h
@@ -35,7 +35,7 @@ int
 _ao_serial0_pollchar(void);
 
 uint8_t
 _ao_serial0_pollchar(void);
 
 uint8_t

-_ao_serial0_sleep(void);
+_ao_serial0_sleep_for(uint16_t timeout);

 
 void
 ao_serial0_putchar(char c);
 
 void
 ao_serial0_putchar(char c);


@@ -58,7 +58,7 @@ int
 _ao_serial1_pollchar(void);
 
 uint8_t
 _ao_serial1_pollchar(void);
 
 uint8_t

-_ao_serial1_sleep(void);
+_ao_serial1_sleep_for(uint16_t timeout);

 
 void
 ao_serial1_putchar(char c);
 
 void
 ao_serial1_putchar(char c);


@@ -81,7 +81,7 @@ int
 _ao_serial2_pollchar(void);
 
 uint8_t
 _ao_serial2_pollchar(void);
 
 uint8_t

-_ao_serial2_sleep(void);
+_ao_serial2_sleep_for(uint16_t timeout);

 
 void
 ao_serial2_putchar(char c);
 
 void
 ao_serial2_putchar(char c);


@@ -104,7 +104,7 @@ int
 _ao_serial3_pollchar(void);
 
 uint8_t
 _ao_serial3_pollchar(void);
 
 uint8_t

-_ao_serial3_sleep(void);
+_ao_serial3_sleep_for(uint16_t timeout);

 
 void
 ao_serial3_putchar(char c);
 
 void
 ao_serial3_putchar(char c);

diff --git a/src/kernel/ao_task.c b/src/kernel/ao_task.c
index bafb49439d4441022be1b9159947f30a9f8d7bff..1ecdd7dd1261246dc18eeb1483262274c2a76cb9 100644 (file)
--- a/src/kernel/ao_task.c
+++ b/src/kernel/ao_task.c
@@ -450,7 +450,7 @@ ao_wakeup(__xdata void *wchan) __reentrant
        ao_check_stack();
 }
 
        ao_check_stack();
 }
 

-void
+static void

 ao_alarm(uint16_t delay)
 {
 #if HAS_TASK_QUEUE
 ao_alarm(uint16_t delay)
 {
 #if HAS_TASK_QUEUE


@@ -468,7 +468,7 @@ ao_alarm(uint16_t delay)
 #endif
 }
 
 #endif
 }
 

-void
+static void

 ao_clear_alarm(void)
 {
 #if HAS_TASK_QUEUE
 ao_clear_alarm(void)
 {
 #if HAS_TASK_QUEUE


@@ -483,14 +483,24 @@ ao_clear_alarm(void)
 #endif
 }
 
 #endif
 }
 

+uint8_t
+ao_sleep_for(__xdata void *wchan, uint16_t timeout)
+{
+       uint8_t ret;
+       if (timeout)
+               ao_alarm(timeout);
+       ret = ao_sleep(wchan);
+       if (timeout)
+               ao_clear_alarm();
+       return ret;
+}
+

 static __xdata uint8_t ao_forever;
 
 void
 ao_delay(uint16_t ticks)
 {
 static __xdata uint8_t ao_forever;
 
 void
 ao_delay(uint16_t ticks)
 {

-       ao_alarm(ticks);
-       ao_sleep(&ao_forever);
-       ao_clear_alarm();
+       ao_sleep_for(&ao_forever, ticks);

 }
 
 void
 }
 
 void

diff --git a/src/kernel/ao_task.h b/src/kernel/ao_task.h
index 9c56b48021d6dd4ebe83c69f44aa04c5ade023c3..c6bec0e397dccba3f1625160330ff4af049f27fa 100644 (file)
--- a/src/kernel/ao_task.h
+++ b/src/kernel/ao_task.h
@@ -68,10 +68,19 @@ extern __data uint8_t ao_task_minimize_latency;     /* Reduce IRQ latency */
 uint8_t
 ao_sleep(__xdata void *wchan);
 
 uint8_t
 ao_sleep(__xdata void *wchan);
 

+/* Suspend the current task until wchan is awoken or the timeout
+ * expires. returns:
+ *  0 on normal wake
+ *  1 on alarm
+ */
+uint8_t
+ao_sleep_for(__xdata void *wchan, uint16_t timeout);
+

 /* Wake all tasks sleeping on wchan */
 void
 ao_wakeup(__xdata void *wchan) __reentrant;
 
 /* Wake all tasks sleeping on wchan */
 void
 ao_wakeup(__xdata void *wchan) __reentrant;
 

+#if 0

 /* set an alarm to go off in 'delay' ticks */
 void
 ao_alarm(uint16_t delay);
 /* set an alarm to go off in 'delay' ticks */
 void
 ao_alarm(uint16_t delay);


@@ -79,6 +88,7 @@ ao_alarm(uint16_t delay);
 /* Clear any pending alarm */
 void
 ao_clear_alarm(void);
 /* Clear any pending alarm */
 void
 ao_clear_alarm(void);

+#endif

 
 /* Yield the processor to another task */
 void
 
 /* Yield the processor to another task */
 void

diff --git a/src/kernel/ao_telemetry.c b/src/kernel/ao_telemetry.c
index e2197f7a24cb1f9ad735ed49ea0d3c7c99cfb3c3..854ac898dcbc646613caf036050e7ce205c6e2a0 100644 (file)
--- a/src/kernel/ao_telemetry.c
+++ b/src/kernel/ao_telemetry.c
@@ -486,9 +486,7 @@ ao_telemetry(void)
 #endif /* HAS_APRS */
                        delay = time - ao_time();
                        if (delay > 0) {
 #endif /* HAS_APRS */
                        delay = time - ao_time();
                        if (delay > 0) {

-                               ao_alarm(delay);
-                               ao_sleep(&telemetry);
-                               ao_clear_alarm();
+                               ao_sleep_for(&telemetry, delay);

                        }
                }
        }
                        }
                }
        }

diff --git a/src/product/ao_terraui.c b/src/product/ao_terraui.c
index 8fd97033d6533329bd25af5d0e5ee3bb453f36ff..1e7b5dcd58511cd8a4dec4a915b7642e2e306dfd 100644 (file)
--- a/src/product/ao_terraui.c
+++ b/src/product/ao_terraui.c
@@ -539,9 +539,7 @@ ao_terraui(void)
                else
                        ao_terraui_page[ao_current_page]();
 
                else
                        ao_terraui_page[ao_current_page]();
 

-               ao_alarm(AO_SEC_TO_TICKS(1));
-               b = ao_button_get();
-               ao_clear_alarm();
+               b = ao_button_get(AO_SEC_TO_TICKS(1));

 
                if (b > 0) {
                        ao_beep_for(AO_BEEP_HIGH, AO_MS_TO_TICKS(10));
 
                if (b > 0) {
                        ao_beep_for(AO_BEEP_HIGH, AO_MS_TO_TICKS(10));

diff --git a/src/stm/ao_i2c_stm.c b/src/stm/ao_i2c_stm.c
index 1c90cdb85c19193f223acaf40b970c9cfc74a267..158f5b218ebfe0edd877b4049322fb11b51f18fd 100644 (file)
--- a/src/stm/ao_i2c_stm.c
+++ b/src/stm/ao_i2c_stm.c
@@ -195,15 +195,13 @@ ao_i2c_start(uint8_t index, uint16_t addr)
                if (!(stm_i2c->cr1 & (1 << STM_I2C_CR1_START)))
                        break;
        }
                if (!(stm_i2c->cr1 & (1 << STM_I2C_CR1_START)))
                        break;
        }

-       ao_alarm(AO_MS_TO_TICKS(250));

        ao_arch_block_interrupts();
        stm_i2c->cr2 = AO_STM_I2C_CR2 | (1 << STM_I2C_CR2_ITEVTEN) | (1 << STM_I2C_CR2_ITERREN);
        ao_i2c_ev_isr(index);
        while (ao_i2c_state[index] == I2C_IDLE)
        ao_arch_block_interrupts();
        stm_i2c->cr2 = AO_STM_I2C_CR2 | (1 << STM_I2C_CR2_ITEVTEN) | (1 << STM_I2C_CR2_ITERREN);
        ao_i2c_ev_isr(index);
        while (ao_i2c_state[index] == I2C_IDLE)

-               if (ao_sleep(&ao_i2c_state[index]))
+               if (ao_sleep_for(&ao_i2c_state[index], AO_MS_TO_TICKS(250)))

                        break;
        ao_arch_release_interrupts();
                        break;
        ao_arch_release_interrupts();

-       ao_clear_alarm();

        return ao_i2c_state[index] == I2C_RUNNING;
 }
 
        return ao_i2c_state[index] == I2C_RUNNING;
 }
 


@@ -258,16 +256,14 @@ ao_i2c_send(void *block, uint16_t len, uint8_t index, uint8_t stop)
                            (STM_DMA_CCR_DIR_MEM_TO_PER << STM_DMA_CCR_DIR));
                           
        ao_dma_start(tx_dma_index);
                            (STM_DMA_CCR_DIR_MEM_TO_PER << STM_DMA_CCR_DIR));
                           
        ao_dma_start(tx_dma_index);

-       ao_alarm(1 + len);

        ao_arch_block_interrupts();
        while (!ao_dma_done[tx_dma_index])
        ao_arch_block_interrupts();
        while (!ao_dma_done[tx_dma_index])

-               if (ao_sleep(&ao_dma_done[tx_dma_index]))
+               if (ao_sleep_for(&ao_dma_done[tx_dma_index], 1 + len))

                        break;
                        break;

-       ao_clear_alarm();

        ao_dma_done_transfer(tx_dma_index);
        stm_i2c->cr2 = AO_STM_I2C_CR2 | (1 << STM_I2C_CR2_ITEVTEN) | (1 << STM_I2C_CR2_ITERREN);
        while ((stm_i2c->sr1 & (1 << STM_I2C_SR1_BTF)) == 0)
        ao_dma_done_transfer(tx_dma_index);
        stm_i2c->cr2 = AO_STM_I2C_CR2 | (1 << STM_I2C_CR2_ITEVTEN) | (1 << STM_I2C_CR2_ITERREN);
        while ((stm_i2c->sr1 & (1 << STM_I2C_SR1_BTF)) == 0)

-               if (ao_sleep(&ao_i2c_state[index]))
+               if (ao_sleep_for(&ao_i2c_state[index], 1 + len))

                        break;
        stm_i2c->cr2 = AO_STM_I2C_CR2;
        ao_arch_release_interrupts();
                        break;
        stm_i2c->cr2 = AO_STM_I2C_CR2;
        ao_arch_release_interrupts();


@@ -321,14 +317,12 @@ ao_i2c_recv(void *block, uint16_t len, uint8_t index, uint8_t stop)
                if (stop)
                        stm_i2c->cr1 = AO_STM_I2C_CR1 | (1 << STM_I2C_CR1_STOP);
 
                if (stop)
                        stm_i2c->cr1 = AO_STM_I2C_CR1 | (1 << STM_I2C_CR1_STOP);
 

-               ao_alarm(1);

                ao_arch_block_interrupts();
                while (ao_i2c_recv_len[index])
                ao_arch_block_interrupts();
                while (ao_i2c_recv_len[index])

-                       if (ao_sleep(&ao_i2c_recv_len[index]))
+                       if (ao_sleep_for(&ao_i2c_recv_len[index], 1))

                                break;
                ao_arch_release_interrupts();
                ret = ao_i2c_recv_len[index] == 0;
                                break;
                ao_arch_release_interrupts();
                ret = ao_i2c_recv_len[index] == 0;

-               ao_clear_alarm();

        } else {
                uint8_t         rx_dma_index = ao_i2c_stm_info[index].rx_dma_index;
                ao_dma_set_transfer(rx_dma_index,
        } else {
                uint8_t         rx_dma_index = ao_i2c_stm_info[index].rx_dma_index;
                ao_dma_set_transfer(rx_dma_index,


@@ -351,13 +345,11 @@ ao_i2c_recv(void *block, uint16_t len, uint8_t index, uint8_t stop)
                ao_i2c_wait_addr(index);
 
                ao_dma_start(rx_dma_index);
                ao_i2c_wait_addr(index);
 
                ao_dma_start(rx_dma_index);

-               ao_alarm(len);

                ao_arch_block_interrupts();
                while (!ao_dma_done[rx_dma_index])
                ao_arch_block_interrupts();
                while (!ao_dma_done[rx_dma_index])

-                       if (ao_sleep(&ao_dma_done[rx_dma_index]))
+                       if (ao_sleep_for(&ao_dma_done[rx_dma_index], len))

                                break;
                ao_arch_release_interrupts();
                                break;
                ao_arch_release_interrupts();

-               ao_clear_alarm();

                ret = ao_dma_done[rx_dma_index];
                ao_dma_done_transfer(rx_dma_index);
                stm_i2c->cr1 = AO_STM_I2C_CR1 | (1 << STM_I2C_CR1_STOP);
                ret = ao_dma_done[rx_dma_index];
                ao_dma_done_transfer(rx_dma_index);
                stm_i2c->cr1 = AO_STM_I2C_CR1 | (1 << STM_I2C_CR1_STOP);

diff --git a/src/stm/ao_serial_stm.c b/src/stm/ao_serial_stm.c
index 2568cf430fe5cb92eccc751ae463d2e8c8ccf796..88f2d0299ecf65f1b350dde44e0ede1d744c7c1f 100644 (file)
--- a/src/stm/ao_serial_stm.c
+++ b/src/stm/ao_serial_stm.c
@@ -86,9 +86,9 @@ ao_usart_getchar(struct ao_stm_usart *usart)
 }
 
 static inline uint8_t
 }
 
 static inline uint8_t

-_ao_usart_sleep(struct ao_stm_usart *usart)
+_ao_usart_sleep_for(struct ao_stm_usart *usart, uint16_t timeout)

 {
 {

-       return ao_sleep(&usart->rx_fifo);
+       return ao_sleep_for(&usart->rx_fifo, timeout);

 }
 
 void
 }
 
 void


@@ -217,9 +217,9 @@ _ao_serial1_pollchar(void)
 }
 
 uint8_t
 }
 
 uint8_t

-_ao_serial1_sleep(void)
+_ao_serial1_sleep_for(uint16_t timeout)

 {
 {

-       return _ao_usart_sleep(&ao_stm_usart1);
+       return _ao_usart_sleep_for(&ao_stm_usart1, timeout);

 }
 
 void
 }
 
 void


@@ -260,9 +260,9 @@ _ao_serial2_pollchar(void)
 }
 
 uint8_t
 }
 
 uint8_t

-_ao_serial2_sleep(void)
+_ao_serial2_sleep_for(uint16_t timeout)

 {
 {

-       return _ao_usart_sleep(&ao_stm_usart2);
+       return _ao_usart_sleep_for(&ao_stm_usart2, timeout);

 }
 
 void
 }
 
 void


@@ -303,9 +303,9 @@ _ao_serial3_pollchar(void)
 }
 
 uint8_t
 }
 
 uint8_t

-_ao_serial3_sleep(void)
+_ao_serial3_sleep_for(uint16_t timeout)

 {
 {

-       return _ao_usart_sleep(&ao_stm_usart3);
+       return _ao_usart_sleep_for(&ao_stm_usart3, timeout);

 }
 
 void
 }
 
 void

diff --git a/src/telebt-v3.0/ao_pins.h b/src/telebt-v3.0/ao_pins.h
index 838f0dfcfbc948d73c2e9fa3e8c170ddca96abcb..6e90afcc16c63d32043f19e79b86bbd594f09949 100644 (file)
--- a/src/telebt-v3.0/ao_pins.h
+++ b/src/telebt-v3.0/ao_pins.h
@@ -168,7 +168,7 @@ struct ao_adc {
 #define ao_serial_btm_getchar  ao_serial2_getchar
 #define ao_serial_btm_putchar  ao_serial2_putchar
 #define _ao_serial_btm_pollchar        _ao_serial2_pollchar
 #define ao_serial_btm_getchar  ao_serial2_getchar
 #define ao_serial_btm_putchar  ao_serial2_putchar
 #define _ao_serial_btm_pollchar        _ao_serial2_pollchar

-#define _ao_serial_btm_sleep   _ao_serial2_sleep
+#define _ao_serial_btm_sleep_for       _ao_serial2_sleep_for

 #define ao_serial_btm_set_speed ao_serial2_set_speed
 #define ao_serial_btm_drain    ao_serial2_drain
 #define ao_serial_btm_rx_fifo  (ao_stm_usart2.rx_fifo)
 #define ao_serial_btm_set_speed ao_serial2_set_speed
 #define ao_serial_btm_drain    ao_serial2_drain
 #define ao_serial_btm_rx_fifo  (ao_stm_usart2.rx_fifo)

diff --git a/src/telelco-v0.1/ao_lco.c b/src/telelco-v0.1/ao_lco.c
index 79f3896baff9a5adcb0f96785a0b43be0b812c46..cb2195efc928540c2f1455812cfa15a996a5a8f4 100644 (file)
--- a/src/telelco-v0.1/ao_lco.c
+++ b/src/telelco-v0.1/ao_lco.c
@@ -280,9 +280,7 @@ ao_lco_igniter_status(void)
        uint16_t        delay;
 
        for (;;) {
        uint16_t        delay;
 
        for (;;) {

-//             ao_alarm(delay);

                ao_sleep(&ao_pad_query);
                ao_sleep(&ao_pad_query);

-//             ao_clear_alarm();

                if (!ao_lco_valid) {
                        ao_led_on(AO_LED_RED);
                        ao_led_off(AO_LED_GREEN);
                if (!ao_lco_valid) {
                        ao_led_on(AO_LED_RED);
                        ao_led_off(AO_LED_GREEN);


@@ -364,9 +362,7 @@ ao_lco_monitor(void)
                        delay = AO_MS_TO_TICKS(100);
                else
                        delay = AO_SEC_TO_TICKS(1);
                        delay = AO_MS_TO_TICKS(100);
                else
                        delay = AO_SEC_TO_TICKS(1);

-               ao_alarm(delay);
-               ao_sleep(&ao_lco_armed);
-               ao_clear_alarm();
+               ao_sleep_for(&ao_lco_armed, delay);

        }
 }
 
        }
 }
 

diff --git a/src/telelco-v0.2/ao_lco.c b/src/telelco-v0.2/ao_lco.c
index 4b5f7a9bbec58205ff7bf24d4a881563fad42f61..12a247bf05dfaa59d2d74a6c39a671ae6b993d4e 100644 (file)
--- a/src/telelco-v0.2/ao_lco.c
+++ b/src/telelco-v0.2/ao_lco.c
@@ -369,9 +369,7 @@ ao_lco_monitor(void)
                        delay = AO_MS_TO_TICKS(100);
                else
                        delay = AO_SEC_TO_TICKS(1);
                        delay = AO_MS_TO_TICKS(100);
                else
                        delay = AO_SEC_TO_TICKS(1);

-               ao_alarm(delay);
-               ao_sleep(&ao_lco_armed);
-               ao_clear_alarm();
+               ao_sleep_for(&ao_lco_armed, delay);

        }
 }
 
        }
 }