giomba/nes-proj
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #562 from simonduq/contrib/csma-busywait

Browse Source 
Reworked busy-wait routines
This commit is contained in:
Simon Duquennoy 2018-10-12 12:08:17 +02:00 committed by GitHub
commit b4a23467fa
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 76 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
arch/dev/cc1200/cc1200.c
View File

@ -310,15 +310,7 @@ extern const cc1200_rf_cfg_t CC1200_RF_CFG;
#define LOCK_SPI() do { spi_locked++; } while(0) #define LOCK_SPI() do { spi_locked++; } while(0)
#define SPI_IS_LOCKED() (spi_locked != 0) #define SPI_IS_LOCKED() (spi_locked != 0)
#define RELEASE_SPI() do { spi_locked--; } while(0) #define RELEASE_SPI() do { spi_locked--; } while(0)
/*---------------------------------------------------------------------------*/
#define BUSYWAIT_UNTIL(cond, max_time) \
do { \
rtimer_clock_t t0; \
t0 = RTIMER_NOW(); \
while(!(cond) && RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + (max_time))) { \
watchdog_periodic(); \
} \
} while(0)
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
#if CC1200_USE_GPIO2 #if CC1200_USE_GPIO2
/* Configure GPIO interrupts. GPIO0: falling, GPIO2: rising edge */ /* Configure GPIO interrupts. GPIO0: falling, GPIO2: rising edge */
@ -378,29 +370,9 @@ extern const cc1200_rf_cfg_t CC1200_RF_CFG;
#define INFO(...) #define INFO(...)
#endif #endif
#if DEBUG_LEVEL > 0 /* Busy-wait (time-bounded) until the radio reaches a given state */
/* #define RTIMER_BUSYWAIT_UNTIL_STATE(s, t) RTIMER_BUSYWAIT_UNTIL(state() == (s), t)
* As BUSYWAIT_UNTIL was mainly used to test for a state transition,
* we define a separate macro for this adding the possibility to
* throw an error message when the timeout exceeds
*/
#define BUSYWAIT_UNTIL_STATE(s, t) \
do { \
rtimer_clock_t t0; \
t0 = RTIMER_NOW(); \
while((state() != s) && RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + (t))) {} \
if(!(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + (t)))) { \
printf("RF: Timeout exceeded in line %d!\n", __LINE__); \
} \
} while(0)
#else
#define BUSYWAIT_UNTIL_STATE(s, t) \
do { \
rtimer_clock_t t0; \
t0 = RTIMER_NOW(); \
while((state() != s) && RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + (t))) {} \
} while(0)
#endif
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
/* Variables */ /* Variables */
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
@ -604,7 +576,7 @@ PROCESS_THREAD(cc1200_process, ev, data)
/* /*
* We are on and not in TX. As every function of this driver * We are on and not in TX. As every function of this driver
* assures that we are in RX mode * assures that we are in RX mode
* (using BUSYWAIT_UNTIL_STATE(STATE_RX, ...) construct) in * (using RTIMER_BUSYWAIT_UNTIL_STATE(STATE_RX, ...) construct) in
* either rx_rx(), idle_calibrate_rx() or transmit(), * either rx_rx(), idle_calibrate_rx() or transmit(),
* something probably went wrong in the rx interrupt handler * something probably went wrong in the rx interrupt handler
* if we are not in RX at this point. * if we are not in RX at this point.
@ -893,7 +865,7 @@ transmit(unsigned short transmit_len)
* again as they were turned off in idle() * again as they were turned off in idle()
*/ */
BUSYWAIT_UNTIL_STATE(STATE_RX, RTIMER_BUSYWAIT_UNTIL_STATE(STATE_RX,
CC1200_RF_CFG.tx_rx_turnaround); CC1200_RF_CFG.tx_rx_turnaround);
ENABLE_GPIO_INTERRUPTS(); ENABLE_GPIO_INTERRUPTS();
@ -1033,7 +1005,7 @@ channel_clear(void)
} }
/* Wait for CARRIER_SENSE_VALID signal */ /* Wait for CARRIER_SENSE_VALID signal */
BUSYWAIT_UNTIL(((rssi0 = single_read(CC1200_RSSI0)) RTIMER_BUSYWAIT_UNTIL(((rssi0 = single_read(CC1200_RSSI0))
& CC1200_CARRIER_SENSE_VALID), & CC1200_CARRIER_SENSE_VALID),
RTIMER_SECOND / 100); RTIMER_SECOND / 100);
RF_ASSERT(rssi0 & CC1200_CARRIER_SENSE_VALID); RF_ASSERT(rssi0 & CC1200_CARRIER_SENSE_VALID);
@ -1135,7 +1107,7 @@ on(void)
/* Wake-up procedure. Wait for GPIO0 to de-assert (CHIP_RDYn) */ /* Wake-up procedure. Wait for GPIO0 to de-assert (CHIP_RDYn) */
cc1200_arch_spi_select(); cc1200_arch_spi_select();
BUSYWAIT_UNTIL((cc1200_arch_gpio0_read_pin() == 0), RTIMER_BUSYWAIT_UNTIL((cc1200_arch_gpio0_read_pin() == 0),
RTIMER_SECOND / 100); RTIMER_SECOND / 100);
RF_ASSERT((cc1200_arch_gpio0_read_pin() == 0)); RF_ASSERT((cc1200_arch_gpio0_read_pin() == 0));
cc1200_arch_spi_deselect(); cc1200_arch_spi_deselect();
@ -1239,7 +1211,7 @@ get_rssi(void)
} }
/* Wait for CARRIER_SENSE_VALID signal */ /* Wait for CARRIER_SENSE_VALID signal */
BUSYWAIT_UNTIL(((rssi0 = single_read(CC1200_RSSI0)) RTIMER_BUSYWAIT_UNTIL(((rssi0 = single_read(CC1200_RSSI0))
& CC1200_CARRIER_SENSE_VALID), & CC1200_CARRIER_SENSE_VALID),
RTIMER_SECOND / 100); RTIMER_SECOND / 100);
RF_ASSERT(rssi0 & CC1200_CARRIER_SENSE_VALID); RF_ASSERT(rssi0 & CC1200_CARRIER_SENSE_VALID);
@ -1706,20 +1678,20 @@ configure(void)
while(1) { while(1) {
#if (CC1200_RF_TESTMODE == 1) #if (CC1200_RF_TESTMODE == 1)
watchdog_periodic(); watchdog_periodic();
BUSYWAIT_UNTIL(0, RTIMER_SECOND / 10); RTIMER_BUSYWAIT(RTIMER_SECOND / 10);
leds_off(LEDS_YELLOW); leds_off(LEDS_YELLOW);
leds_on(LEDS_RED); leds_on(LEDS_RED);
watchdog_periodic(); watchdog_periodic();
BUSYWAIT_UNTIL(0, RTIMER_SECOND / 10); RTIMER_BUSYWAIT(RTIMER_SECOND / 10);
leds_off(LEDS_RED); leds_off(LEDS_RED);
leds_on(LEDS_YELLOW); leds_on(LEDS_YELLOW);
#else #else
watchdog_periodic(); watchdog_periodic();
BUSYWAIT_UNTIL(0, RTIMER_SECOND / 10); RTIMER_BUSYWAIT(RTIMER_SECOND / 10);
leds_off(LEDS_GREEN); leds_off(LEDS_GREEN);
leds_on(LEDS_RED); leds_on(LEDS_RED);
watchdog_periodic(); watchdog_periodic();
BUSYWAIT_UNTIL(0, RTIMER_SECOND / 10); RTIMER_BUSYWAIT(RTIMER_SECOND / 10);
leds_off(LEDS_RED); leds_off(LEDS_RED);
leds_on(LEDS_GREEN); leds_on(LEDS_GREEN);
#endif #endif
@ -1741,11 +1713,11 @@ configure(void)
while(1) { while(1) {
watchdog_periodic(); watchdog_periodic();
BUSYWAIT_UNTIL(0, RTIMER_SECOND / 10); RTIMER_BUSYWAIT(RTIMER_SECOND / 10);
leds_off(LEDS_GREEN); leds_off(LEDS_GREEN);
leds_on(LEDS_YELLOW); leds_on(LEDS_YELLOW);
watchdog_periodic(); watchdog_periodic();
BUSYWAIT_UNTIL(0, RTIMER_SECOND / 10); RTIMER_BUSYWAIT(RTIMER_SECOND / 10);
leds_off(LEDS_YELLOW); leds_off(LEDS_YELLOW);
leds_on(LEDS_GREEN); leds_on(LEDS_GREEN);
clock_delay_usec(1000); clock_delay_usec(1000);
@ -1866,8 +1838,8 @@ calibrate(void)
INFO("RF: Calibrate\n"); INFO("RF: Calibrate\n");
strobe(CC1200_SCAL); strobe(CC1200_SCAL);
BUSYWAIT_UNTIL_STATE(STATE_CALIBRATE, RTIMER_SECOND / 100); RTIMER_BUSYWAIT_UNTIL_STATE(STATE_CALIBRATE, RTIMER_SECOND / 100);
BUSYWAIT_UNTIL_STATE(STATE_IDLE, RTIMER_SECOND / 100); RTIMER_BUSYWAIT_UNTIL_STATE(STATE_IDLE, RTIMER_SECOND / 100);
#if CC1200_CAL_TIMEOUT_SECONDS #if CC1200_CAL_TIMEOUT_SECONDS
cal_timer = clock_seconds(); cal_timer = clock_seconds();
@ -1904,7 +1876,7 @@ idle(void)
} }
strobe(CC1200_SIDLE); strobe(CC1200_SIDLE);
BUSYWAIT_UNTIL_STATE(STATE_IDLE, RTIMER_SECOND / 100); RTIMER_BUSYWAIT_UNTIL_STATE(STATE_IDLE, RTIMER_SECOND / 100);
} /* idle(), 21.05.2015 */ } /* idle(), 21.05.2015 */
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
@ -1922,7 +1894,7 @@ idle_calibrate_rx(void)
rf_flags &= ~RF_RX_PROCESSING_PKT; rf_flags &= ~RF_RX_PROCESSING_PKT;
strobe(CC1200_SFRX); strobe(CC1200_SFRX);
strobe(CC1200_SRX); strobe(CC1200_SRX);
BUSYWAIT_UNTIL_STATE(STATE_RX, RTIMER_SECOND / 100); RTIMER_BUSYWAIT_UNTIL_STATE(STATE_RX, RTIMER_SECOND / 100);
ENABLE_GPIO_INTERRUPTS(); ENABLE_GPIO_INTERRUPTS();
@ -1947,7 +1919,7 @@ rx_rx(void)
strobe(CC1200_SFTX); strobe(CC1200_SFTX);
} else { } else {
strobe(CC1200_SIDLE); strobe(CC1200_SIDLE);
BUSYWAIT_UNTIL_STATE(STATE_IDLE, RTIMER_BUSYWAIT_UNTIL_STATE(STATE_IDLE,
RTIMER_SECOND / 100); RTIMER_SECOND / 100);
} }
@ -1959,7 +1931,7 @@ rx_rx(void)
strobe(CC1200_SFRX); strobe(CC1200_SFRX);
strobe(CC1200_SRX); strobe(CC1200_SRX);
BUSYWAIT_UNTIL_STATE(STATE_RX, RTIMER_SECOND / 100); RTIMER_BUSYWAIT_UNTIL_STATE(STATE_RX, RTIMER_SECOND / 100);
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
@ -2002,14 +1974,14 @@ idle_tx_rx(const uint8_t *payload, uint16_t payload_len)
#if USE_SFSTXON #if USE_SFSTXON
/* Wait for synthesizer to be ready */ /* Wait for synthesizer to be ready */
BUSYWAIT_UNTIL_STATE(STATE_FSTXON, RTIMER_SECOND / 100); RTIMER_BUSYWAIT_UNTIL_STATE(STATE_FSTXON, RTIMER_SECOND / 100);
#endif #endif
/* Start TX */ /* Start TX */
strobe(CC1200_STX); strobe(CC1200_STX);
/* Wait for TX to start. */ /* Wait for TX to start. */
BUSYWAIT_UNTIL((cc1200_arch_gpio0_read_pin() == 1), RTIMER_SECOND / 100); RTIMER_BUSYWAIT_UNTIL((cc1200_arch_gpio0_read_pin() == 1), RTIMER_SECOND / 100);
/* Turned off at the latest in idle() */ /* Turned off at the latest in idle() */
TX_LEDS_ON(); TX_LEDS_ON();
@ -2072,7 +2044,7 @@ idle_tx_rx(const uint8_t *payload, uint16_t payload_len)
*/ */
INFO("RF: TX failure!\n"); INFO("RF: TX failure!\n");
BUSYWAIT_UNTIL((state() != STATE_TX), RTIMER_SECOND / 100); RTIMER_BUSYWAIT_UNTIL((state() != STATE_TX), RTIMER_SECOND / 100);
/* Re-configure GPIO2 */ /* Re-configure GPIO2 */
single_write(CC1200_IOCFG2, GPIO2_IOCFG); single_write(CC1200_IOCFG2, GPIO2_IOCFG);
idle(); idle();
@ -2086,12 +2058,12 @@ idle_tx_rx(const uint8_t *payload, uint16_t payload_len)
} else { } else {
/* Wait for TX to complete */ /* Wait for TX to complete */
BUSYWAIT_UNTIL((cc1200_arch_gpio0_read_pin() == 0), RTIMER_BUSYWAIT_UNTIL((cc1200_arch_gpio0_read_pin() == 0),
CC1200_RF_CFG.tx_pkt_lifetime); CC1200_RF_CFG.tx_pkt_lifetime);
} }
#else #else
/* Wait for TX to complete */ /* Wait for TX to complete */
BUSYWAIT_UNTIL((cc1200_arch_gpio0_read_pin() == 0), RTIMER_BUSYWAIT_UNTIL((cc1200_arch_gpio0_read_pin() == 0),
CC1200_RF_CFG.tx_pkt_lifetime); CC1200_RF_CFG.tx_pkt_lifetime);
#endif #endif

7
arch/platform/cooja/dev/watchdog.c
View File

@ -30,8 +30,10 @@
* *
*/ */
/* Dummy watchdog routines for the Raven 1284p */ /* Dummy watchdog routines for Cooja motes */
#include "dev/watchdog.h" #include "dev/watchdog.h"
#include "lib/simEnvChange.h"
#include "sys/cooja_mt.h"
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
void void
@ -47,6 +49,9 @@ watchdog_start(void)
void void
watchdog_periodic(void) watchdog_periodic(void)
{ {
/* Yield and give control back to the simulator scheduler */
simProcessRunValue = 1;
cooja_mt_yield();
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
void void

13
arch/platform/jn516x/dev/micromac-radio.c
View File

@ -130,13 +130,6 @@
#define MICROMAC_CONF_ALWAYS_ON 1 #define MICROMAC_CONF_ALWAYS_ON 1
#endif /* MICROMAC_CONF_ALWAYS_ON */ #endif /* MICROMAC_CONF_ALWAYS_ON */
#define BUSYWAIT_UNTIL(cond, max_time) \
do { \
rtimer_clock_t t0; \
t0 = RTIMER_NOW(); \
while(!(cond) && RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + (max_time))) ; \
} while(0)
/* Local variables */ /* Local variables */
static volatile signed char radio_last_rssi; static volatile signed char radio_last_rssi;
static volatile uint8_t radio_last_correlation; /* LQI */ static volatile uint8_t radio_last_correlation; /* LQI */
@ -377,14 +370,14 @@ transmit(unsigned short payload_len)
(send_on_cca ? E_MMAC_TX_USE_CCA : E_MMAC_TX_NO_CCA)); (send_on_cca ? E_MMAC_TX_USE_CCA : E_MMAC_TX_NO_CCA));
#endif #endif
if(poll_mode) { if(poll_mode) {
BUSYWAIT_UNTIL(u32MMAC_PollInterruptSource(E_MMAC_INT_TX_COMPLETE), MAX_PACKET_DURATION); RTIMER_BUSYWAIT_UNTIL(u32MMAC_PollInterruptSource(E_MMAC_INT_TX_COMPLETE), MAX_PACKET_DURATION);
} else { } else {
if(in_ack_transmission) { if(in_ack_transmission) {
/* as nested interupts are not possible, the tx flag will never be cleared */ /* as nested interupts are not possible, the tx flag will never be cleared */
BUSYWAIT_UNTIL(FALSE, MAX_ACK_DURATION); RTIMER_BUSYWAIT_UNTIL(FALSE, MAX_ACK_DURATION);
} else { } else {
/* wait until the tx flag is cleared */ /* wait until the tx flag is cleared */
BUSYWAIT_UNTIL(!tx_in_progress, MAX_PACKET_DURATION); RTIMER_BUSYWAIT_UNTIL(!tx_in_progress, MAX_PACKET_DURATION);
} }
} }

10
arch/platform/jn516x/dev/uart-driver.c
View File

@ -66,14 +66,6 @@ extern volatile unsigned char xonxoff_state;
#endif /* UART_XONXOFF_FLOW_CTRL */ #endif /* UART_XONXOFF_FLOW_CTRL */
/*** Macro Definitions ***/
#define BUSYWAIT_UNTIL(cond, max_time) \
do { \
rtimer_clock_t t0; \
t0 = RTIMER_NOW(); \
while(!(cond) && RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + (max_time))) ; \
} while(0)
#define DEBUG_UART_BUFFERED FALSE #define DEBUG_UART_BUFFERED FALSE
#define CHAR_DEADLINE (uart_char_delay * 100) #define CHAR_DEADLINE (uart_char_delay * 100)
@ -276,7 +268,7 @@ uart_driver_write_with_deadline(uint8_t uart_dev, uint8_t ch)
volatile int16_t write = 0; volatile int16_t write = 0;
watchdog_periodic(); watchdog_periodic();
/* wait until there is space in tx fifo */ /* wait until there is space in tx fifo */
BUSYWAIT_UNTIL(write = (uart_driver_get_tx_fifo_available_space(uart_dev) > 0), RTIMER_BUSYWAIT_UNTIL(write = (uart_driver_get_tx_fifo_available_space(uart_dev) > 0),
CHAR_DEADLINE); CHAR_DEADLINE);
/* write only if there is space so we do not get stuck */ /* write only if there is space so we do not get stuck */
if(write) { if(write) {

15
arch/platform/zoul/dev/cc1200-zoul-arch.c
View File

@ -76,18 +76,8 @@
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
#if DEBUG_CC1200_ARCH > 0 #if DEBUG_CC1200_ARCH > 0
#define PRINTF(...) printf(__VA_ARGS__) #define PRINTF(...) printf(__VA_ARGS__)
#define BUSYWAIT_UNTIL(cond, max_time) \
do { \
rtimer_clock_t t0; \
t0 = RTIMER_NOW(); \
while(!(cond) && RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + (max_time))) {} \
if(!(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + (max_time)))) { \
printf("ARCH: Timeout exceeded in line %d!\n", __LINE__); \
} \
} while(0)
#else #else
#define PRINTF(...) #define PRINTF(...)
#define BUSYWAIT_UNTIL(cond, max_time) while(!cond)
#endif #endif
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
extern int cc1200_rx_interrupt(void); extern int cc1200_rx_interrupt(void);
@ -105,7 +95,7 @@ cc1200_arch_spi_select(void)
/* Set CSn to low (0) */ /* Set CSn to low (0) */
GPIO_CLR_PIN(CC1200_SPI_CSN_PORT_BASE, CC1200_SPI_CSN_PIN_MASK); GPIO_CLR_PIN(CC1200_SPI_CSN_PORT_BASE, CC1200_SPI_CSN_PIN_MASK);
/* The MISO pin should go low before chip is fully enabled. */ /* The MISO pin should go low before chip is fully enabled. */
BUSYWAIT_UNTIL( RTIMER_BUSYWAIT_UNTIL(
GPIO_READ_PIN(CC1200_SPI_MISO_PORT_BASE, CC1200_SPI_MISO_PIN_MASK) == 0, GPIO_READ_PIN(CC1200_SPI_MISO_PORT_BASE, CC1200_SPI_MISO_PIN_MASK) == 0,
RTIMER_SECOND / 100); RTIMER_SECOND / 100);
} }
@ -288,7 +278,7 @@ cc1200_arch_init(void)
cc1200_arch_spi_deselect(); cc1200_arch_spi_deselect();
/* Ensure MISO is high */ /* Ensure MISO is high */
BUSYWAIT_UNTIL( RTIMER_BUSYWAIT_UNTIL(
GPIO_READ_PIN(CC1200_SPI_MISO_PORT_BASE, CC1200_SPI_MISO_PIN_MASK), GPIO_READ_PIN(CC1200_SPI_MISO_PORT_BASE, CC1200_SPI_MISO_PIN_MASK),
RTIMER_SECOND / 10); RTIMER_SECOND / 10);
} }
@ -297,4 +287,3 @@ cc1200_arch_init(void)
* @} * @}
* @} * @}
*/ */

13
arch/platform/zoul/dev/dht22.c
View File

@ -51,15 +51,6 @@
#define PRINTF(...) #define PRINTF(...)
#endif #endif
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
#define BUSYWAIT_UNTIL(max_time) \
do { \
rtimer_clock_t t0; \
t0 = RTIMER_NOW(); \
while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + (max_time))) { \
watchdog_periodic(); \
} \
} while(0)
/*---------------------------------------------------------------------------*/
#define DHT22_PORT_BASE GPIO_PORT_TO_BASE(DHT22_PORT) #define DHT22_PORT_BASE GPIO_PORT_TO_BASE(DHT22_PORT)
#define DHT22_PIN_MASK GPIO_PIN_MASK(DHT22_PIN) #define DHT22_PIN_MASK GPIO_PIN_MASK(DHT22_PIN)
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
@ -80,12 +71,12 @@ dht22_read(void)
/* Exit low power mode and initialize variables */ /* Exit low power mode and initialize variables */
GPIO_SET_OUTPUT(DHT22_PORT_BASE, DHT22_PIN_MASK); GPIO_SET_OUTPUT(DHT22_PORT_BASE, DHT22_PIN_MASK);
GPIO_SET_PIN(DHT22_PORT_BASE, DHT22_PIN_MASK); GPIO_SET_PIN(DHT22_PORT_BASE, DHT22_PIN_MASK);
BUSYWAIT_UNTIL(DHT22_AWAKE_TIME); RTIMER_BUSYWAIT(DHT22_AWAKE_TIME);
memset(dht22_data, 0, DHT22_BUFFER); memset(dht22_data, 0, DHT22_BUFFER);
/* Initialization sequence */ /* Initialization sequence */
GPIO_CLR_PIN(DHT22_PORT_BASE, DHT22_PIN_MASK); GPIO_CLR_PIN(DHT22_PORT_BASE, DHT22_PIN_MASK);
BUSYWAIT_UNTIL(DHT22_START_TIME); RTIMER_BUSYWAIT(DHT22_START_TIME);
GPIO_SET_PIN(DHT22_PORT_BASE, DHT22_PIN_MASK); GPIO_SET_PIN(DHT22_PORT_BASE, DHT22_PIN_MASK);
clock_delay_usec(DHT22_READY_TIME); clock_delay_usec(DHT22_READY_TIME);

31
os/net/mac/csma/csma-output.c
View File

@ -50,11 +50,6 @@
#include "lib/list.h" #include "lib/list.h"
#include "lib/memb.h" #include "lib/memb.h"
#if CONTIKI_TARGET_COOJA
#include "lib/simEnvChange.h"
#include "sys/cooja_mt.h"
#endif /* CONTIKI_TARGET_COOJA */
/* Log configuration */ /* Log configuration */
#include "sys/log.h" #include "sys/log.h"
#define LOG_MODULE "CSMA" #define LOG_MODULE "CSMA"
@ -201,17 +196,10 @@ send_one_packet(void *ptr)
if(is_broadcast) { if(is_broadcast) {
ret = MAC_TX_OK; ret = MAC_TX_OK;
} else { } else {
rtimer_clock_t wt;
/* Check for ack */ /* Check for ack */
wt = RTIMER_NOW();
watchdog_periodic(); /* Wait for max CSMA_ACK_WAIT_TIME */
while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + CSMA_ACK_WAIT_TIME)) { RTIMER_BUSYWAIT_UNTIL(NETSTACK_RADIO.pending_packet(), CSMA_ACK_WAIT_TIME);
#if CONTIKI_TARGET_COOJA
simProcessRunValue = 1;
cooja_mt_yield();
#endif /* CONTIKI_TARGET_COOJA */
}
ret = MAC_TX_NOACK; ret = MAC_TX_NOACK;
if(NETSTACK_RADIO.receiving_packet() || if(NETSTACK_RADIO.receiving_packet() ||
@ -220,17 +208,8 @@ send_one_packet(void *ptr)
int len; int len;
uint8_t ackbuf[CSMA_ACK_LEN]; uint8_t ackbuf[CSMA_ACK_LEN];
if(CSMA_AFTER_ACK_DETECTED_WAIT_TIME > 0) { /* Wait an additional CSMA_AFTER_ACK_DETECTED_WAIT_TIME to complete reception */
wt = RTIMER_NOW(); RTIMER_BUSYWAIT_UNTIL(NETSTACK_RADIO.pending_packet(), CSMA_AFTER_ACK_DETECTED_WAIT_TIME);
watchdog_periodic();
while(RTIMER_CLOCK_LT(RTIMER_NOW(),
wt + CSMA_AFTER_ACK_DETECTED_WAIT_TIME)) {
#if CONTIKI_TARGET_COOJA
simProcessRunValue = 1;
cooja_mt_yield();
#endif /* CONTIKI_TARGET_COOJA */
}
}
if(NETSTACK_RADIO.pending_packet()) { if(NETSTACK_RADIO.pending_packet()) {
len = NETSTACK_RADIO.read(ackbuf, CSMA_ACK_LEN); len = NETSTACK_RADIO.read(ackbuf, CSMA_ACK_LEN);

23
os/net/mac/tsch/tsch-slot-operation.c
View File

@ -52,10 +52,6 @@
#include "net/queuebuf.h" #include "net/queuebuf.h"
#include "net/mac/framer/framer-802154.h" #include "net/mac/framer/framer-802154.h"
#include "net/mac/tsch/tsch.h" #include "net/mac/tsch/tsch.h"
#if CONTIKI_TARGET_COOJA
#include "lib/simEnvChange.h"
#include "sys/cooja_mt.h"
#endif /* CONTIKI_TARGET_COOJA */
#include "sys/log.h" #include "sys/log.h"
/* TSCH debug macros, i.e. to set LEDs or GPIOs on various TSCH /* TSCH debug macros, i.e. to set LEDs or GPIOs on various TSCH
@ -206,10 +202,7 @@ tsch_get_lock(void)
busy_wait = 1; busy_wait = 1;
busy_wait_time = RTIMER_NOW(); busy_wait_time = RTIMER_NOW();
while(tsch_in_slot_operation) { while(tsch_in_slot_operation) {
#if CONTIKI_TARGET_COOJA watchdog_periodic();
simProcessRunValue = 1;
cooja_mt_yield();
#endif /* CONTIKI_TARGET_COOJA */
} }
busy_wait_time = RTIMER_NOW() - busy_wait_time; busy_wait_time = RTIMER_NOW() - busy_wait_time;
} }
@ -303,7 +296,7 @@ tsch_schedule_slot_operation(struct rtimer *tm, rtimer_clock_t ref_time, rtimer_
} }
/* block until the time to schedule comes */ /* block until the time to schedule comes */
BUSYWAIT_UNTIL_ABS(0, ref_time, offset); RTIMER_BUSYWAIT_UNTIL_ABS(0, ref_time, offset);
return 0; return 0;
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
@ -314,7 +307,7 @@ tsch_schedule_slot_operation(struct rtimer *tm, rtimer_clock_t ref_time, rtimer_
do { \ do { \
if(tsch_schedule_slot_operation(tm, ref_time, offset - RTIMER_GUARD, str)) { \ if(tsch_schedule_slot_operation(tm, ref_time, offset - RTIMER_GUARD, str)) { \
PT_YIELD(pt); \ PT_YIELD(pt); \
BUSYWAIT_UNTIL_ABS(0, ref_time, offset); \ RTIMER_BUSYWAIT_UNTIL_ABS(0, ref_time, offset); \
} \ } \
} while(0); } while(0);
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
@ -514,7 +507,7 @@ PT_THREAD(tsch_tx_slot(struct pt *pt, struct rtimer *t))
TSCH_DEBUG_TX_EVENT(); TSCH_DEBUG_TX_EVENT();
tsch_radio_on(TSCH_RADIO_CMD_ON_WITHIN_TIMESLOT); tsch_radio_on(TSCH_RADIO_CMD_ON_WITHIN_TIMESLOT);
/* CCA */ /* CCA */
BUSYWAIT_UNTIL_ABS(!(cca_status &= NETSTACK_RADIO.channel_clear()), RTIMER_BUSYWAIT_UNTIL_ABS(!(cca_status &= NETSTACK_RADIO.channel_clear()),
current_slot_start, tsch_timing[tsch_ts_cca_offset] + tsch_timing[tsch_ts_cca]); current_slot_start, tsch_timing[tsch_ts_cca_offset] + tsch_timing[tsch_ts_cca]);
TSCH_DEBUG_TX_EVENT(); TSCH_DEBUG_TX_EVENT();
/* there is not enough time to turn radio off */ /* there is not enough time to turn radio off */
@ -561,14 +554,14 @@ PT_THREAD(tsch_tx_slot(struct pt *pt, struct rtimer *t))
TSCH_DEBUG_TX_EVENT(); TSCH_DEBUG_TX_EVENT();
tsch_radio_on(TSCH_RADIO_CMD_ON_WITHIN_TIMESLOT); tsch_radio_on(TSCH_RADIO_CMD_ON_WITHIN_TIMESLOT);
/* Wait for ACK to come */ /* Wait for ACK to come */
BUSYWAIT_UNTIL_ABS(NETSTACK_RADIO.receiving_packet(), RTIMER_BUSYWAIT_UNTIL_ABS(NETSTACK_RADIO.receiving_packet(),
tx_start_time, tx_duration + tsch_timing[tsch_ts_rx_ack_delay] + tsch_timing[tsch_ts_ack_wait] + RADIO_DELAY_BEFORE_DETECT); tx_start_time, tx_duration + tsch_timing[tsch_ts_rx_ack_delay] + tsch_timing[tsch_ts_ack_wait] + RADIO_DELAY_BEFORE_DETECT);
TSCH_DEBUG_TX_EVENT(); TSCH_DEBUG_TX_EVENT();
ack_start_time = RTIMER_NOW() - RADIO_DELAY_BEFORE_DETECT; ack_start_time = RTIMER_NOW() - RADIO_DELAY_BEFORE_DETECT;
/* Wait for ACK to finish */ /* Wait for ACK to finish */
BUSYWAIT_UNTIL_ABS(!NETSTACK_RADIO.receiving_packet(), RTIMER_BUSYWAIT_UNTIL_ABS(!NETSTACK_RADIO.receiving_packet(),
ack_start_time, tsch_timing[tsch_ts_max_ack]); ack_start_time, tsch_timing[tsch_ts_max_ack]);
TSCH_DEBUG_TX_EVENT(); TSCH_DEBUG_TX_EVENT();
tsch_radio_off(TSCH_RADIO_CMD_OFF_WITHIN_TIMESLOT); tsch_radio_off(TSCH_RADIO_CMD_OFF_WITHIN_TIMESLOT);
@ -748,7 +741,7 @@ PT_THREAD(tsch_rx_slot(struct pt *pt, struct rtimer *t))
packet_seen = NETSTACK_RADIO.receiving_packet() || NETSTACK_RADIO.pending_packet(); packet_seen = NETSTACK_RADIO.receiving_packet() || NETSTACK_RADIO.pending_packet();
if(!packet_seen) { if(!packet_seen) {
/* Check if receiving within guard time */ /* Check if receiving within guard time */
BUSYWAIT_UNTIL_ABS((packet_seen = NETSTACK_RADIO.receiving_packet()), RTIMER_BUSYWAIT_UNTIL_ABS((packet_seen = NETSTACK_RADIO.receiving_packet()),
current_slot_start, tsch_timing[tsch_ts_rx_offset] + tsch_timing[tsch_ts_rx_wait] + RADIO_DELAY_BEFORE_DETECT); current_slot_start, tsch_timing[tsch_ts_rx_offset] + tsch_timing[tsch_ts_rx_wait] + RADIO_DELAY_BEFORE_DETECT);
} }
if(!packet_seen) { if(!packet_seen) {
@ -760,7 +753,7 @@ PT_THREAD(tsch_rx_slot(struct pt *pt, struct rtimer *t))
rx_start_time = RTIMER_NOW() - RADIO_DELAY_BEFORE_DETECT; rx_start_time = RTIMER_NOW() - RADIO_DELAY_BEFORE_DETECT;
/* Wait until packet is received, turn radio off */ /* Wait until packet is received, turn radio off */
BUSYWAIT_UNTIL_ABS(!NETSTACK_RADIO.receiving_packet(), RTIMER_BUSYWAIT_UNTIL_ABS(!NETSTACK_RADIO.receiving_packet(),
current_slot_start, tsch_timing[tsch_ts_rx_offset] + tsch_timing[tsch_ts_rx_wait] + tsch_timing[tsch_ts_max_tx]); current_slot_start, tsch_timing[tsch_ts_rx_offset] + tsch_timing[tsch_ts_rx_wait] + tsch_timing[tsch_ts_max_tx]);
TSCH_DEBUG_RX_EVENT(); TSCH_DEBUG_RX_EVENT();
tsch_radio_off(TSCH_RADIO_CMD_OFF_WITHIN_TIMESLOT); tsch_radio_off(TSCH_RADIO_CMD_OFF_WITHIN_TIMESLOT);

2
os/net/mac/tsch/tsch.c
View File

@ -737,7 +737,7 @@ PT_THREAD(tsch_scan(struct pt *pt))
if(!is_packet_pending && NETSTACK_RADIO.receiving_packet()) { if(!is_packet_pending && NETSTACK_RADIO.receiving_packet()) {
/* If we are currently receiving a packet, wait until end of reception */ /* If we are currently receiving a packet, wait until end of reception */
t0 = RTIMER_NOW(); t0 = RTIMER_NOW();
BUSYWAIT_UNTIL_ABS((is_packet_pending = NETSTACK_RADIO.pending_packet()), t0, RTIMER_SECOND / 100); RTIMER_BUSYWAIT_UNTIL_ABS((is_packet_pending = NETSTACK_RADIO.pending_packet()), t0, RTIMER_SECOND / 100);
} }
if(is_packet_pending) { if(is_packet_pending) {

18
os/net/mac/tsch/tsch.h
View File

@ -65,30 +65,12 @@ frequency hopping for enhanced reliability.
#include "net/mac/tsch/tsch-rpl.h" #include "net/mac/tsch/tsch-rpl.h"
#endif /* UIP_CONF_IPV6_RPL */ #endif /* UIP_CONF_IPV6_RPL */
#if CONTIKI_TARGET_COOJA
#include "lib/simEnvChange.h"
#include "sys/cooja_mt.h"
#endif /* CONTIKI_TARGET_COOJA */
/* Include Arch-Specific conf */ /* Include Arch-Specific conf */
#ifdef TSCH_CONF_ARCH_HDR_PATH #ifdef TSCH_CONF_ARCH_HDR_PATH
#include TSCH_CONF_ARCH_HDR_PATH #include TSCH_CONF_ARCH_HDR_PATH
#endif /* TSCH_CONF_ARCH_HDR_PATH */ #endif /* TSCH_CONF_ARCH_HDR_PATH */
/*********** Macros *********/
/* Wait for a condition with timeout t0+offset. */
#if CONTIKI_TARGET_COOJA
#define BUSYWAIT_UNTIL_ABS(cond, t0, offset) \
while(!(cond) && RTIMER_CLOCK_LT(RTIMER_NOW(), (t0) + (offset))) { \
simProcessRunValue = 1; \
cooja_mt_yield(); \
};
#else
#define BUSYWAIT_UNTIL_ABS(cond, t0, offset) \
while(!(cond) && RTIMER_CLOCK_LT(RTIMER_NOW(), (t0) + (offset))) ;
#endif /* CONTIKI_TARGET_COOJA */
/*********** Callbacks *********/ /*********** Callbacks *********/
/* Link callbacks to RPL in case RPL is enabled */ /* Link callbacks to RPL in case RPL is enabled */

22
os/sys/rtimer.h
View File

@ -54,6 +54,8 @@
#define RTIMER_H_ #define RTIMER_H_
#include "contiki.h" #include "contiki.h"
#include "dev/watchdog.h"
#include <stdbool.h>
/** \brief The rtimer size (in bytes) */ /** \brief The rtimer size (in bytes) */
#ifdef RTIMER_CONF_CLOCK_SIZE #ifdef RTIMER_CONF_CLOCK_SIZE
@ -186,6 +188,26 @@ void rtimer_arch_schedule(rtimer_clock_t t);
#define RTIMER_GUARD_TIME (RTIMER_ARCH_SECOND >> 14) #define RTIMER_GUARD_TIME (RTIMER_ARCH_SECOND >> 14)
#endif /* RTIMER_CONF_GUARD_TIME */ #endif /* RTIMER_CONF_GUARD_TIME */
/** \brief Busy-wait until a condition. Start time is t0, max wait time is max_time */
#define RTIMER_BUSYWAIT_UNTIL_ABS(cond, t0, max_time) \
({ \
bool c; \
while(!(c = cond) && RTIMER_CLOCK_LT(RTIMER_NOW(), (t0) + (max_time))) { \
watchdog_periodic(); \
} \
c; \
})
/** \brief Busy-wait until a condition for at most max_time */
#define RTIMER_BUSYWAIT_UNTIL(cond, max_time) \
({ \
rtimer_clock_t t0 = RTIMER_NOW(); \
RTIMER_BUSYWAIT_UNTIL_ABS(cond, t0, max_time); \
})
/** \brief Busy-wait for a fixed duration */
#define RTIMER_BUSYWAIT(duration) RTIMER_BUSYWAIT_UNTIL(0, duration)
#endif /* RTIMER_H_ */ #endif /* RTIMER_H_ */
/** @} */ /** @} */