/*---------------------------------------------------------------------------*/ static int detect_ack(void) { #define INTER_PACKET_INTERVAL RTIMER_ARCH_SECOND / 5000 #define ACK_LEN 3 #define AFTER_ACK_DETECTECT_WAIT_TIME RTIMER_ARCH_SECOND / 1000 rtimer_clock_t wt; uint8_t ack_received = 0; wt = RTIMER_NOW(); leds_on(LEDS_GREEN); while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + INTER_PACKET_INTERVAL)) { } leds_off(LEDS_GREEN); /* Check for incoming ACK. */ if((NETSTACK_RADIO.receiving_packet() || NETSTACK_RADIO.pending_packet() || NETSTACK_RADIO.channel_clear() == 0)) { int len; uint8_t ackbuf[ACK_LEN + 2]; wt = RTIMER_NOW(); while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + AFTER_ACK_DETECTECT_WAIT_TIME)) { } len = NETSTACK_RADIO.read(ackbuf, ACK_LEN); if(len == ACK_LEN) { ack_received = 1; } } if(ack_received) { leds_toggle(LEDS_RED); } return ack_received; }
int sht21_humidity(void) { int val; i2c_enable(); /* For for about 15ms before the SHT11 can be used */ sht21_timer = RTIMER_NOW(); while(RTIMER_CLOCK_LT(RTIMER_NOW(), sht21_timer + (RTIMER_SECOND/1000)*15)); buf[0] = 0xe5; i2c_transmitinit(0x40, 1, buf); while(!i2c_transferred()) ; /* Wait for measurement about 85ms */ sht21_timer = RTIMER_NOW(); while(RTIMER_CLOCK_LT(RTIMER_NOW(), sht21_timer + (RTIMER_SECOND/1000)*85)); i2c_receiveinit(0x40, 3, buf); while(!i2c_transferred()) ; val = (int)(buf[0]<<24 | buf[1]<<16 | buf[2]<<8 | buf[3]); // i2c_disable(); /* return relative humidity * 100 (0.04 % accuracy) */ return (-6.0 + (125.0*((val>>16)&0x0000fffc))/0x10000)*100; }
static int set_locked(struct rtimer *rtimer, rtimer_clock_t time, rtimer_callback_t func, void *ptr) { struct rtimer **anchor; /* * RTIMER_ERR_ALREADY_SCHEDULED in rtimer.h suggests we should fail if the * timer is already scheduled. However, the original implementation allows * timers to be rescheduled with impunity, so we maintain de facto * compatibility. */ for (anchor = &next_rtimer; *anchor; anchor = &(*anchor)->next) if (*anchor == rtimer) { *anchor = rtimer->next; break; } rtimer->time = time; rtimer->func = func; rtimer->ptr = func; rtimer->cancel = 0; for (anchor = &next_rtimer; *anchor && RTIMER_CLOCK_LT((*anchor)->time, time); anchor = &(*anchor)->next); rtimer->next = *anchor; *anchor = rtimer; if (next_rtimer == rtimer) rtimer_arch_schedule(time); return RTIMER_OK; }
/** * @brief transmit_epidemic */ static void transmit_epidemic(){ packetbuf_clear(); data_packet_t *dpkt = (data_packet_t*)packetbuf_dataptr(); if(isAnchorFlag){ dpkt->type = ANCHOR_PKT; }else{ dpkt->type = PROBE_PKT; } //add sender offset. dpkt->offset = probe_offset; dpkt->period = get_node_period(); dpkt->src_id = rimeaddr_node_addr.u8[0]; uint8_t pldSize = 0; if(radio_read_flag == 0){ if(list_access_flag == 0){ list_access_flag = 1; pldSize = neighs_add2payload(&dpkt->data[0], isAnchorFlag, probe_offset); list_access_flag = 0; } //if(pldSize){ rtimer_clock_t t0; uint8_t i = 0, pkt_seen = 0, ccaCounter= 0; //ccaCounter= randomint_between(CCA_COUNT_MAX, CCA_COUNT_MAX_TX); ccaCounter = /*CCA_COUNT_MAX +*/ random_int(CCA_COUNT_MAX_TX); //watchdog watchdog_periodic(); for( i = 0; i < ccaCounter && beacon_2_flag; i++){ //watchdog watchdog_periodic(); t0 = RTIMER_NOW(); while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + CCA_CHECK_TIME)){ //do nothing.. KUNANGA } if(NETSTACK_RADIO.channel_clear() == 0){ pkt_seen = 1; break; // maybe return here .. collision is expected } } if((pkt_seen == 0) && (radio_read_flag == 0)){ NETSTACK_RADIO.send((void*)packetbuf_dataptr(),DATAPKT_HDR_LEN + pldSize); } //} //end of pldSize } }
int uart_receive(uint8_t *buffer, uint32_t count) { #ifndef __USE_UART_PORT3__ fprintf(stderr, "uart: __USE_UART_PORT3__ not defined\n"); return -1; #else uint32_t i = 0; int data = -1; rtimer_clock_t start; start = RTIMER_NOW(); for(i = 0; i < count; i++) { while((data = ringbuf_get(&uart_ring_buffer)) < 0) { if(current_timeout == NO_TIMEOUT) continue; if(RTIMER_CLOCK_LT(start + current_timeout, RTIMER_NOW())) { fprintf(stderr, "uart: Read timed out\n"); return -1; } } buffer[i] = (uint8_t)data; } return count; #endif }
/*---------------------------------------------------------------------------*/ static void hold_time(rtimer_clock_t interval) { rtimer_clock_t rct; rct = RTIMER_NOW(); while(RTIMER_CLOCK_LT(RTIMER_NOW(), rct+interval)){ } }
/*Detecta las condiciones del canal y lo añade o elimina de la blacklist*/ static int channel_conditions() { NETSTACK_RADIO.get_value(RADIO_PARAM_CHANNEL,& wake_up_channel); if(NETSTACK_RADIO.channel_clear()!= 0 ) { count = 0; /*Channel idle*/ /*Send the packet and channel's badness metric -1 (metric >=0). After a node sends a wake-up beacon: if CCA ==0 and not valid packet --> retransmit packet. If collision resolution fails --> channel's badness metric +2*/ if (badness_metric[wake_up_channel] > 0) { //If badness_metric<=15 remove channel from blacklist if (badness_metric[wake_up_channel] == threshold_Cbad+1) blacklist ^= (1<<(wake_up_channel)); //XOR //I think you should only remove the channel from the blacklist once it has passed T_black. /* A node R expires and removes from its channel blacklist the channels that have been on the blacklist for more than Tblack time and resets * the badness metric of such channel to 0. */ --badness_metric[wake_up_channel]; } return 1; } else if (NETSTACK_RADIO.channel_clear()== 0 ) { count++; if(count < 3) { t0 = RTIMER_NOW(); /*From ContikiMAC*/ while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + CCA_CHECK_TIME)) {} /* Then, after waiting this time, it should check again, doesn't it? */ } /*If channel still busy after three such CCA checks: channel's badness metric +2 and sleep*/ else { badness_metric[wake_up_channel]+= 2; //If badness_metric>15 include channel in blacklist if (badness_metric[wake_up_channel] > threshold_Cbad) blacklist |= (1<<(wake_up_channel)); //Sleep return 0; } } }
/*---------------------------------------------------------------------------*/ rtimer_clock_t cc26xx_rtc_get_next_trigger() { rtimer_clock_t ch2 = ti_lib_aon_rtc_compare_value_get(AON_RTC_CH2); if(HWREG(AON_RTC_BASE + AON_RTC_O_CHCTL) & AON_RTC_CHCTL_CH0_EN) { rtimer_clock_t ch0 = ti_lib_aon_rtc_compare_value_get(AON_RTC_CH2); return RTIMER_CLOCK_LT(ch0, ch2) ? ch0 : ch2; } return ch2; }
static void next_timer_locked(void) { rtimer_clock_t now = RTIMER_NOW(); struct rtimer *t; while (next_rtimer && !RTIMER_CLOCK_LT(now, next_rtimer->time)) { t = next_rtimer; next_rtimer = t->next; if (!t->cancel) t->func(t, t->ptr); } if (next_rtimer) rtimer_arch_schedule(next_rtimer->time); }
/*---------------------------------------------------------------------------*/ void rtimer_run_next(void) { int i, n; struct rtimer *t; /* Do not run timer if list is empty. */ if(next == firstempty) { return; } t = rtimers[next]; /* Increase the pointer to the next rtimer. */ next = (next + 1) % LIST_SIZE; /* Run the rtimer. */ PRINTF("rtimer_run_next running %p\n", t); t->func(t, t->ptr); if(next == firstempty) { PRINTF("rtimer_run_next: empty rtimer list\n"); /* The list is empty, no more rtimers to schedule. */ return; } /* Find the next rtimer to run. */ n = next; for(i = next; i != firstempty; i = (i + 1) % LIST_SIZE) { PRINTF("rtimer_run_next checking %p (%d) against %p (%d)\n", rtimers[i], rtimers[i]->time, rtimers[n], rtimers[n]->time); if(RTIMER_CLOCK_LT(rtimers[i]->time, rtimers[n]->time)) { n = i; } } PRINTF("rtimer_run_next next rtimer is %d %p (%d)\n", n, rtimers[n], rtimers[n]->time); /* Put the next rtimer first in the rtimer list. */ t = rtimers[next]; rtimers[next] = rtimers[n]; rtimers[n] = t; PRINTF("rtimer_run_next scheduling %d %p (%d)\n", next, rtimers[next], rtimers[next]->time); rtimer_arch_schedule(rtimers[next]->time); }
/** * @brief schedule_fixed * @param rt * @param next_time * @return */ static char schedule_fixed(struct rtimer *rt, rtimer_clock_t next_time){ if(RTIMER_CLOCK_LT(next_time, RTIMER_NOW() + 1)) { next_time = RTIMER_NOW() + 3; } int ret = rtimer_set(&generic_timer, next_time, 1, (void (*)(struct rtimer *, void *))power_cycle, NULL); if(ret){ PRINTF("synchronization failed\n"); } return 0; }
static char powercycle(struct rtimer *t, void *ptr) { if(is_streaming) { if(!RTIMER_CLOCK_LT(RTIMER_NOW(), stream_until)) { is_streaming = 0; rimeaddr_copy(&is_streaming_to, &rimeaddr_null); rimeaddr_copy(&is_streaming_to_too, &rimeaddr_null); } } PT_BEGIN(&pt); while(1) { /* Only wait for some cycles to pass for someone to start sending */ if(someone_is_sending > 0) { someone_is_sending--; } /* If there were a strobe in the air, turn radio on */ powercycle_turn_radio_on(); schedule_powercycle(t, xmac_config.on_time); PT_YIELD(&pt); if(xmac_config.off_time > 0 && !NETSTACK_RADIO.receiving_packet()) { powercycle_turn_radio_off(); if(waiting_for_packet != 0) { waiting_for_packet++; if(waiting_for_packet > 2) { /* We should not be awake for more than two consecutive power cycles without having heard a packet, so we turn off the radio. */ waiting_for_packet = 0; powercycle_turn_radio_off(); } } schedule_powercycle(t, xmac_config.off_time); PT_YIELD(&pt); } } PT_END(&pt); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(myTimer_process, ev, data) { static rtimer_clock_t t0; PROCESS_BEGIN(); printf("I start the timer (1 s.)\n"); while(1) { watchdog_periodic(); t0 = RTIMER_NOW(); while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + RTIMER_SECOND)); watchdog_periodic(); timeout_handler(); } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ static void schedule_powercycle_fixed(struct rtimer *t, rtimer_clock_t fixed_time) { int r; if(contikimac_is_on) { if(RTIMER_CLOCK_LT(fixed_time, RTIMER_NOW() + 1)) { fixed_time = RTIMER_NOW() + 1; } r = rtimer_set(t, fixed_time, 1, (void (*)(struct rtimer *, void *))powercycle, NULL); if(r != RTIMER_OK) { PRINTF("schedule_powercycle: could not set rtimer\n"); } } }
static void schedule_powercycle(struct rtimer *t, rtimer_clock_t time) { int r; if(contikimac_is_on) { if(RTIMER_CLOCK_LT(RTIMER_TIME(t) + time, RTIMER_NOW() + 2)) { time = RTIMER_NOW() - RTIMER_TIME(t) + 2; } r = rtimer_set(t, RTIMER_TIME(t) + time, 1, (void (*)(struct rtimer *, void *))powercycle, NULL); if(r != RTIMER_OK) { PRINTF("schedule_powercycle: could not set rtimer\n"); } } }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(energy_scan, ev, data) { PROCESS_BEGIN(); printf("Energy Scanner\n"); printf("CCA Threshold: %d\n", (int8_t)RSSIH); printf("Channel scan range: [%u , %u]\n", CHANNEL_MIN, CHANNEL_MAX); printf("%u samples per channel, interval %u ticks\n", RSSI_SAMPLES, SAMPLE_INTERVAL); channel = CHANNEL_MIN; while(1) { cmax = RSSI_BASE; cc2430_rf_channel_set(channel); clock_delay(200); for(j = 0; j < RSSI_SAMPLES; j++) { t0 = RTIMER_NOW(); rssi = RSSIL; if(rssi > cmax) { cmax = rssi; } while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + 25)); } printf("%u [%3d]: ", channel, cmax); for(j = RSSI_BASE; j <= cmax; j++) { printf("#"); } printf("\n"); if(channel == CHANNEL_MAX) { printf("===============\n"); channel = CHANNEL_MIN; } else { channel++; } etimer_set(&et, SAMPLE_INTERVAL); PROCESS_YIELD(); } PROCESS_END(); }
/*---------------------------------------------------------------------------*/ static void schedule_powercycle_fixed(struct rtimer *t, rtimer_clock_t fixed_time) { int r; rtimer_clock_t now; if(contikimac_is_on) { now = RTIMER_NOW(); if(RTIMER_CLOCK_LT(fixed_time, now + RTIMER_GUARD_TIME)) { fixed_time = now + RTIMER_GUARD_TIME; } r = rtimer_set(t, fixed_time, 1, powercycle_wrapper, NULL); if(r != RTIMER_OK) { PRINTF("schedule_powercycle: could not set rtimer\n"); } } }
/*---------------------------------------------------------------------------*/ static char cpowercycle(void *ptr) { if(is_streaming) { if(!RTIMER_CLOCK_LT(RTIMER_NOW(), stream_until)) { is_streaming = 0; rimeaddr_copy(&is_streaming_to, &rimeaddr_null); rimeaddr_copy(&is_streaming_to_too, &rimeaddr_null); } } PT_BEGIN(&pt); while(1) { /* Only wait for some cycles to pass for someone to start sending */ if(someone_is_sending > 0) { someone_is_sending--; } /* If there were a strobe in the air, turn radio on */ powercycle_turn_radio_on(); CSCHEDULE_POWERCYCLE(DEFAULT_ON_TIME); PT_YIELD(&pt); if(cxmac_config.off_time > 0) { powercycle_turn_radio_off(); if(waiting_for_packet != 0) { waiting_for_packet++; if(waiting_for_packet > 2) { /* We should not be awake for more than two consecutive power cycles without having heard a packet, so we turn off the radio. */ waiting_for_packet = 0; powercycle_turn_radio_off(); } } CSCHEDULE_POWERCYCLE(DEFAULT_OFF_TIME); PT_YIELD(&pt); } } PT_END(&pt); }
/*---------------------------------------------------------------------------*/ static int configure(int type, int c) { switch(type) { case SENSORS_ACTIVE: if(c) { if(!status(SENSORS_ACTIVE)) { rtimer_clock_t t0; sht11_init(); state = ON; /* For for about 11 ms before the SHT11 can be used. */ t0 = RTIMER_NOW(); while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + RTIMER_SECOND / 100)); } } else { sht11_off(); state = OFF; } } return 0; }
static void schedule_powercycle_fixed(struct rtimer *t, rtimer_clock_t fixed_time) { int r; if(contikimac_is_on) { if(RTIMER_CLOCK_LT(fixed_time, RTIMER_NOW() + 1)) { fixed_time = RTIMER_NOW() + 1; } #if NURTIMER r = rtimer_reschedule(t, RTIMER_TIME(t) - time, 1); #else r = rtimer_set(t, fixed_time, 1, (void (*)(struct rtimer *, void *))powercycle, NULL); #endif if(r != RTIMER_OK) { printf("schedule_powercycle: could not set rtimer\n"); } } }
/*---------------------------------------------------------------------------*/ static void advanceSlot(struct rtimer *t, void *ptr, int status) { off(TURN_OFF); last = RTIMER_TIME(t); if(!(rtimer_set(t, last + REGULAR_SLOT, 1, (void (*)(struct rtimer *, void *))advanceSlot, NULL) == RTIMER_OK)) { printf("%s\n", "WPI-MAC: Could not schedule task!!!!!"); } if(current_slot == TOTAL_SLOTS + 1) { current_slot = BROADCAST_SLOT; } else { current_slot++; } if(current_slot > (TOTAL_SLOTS - 1)) { current_slot = BROADCAST_SLOT; } //printf("Slot is now %u\n", current_slot); unsigned char somethingToSend = check_buffers(current_slot); if(somethingToSend) { // grab the necessary info from our queue QueuedPacket *curr = QPQueue[current_slot]; real_send(curr->sent, curr->ptr, curr->packet); } else if(current_slot == BROADCAST_SLOT || current_slot == node_id) { // just need to be awake to listen // if(!(rtimer_set(t, last + CONTENTION_PREPARE + (CONTENTION_TICKS * (CONTENTION_SLOTS)), 1, (void (*)(struct rtimer *, void *))async_on, NULL) == RTIMER_OK)){ // printf("%s\n", "Could not schedule task!!!!!"); // } rtimer_clock_t stall = last + CONTENTION_PREPARE + (CONTENTION_TICKS * (CONTENTION_SLOTS)); // printf("STALLLLL: %u %u %u %u\n", RTIMER_NOW(), stall, REGULAR_SLOT, last); while(RTIMER_CLOCK_LT(RTIMER_NOW(), stall)); if(!radio_is_on) on(); } else { // we can snooze if(radio_is_on) off(TURN_OFF); } }
/** * \brief Returns a reading from the sensor * \param type MPU_9250_SENSOR_TYPE_ACC_[XYZ] or MPU_9250_SENSOR_TYPE_GYRO_[XYZ] * \return centi-G (ACC) or centi-Deg/Sec (Gyro) */ static int value(int type) { int rv; float converted_val = 0; if(state == SENSOR_STATE_DISABLED) { PRINTF("MPU: Sensor Disabled\n"); return CC26XX_SENSOR_READING_ERROR; } memset(sensor_value, 0, sizeof(sensor_value)); if((type & MPU_9250_SENSOR_TYPE_ACC) != 0) { t0 = RTIMER_NOW(); while(!int_status() && (RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + READING_WAIT_TIMEOUT))); rv = acc_read(sensor_value); if(rv == 0) { return CC26XX_SENSOR_READING_ERROR; } PRINTF("MPU: ACC = 0x%04x 0x%04x 0x%04x = ", sensor_value[0], sensor_value[1], sensor_value[2]); /* Convert */ if(type == MPU_9250_SENSOR_TYPE_ACC_X) { converted_val = acc_convert(sensor_value[0]); } else if(type == MPU_9250_SENSOR_TYPE_ACC_Y) { converted_val = acc_convert(sensor_value[1]); } else if(type == MPU_9250_SENSOR_TYPE_ACC_Z) { converted_val = acc_convert(sensor_value[2]); } rv = (int)(converted_val * 100); } else if((type & MPU_9250_SENSOR_TYPE_GYRO) != 0) { t0 = RTIMER_NOW(); while(!int_status() && (RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + READING_WAIT_TIMEOUT))); rv = gyro_read(sensor_value); if(rv == 0) { return CC26XX_SENSOR_READING_ERROR; } PRINTF("MPU: Gyro = 0x%04x 0x%04x 0x%04x = ", sensor_value[0], sensor_value[1], sensor_value[2]); if(type == MPU_9250_SENSOR_TYPE_GYRO_X) { converted_val = gyro_convert(sensor_value[0]); } else if(type == MPU_9250_SENSOR_TYPE_GYRO_Y) { converted_val = gyro_convert(sensor_value[1]); } else if(type == MPU_9250_SENSOR_TYPE_GYRO_Z) { converted_val = gyro_convert(sensor_value[2]); } rv = (int)(converted_val * 100); } else { PRINTF("MPU: Invalid type\n"); rv = CC26XX_SENSOR_READING_ERROR; } PRINTF("%ld\n", (long int)(converted_val * 100)); return rv; }
/*---------------------------------------------------------------------------*/ static void powercycle_turn_radio_off(void) { #if CONTIKIMAC_CONF_COMPOWER uint8_t was_on = radio_is_on; #endif /* CONTIKIMAC_CONF_COMPOWER */ #if RDC_CONF_HARDWARE_SEND_ACK if(we_are_sending == 0 && we_are_receiving_burst == 0) { #else if(we_are_sending == 0 && we_are_receiving_burst == 0 && we_are_acking == 0) { #endif off(); #if CONTIKIMAC_CONF_COMPOWER if(was_on && !radio_is_on) { compower_accumulate(&compower_idle_activity); } #endif /* CONTIKIMAC_CONF_COMPOWER */ } } /*---------------------------------------------------------------------------*/ static void powercycle_turn_radio_on(void) { #if RDC_CONF_HARDWARE_SEND_ACK if(we_are_sending == 0 && we_are_receiving_burst == 0) { #else if(we_are_sending == 0 && we_are_receiving_burst == 0 && we_are_acking == 0) { #endif on(); } } /*---------------------------------------------------------------------------*/ static char powercycle(struct rtimer *t, void *ptr) { #if SYNC_CYCLE_STARTS static volatile rtimer_clock_t sync_cycle_start; static volatile uint8_t sync_cycle_phase; #endif PT_BEGIN(&pt); #if SYNC_CYCLE_STARTS sync_cycle_start = RTIMER_NOW(); #else cycle_start = RTIMER_NOW(); #endif while(1) { static uint8_t packet_seen; static rtimer_clock_t t0; static uint8_t count; #if SYNC_CYCLE_STARTS /* Compute cycle start when RTIMER_ARCH_SECOND is not a multiple of CHANNEL_CHECK_RATE */ if(sync_cycle_phase++ == NETSTACK_RDC_CHANNEL_CHECK_RATE) { sync_cycle_phase = 0; sync_cycle_start += RTIMER_ARCH_SECOND; cycle_start = sync_cycle_start; } else { #if (RTIMER_ARCH_SECOND * NETSTACK_RDC_CHANNEL_CHECK_RATE) > 65535 cycle_start = sync_cycle_start + ((unsigned long)(sync_cycle_phase*RTIMER_ARCH_SECOND))/NETSTACK_RDC_CHANNEL_CHECK_RATE; #else cycle_start = sync_cycle_start + (sync_cycle_phase*RTIMER_ARCH_SECOND)/NETSTACK_RDC_CHANNEL_CHECK_RATE; #endif } #else cycle_start += CYCLE_TIME; #endif packet_seen = 0; for(count = 0; count < CCA_COUNT_MAX; ++count) { t0 = RTIMER_NOW(); if(we_are_sending == 0 && we_are_receiving_burst == 0) { powercycle_turn_radio_on(); /* Check if a packet is seen in the air. If so, we keep the radio on for a while (LISTEN_TIME_AFTER_PACKET_DETECTED) to be able to receive the packet. We also continuously check the radio medium to make sure that we wasn't woken up by a false positive: a spurious radio interference that was not caused by an incoming packet. */ if(NETSTACK_RADIO.channel_clear() == 0) { packet_seen = 1; break; } powercycle_turn_radio_off(); } schedule_powercycle_fixed(t, RTIMER_NOW() + CCA_SLEEP_TIME); PT_YIELD(&pt); } if(packet_seen) { static rtimer_clock_t start; static uint8_t silence_periods, periods; start = RTIMER_NOW(); periods = silence_periods = 0; while(we_are_sending == 0 && radio_is_on && RTIMER_CLOCK_LT(RTIMER_NOW(), (start + LISTEN_TIME_AFTER_PACKET_DETECTED))) { /* Check for a number of consecutive periods of non-activity. If we see two such periods, we turn the radio off. Also, if a packet has been successfully received (as indicated by the NETSTACK_RADIO.pending_packet() function), we stop snooping. */ #if !RDC_CONF_HARDWARE_CSMA /* A cca cycle will disrupt rx on some radios, e.g. mc1322x, rf230 */ /*TODO: Modify those drivers to just return the internal RSSI when already in rx mode */ if(NETSTACK_RADIO.channel_clear()) { ++silence_periods; } else { silence_periods = 0; } #endif ++periods; if(NETSTACK_RADIO.receiving_packet()) { silence_periods = 0; } if(silence_periods > MAX_SILENCE_PERIODS) { powercycle_turn_radio_off(); break; } if(WITH_FAST_SLEEP && periods > MAX_NONACTIVITY_PERIODS && !(NETSTACK_RADIO.receiving_packet() || NETSTACK_RADIO.pending_packet())) { powercycle_turn_radio_off(); break; } if(NETSTACK_RADIO.pending_packet()) { break; } schedule_powercycle(t, CCA_CHECK_TIME + CCA_SLEEP_TIME); PT_YIELD(&pt); } if(radio_is_on) { if(!(NETSTACK_RADIO.receiving_packet() || NETSTACK_RADIO.pending_packet()) || !RTIMER_CLOCK_LT(RTIMER_NOW(), (start + LISTEN_TIME_AFTER_PACKET_DETECTED))) { powercycle_turn_radio_off(); } } } if(RTIMER_CLOCK_LT(RTIMER_NOW() - cycle_start, CYCLE_TIME - CHECK_TIME * 4)) { /* Schedule the next powercycle interrupt, or sleep the mcu until then. Sleeping will not exit from this interrupt, so ensure an occasional wake cycle or foreground processing will be blocked until a packet is detected */ #if RDC_CONF_MCU_SLEEP static uint8_t sleepcycle; if((sleepcycle++ < 16) && !we_are_sending && !radio_is_on) { rtimer_arch_sleep(CYCLE_TIME - (RTIMER_NOW() - cycle_start)); } else { sleepcycle = 0; schedule_powercycle_fixed(t, CYCLE_TIME + cycle_start); PT_YIELD(&pt); } #else schedule_powercycle_fixed(t, CYCLE_TIME + cycle_start); PT_YIELD(&pt); #endif } } PT_END(&pt); } /*---------------------------------------------------------------------------*/ static int broadcast_rate_drop(void) { #if CONTIKIMAC_CONF_BROADCAST_RATE_LIMIT if(!timer_expired(&broadcast_rate_timer)) { broadcast_rate_counter++; if(broadcast_rate_counter < CONTIKIMAC_CONF_BROADCAST_RATE_LIMIT) { return 0; } else { return 1; } } else { timer_set(&broadcast_rate_timer, CLOCK_SECOND); broadcast_rate_counter = 0; return 0; } #else /* CONTIKIMAC_CONF_BROADCAST_RATE_LIMIT */ return 0; #endif /* CONTIKIMAC_CONF_BROADCAST_RATE_LIMIT */ } /*---------------------------------------------------------------------------*/ static int send_packet(mac_callback_t mac_callback, void *mac_callback_ptr, struct rdc_buf_list *buf_list, int is_receiver_awake) { rtimer_clock_t t0; rtimer_clock_t encounter_time = 0; int strobes; uint8_t got_strobe_ack = 0; int hdrlen, len; uint8_t is_broadcast = 0; uint8_t is_reliable = 0; uint8_t is_known_receiver = 0; uint8_t collisions; int transmit_len; int ret; uint8_t contikimac_was_on; uint8_t seqno; #if WITH_CONTIKIMAC_HEADER struct hdr *chdr; #endif /* WITH_CONTIKIMAC_HEADER */ /* Exit if RDC and radio were explicitly turned off */ if(!contikimac_is_on && !contikimac_keep_radio_on) { PRINTF("contikimac: radio is turned off\n"); return MAC_TX_ERR_FATAL; } if(packetbuf_totlen() == 0) { PRINTF("contikimac: send_packet data len 0\n"); return MAC_TX_ERR_FATAL; } #if !NETSTACK_CONF_BRIDGE_MODE /* If NETSTACK_CONF_BRIDGE_MODE is set, assume PACKETBUF_ADDR_SENDER is already set. */ packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &rimeaddr_node_addr); #endif if(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), &rimeaddr_null)) { is_broadcast = 1; PRINTDEBUG("contikimac: send broadcast\n"); if(broadcast_rate_drop()) { return MAC_TX_COLLISION; } } else { #if UIP_CONF_IPV6 PRINTDEBUG("contikimac: send unicast to %02x%02x:%02x%02x:%02x%02x:%02x%02x\n", packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[1], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[2], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[3], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[4], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[5], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[6], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[7]); #else /* UIP_CONF_IPV6 */ PRINTDEBUG("contikimac: send unicast to %u.%u\n", packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[1]); #endif /* UIP_CONF_IPV6 */ } is_reliable = packetbuf_attr(PACKETBUF_ATTR_RELIABLE) || packetbuf_attr(PACKETBUF_ATTR_ERELIABLE); packetbuf_set_attr(PACKETBUF_ATTR_MAC_ACK, 1); #if WITH_CONTIKIMAC_HEADER hdrlen = packetbuf_totlen(); if(packetbuf_hdralloc(sizeof(struct hdr)) == 0) { /* Failed to allocate space for contikimac header */ PRINTF("contikimac: send failed, too large header\n"); return MAC_TX_ERR_FATAL; } chdr = packetbuf_hdrptr(); chdr->id = CONTIKIMAC_ID; chdr->len = hdrlen; /* Create the MAC header for the data packet. */ hdrlen = NETSTACK_FRAMER.create(); if(hdrlen < 0) { /* Failed to send */ PRINTF("contikimac: send failed, too large header\n"); packetbuf_hdr_remove(sizeof(struct hdr)); return MAC_TX_ERR_FATAL; } hdrlen += sizeof(struct hdr); #else /* Create the MAC header for the data packet. */ hdrlen = NETSTACK_FRAMER.create(); if(hdrlen < 0) { /* Failed to send */ PRINTF("contikimac: send failed, too large header\n"); return MAC_TX_ERR_FATAL; } #endif /* Make sure that the packet is longer or equal to the shortest packet length. */ transmit_len = packetbuf_totlen(); if(transmit_len < SHORTEST_PACKET_SIZE) { /* Pad with zeroes */ uint8_t *ptr; ptr = packetbuf_dataptr(); memset(ptr + packetbuf_datalen(), 0, SHORTEST_PACKET_SIZE - packetbuf_totlen()); PRINTF("contikimac: shorter than shortest (%d)\n", packetbuf_totlen()); transmit_len = SHORTEST_PACKET_SIZE; } packetbuf_compact(); #ifdef NETSTACK_ENCRYPT NETSTACK_ENCRYPT(); #endif /* NETSTACK_ENCRYPT */ transmit_len = packetbuf_totlen(); NETSTACK_RADIO.prepare(packetbuf_hdrptr(), transmit_len); /* Remove the MAC-layer header since it will be recreated next time around. */ packetbuf_hdr_remove(hdrlen); if(!is_broadcast && !is_receiver_awake) { #if WITH_PHASE_OPTIMIZATION ret = phase_wait(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), CYCLE_TIME, GUARD_TIME, mac_callback, mac_callback_ptr, buf_list); if(ret == PHASE_DEFERRED) { return MAC_TX_DEFERRED; } if(ret != PHASE_UNKNOWN) { is_known_receiver = 1; } #endif /* WITH_PHASE_OPTIMIZATION */ } /* By setting we_are_sending to one, we ensure that the rtimer powercycle interrupt do not interfere with us sending the packet. */ we_are_sending = 1; /* If we have a pending packet in the radio, we should not send now, because we will trash the received packet. Instead, we signal that we have a collision, which lets the packet be received. This packet will be retransmitted later by the MAC protocol instread. */ if(NETSTACK_RADIO.receiving_packet() || NETSTACK_RADIO.pending_packet()) { we_are_sending = 0; PRINTF("contikimac: collision receiving %d, pending %d\n", NETSTACK_RADIO.receiving_packet(), NETSTACK_RADIO.pending_packet()); return MAC_TX_COLLISION; } /* Switch off the radio to ensure that we didn't start sending while the radio was doing a channel check. */ off(); strobes = 0; /* Send a train of strobes until the receiver answers with an ACK. */ collisions = 0; got_strobe_ack = 0; /* Set contikimac_is_on to one to allow the on() and off() functions to control the radio. We restore the old value of contikimac_is_on when we are done. */ contikimac_was_on = contikimac_is_on; contikimac_is_on = 1; #if !RDC_CONF_HARDWARE_CSMA /* Check if there are any transmissions by others. */ /* TODO: why does this give collisions before sending with the mc1322x? */ if(is_receiver_awake == 0) { int i; for(i = 0; i < CCA_COUNT_MAX_TX; ++i) { t0 = RTIMER_NOW(); on(); #if CCA_CHECK_TIME > 0 while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + CCA_CHECK_TIME)) { } #endif if(NETSTACK_RADIO.channel_clear() == 0) { collisions++; off(); break; } off(); t0 = RTIMER_NOW(); while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + CCA_SLEEP_TIME)) { } } } if(collisions > 0) { we_are_sending = 0; off(); PRINTF("contikimac: collisions before sending\n"); contikimac_is_on = contikimac_was_on; return MAC_TX_COLLISION; } #endif /* RDC_CONF_HARDWARE_CSMA */ #if !RDC_CONF_HARDWARE_ACK if(!is_broadcast) { /* Turn radio on to receive expected unicast ack. Not necessary with hardware ack detection, and may trigger an unnecessary cca or rx cycle */ on(); } #endif watchdog_periodic(); t0 = RTIMER_NOW(); seqno = packetbuf_attr(PACKETBUF_ATTR_MAC_SEQNO); for(strobes = 0, collisions = 0; got_strobe_ack == 0 && collisions == 0 && RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + STROBE_TIME); strobes++) { watchdog_periodic(); if(!is_broadcast && (is_receiver_awake || is_known_receiver) && !RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + MAX_PHASE_STROBE_TIME)) { PRINTF("miss to %d\n", packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0]); break; } len = 0; { rtimer_clock_t wt; rtimer_clock_t txtime; int ret; txtime = RTIMER_NOW(); ret = NETSTACK_RADIO.transmit(transmit_len); #if RDC_CONF_HARDWARE_ACK /* For radios that block in the transmit routine and detect the ACK in hardware */ if(ret == RADIO_TX_OK) { if(!is_broadcast) { got_strobe_ack = 1; encounter_time = txtime; break; } } else if (ret == RADIO_TX_NOACK) { } else if (ret == RADIO_TX_COLLISION) { PRINTF("contikimac: collisions while sending\n"); collisions++; } wt = RTIMER_NOW(); while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + INTER_PACKET_INTERVAL)) { } #else /* RDC_CONF_HARDWARE_ACK */ /* Wait for the ACK packet */ wt = RTIMER_NOW(); while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + INTER_PACKET_INTERVAL)) { } if(!is_broadcast && (NETSTACK_RADIO.receiving_packet() || NETSTACK_RADIO.pending_packet() || NETSTACK_RADIO.channel_clear() == 0)) { uint8_t ackbuf[ACK_LEN]; wt = RTIMER_NOW(); while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + AFTER_ACK_DETECTECT_WAIT_TIME)) { } len = NETSTACK_RADIO.read(ackbuf, ACK_LEN); //PRINTF("%u %u vs %u", len, ackbuf[ACK_LEN - 1], seqno); if(len == ACK_LEN && seqno == ackbuf[ACK_LEN - 1]) { got_strobe_ack = 1; encounter_time = txtime; break; } else { PRINTF("contikimac: collisions while sending\n"); collisions++; } } #endif /* RDC_CONF_HARDWARE_ACK */ } } off(); PRINTF("contikimac: send (strobes=%u, len=%u, %s, %s), done\n", strobes, packetbuf_totlen(), got_strobe_ack ? "ack" : "no ack", collisions ? "collision" : "no collision"); #if CONTIKIMAC_CONF_COMPOWER /* Accumulate the power consumption for the packet transmission. */ compower_accumulate(¤t_packet); /* Convert the accumulated power consumption for the transmitted packet to packet attributes so that the higher levels can keep track of the amount of energy spent on transmitting the packet. */ compower_attrconv(¤t_packet); /* Clear the accumulated power consumption so that it is ready for the next packet. */ compower_clear(¤t_packet); #endif /* CONTIKIMAC_CONF_COMPOWER */ contikimac_is_on = contikimac_was_on; we_are_sending = 0; /* Determine the return value that we will return from the function. We must pass this value to the phase module before we return from the function. */ if(collisions > 0) { ret = MAC_TX_COLLISION; } else if(!is_broadcast && !got_strobe_ack) { ret = MAC_TX_NOACK; } else { ret = MAC_TX_OK; } #if WITH_PHASE_OPTIMIZATION if(is_known_receiver && got_strobe_ack) { PRINTF("no miss %d wake-ups %d\n", packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0], strobes); } if(!is_broadcast) { if(collisions == 0 && is_receiver_awake == 0) { phase_update(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), encounter_time, ret); } } #endif /* WITH_PHASE_OPTIMIZATION */ return ret; } /*---------------------------------------------------------------------------*/ static void qsend_packet(mac_callback_t sent, void *ptr) { int ret = send_packet(sent, ptr, NULL, 0); if(ret != MAC_TX_DEFERRED) { mac_call_sent_callback(sent, ptr, ret, 1); } }
/*---------------------------------------------------------------------------*/ static int send_one_packet(struct net_buf *buf, mac_callback_t sent, void *ptr) { int ret; int last_sent_ok = 0; #if NULLRDC_ENABLE_RETRANSMISSIONS rtimer_clock_t target_time; uint8_t tx_attempts = 0; uint8_t max_tx_attempts; if(packetbuf_attr(PACKETBUF_ATTR_MAX_MAC_TRANSMISSIONS) > 0) { max_tx_attempts = packetbuf_attr(PACKETBUF_ATTR_MAX_MAC_TRANSMISSIONS); } else { max_tx_attempts = NULLRDC_MAX_RETRANSMISSIONS + 1; } #endif /* NULLRDC_ENABLE_RETRANSMISSIONS */ packetbuf_set_addr(buf, PACKETBUF_ADDR_SENDER, &linkaddr_node_addr); #if NULLRDC_802154_AUTOACK || NULLRDC_802154_AUTOACK_HW packetbuf_set_attr(buf, PACKETBUF_ATTR_MAC_ACK, 1); #endif /* NULLRDC_802154_AUTOACK || NULLRDC_802154_AUTOACK_HW */ if(NETSTACK_FRAMER.create_and_secure(buf) < 0) { /* Failed to allocate space for headers */ PRINTF("nullrdc: send failed, too large header\n"); ret = MAC_TX_ERR_FATAL; } else { #if NULLRDC_802154_AUTOACK int is_broadcast; uint8_t dsn; dsn = ((uint8_t *)packetbuf_hdrptr())[2] & 0xff; NETSTACK_RADIO.prepare(packetbuf_hdrptr(), packetbuf_totlen()); is_broadcast = packetbuf_holds_broadcast(); if(NETSTACK_RADIO.receiving_packet() || (!is_broadcast && NETSTACK_RADIO.pending_packet())) { /* Currently receiving a packet over air or the radio has already received a packet that needs to be read before sending with auto ack. */ ret = MAC_TX_COLLISION; } else { if(!is_broadcast) { RIMESTATS_ADD(reliabletx); } #if NULLRDC_ENABLE_RETRANSMISSIONS while(1) { /* Transmit packet and check status */ tx_attempts++; #endif /* NULLRDC_ENABLE_RETRANSMISSIONS */ switch(NETSTACK_RADIO.transmit(packetbuf_totlen(buf))) { case RADIO_TX_OK: if(is_broadcast) { ret = MAC_TX_OK; } else { rtimer_clock_t wt; /* Check for ack */ wt = RTIMER_NOW(); watchdog_periodic(); while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + ACK_WAIT_TIME)) { #if CONTIKI_TARGET_COOJA simProcessRunValue = 1; cooja_mt_yield(); #endif /* CONTIKI_TARGET_COOJA */ } ret = MAC_TX_NOACK; if(NETSTACK_RADIO.receiving_packet() || NETSTACK_RADIO.pending_packet() || NETSTACK_RADIO.channel_clear() == 0) { int len; uint8_t ackbuf[ACK_LEN]; if(AFTER_ACK_DETECTED_WAIT_TIME > 0) { wt = RTIMER_NOW(); watchdog_periodic(); while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + AFTER_ACK_DETECTED_WAIT_TIME)) { #if CONTIKI_TARGET_COOJA simProcessRunValue = 1; cooja_mt_yield(); #endif /* CONTIKI_TARGET_COOJA */ } } if(NETSTACK_RADIO.pending_packet()) { len = NETSTACK_RADIO.read(ackbuf, ACK_LEN); if(len == ACK_LEN && ackbuf[2] == dsn) { /* Ack received */ RIMESTATS_ADD(ackrx); ret = MAC_TX_OK; } else { /* Not an ack or ack not for us: collision */ ret = MAC_TX_COLLISION; } } } else { PRINTF("nullrdc tx noack\n"); } } break; case RADIO_TX_COLLISION: ret = MAC_TX_COLLISION; break; default: ret = MAC_TX_ERR; break; } #if NULLRDC_ENABLE_RETRANSMISSIONS if(is_broadcast) { #if !NULLRDC_ENABLE_RETRANSMISSIONS_BCAST break; #else /* NULLRDC_ENABLE_RETRANSMISSIONS_BCAST */ if(ret != MAC_TX_COLLISION) { /* Retry broadcast frame only upon collision */ break; } #endif /* NULLRDC_ENABLE_RETRANSMISSIONS_BCAST */ } else { /* Frame is unicast. Do not retry unless NO_ACK or COLLISION */ if((ret != MAC_TX_NOACK) && (ret != MAC_TX_COLLISION)) { break; } } /* Do not retry if max attempts reached. */ if(tx_attempts >= max_tx_attempts) { PRINTF("nullrdc: max tx attempts reached\n"); break; } /* Block-wait before retrying the frame. */ target_time = RTIMER_NOW() + (RTIMER_SECOND * NULLRDC_TX_RETRY_DELAY_MS / 1000); watchdog_periodic(); while(RTIMER_CLOCK_LT(RTIMER_NOW(), target_time)) { /* Wait */ } /* Attempt a new frame (re)transmission */ } #endif /* NULLRDC_ENABLE_RETRANSMISSIONS */ } #else /* ! NULLRDC_802154_AUTOACK */ switch(NETSTACK_RADIO.send(buf, packetbuf_hdrptr(buf), packetbuf_totlen(buf))) { case RADIO_TX_OK: ret = MAC_TX_OK; break; case RADIO_TX_COLLISION: ret = MAC_TX_COLLISION; break; case RADIO_TX_NOACK: ret = MAC_TX_NOACK; break; default: ret = MAC_TX_ERR; break; } #endif /* ! NULLRDC_802154_AUTOACK */ } if(ret == MAC_TX_OK) { last_sent_ok = 1; } #if ! NULLRDC_ENABLE_RETRANSMISSIONS mac_call_sent_callback(buf, sent, ptr, ret, 1); #else mac_call_sent_callback(buf, sent, ptr, ret, tx_attempts); #endif /* !NULLRDC_ENABLE_RETRANSMISSIONS */ return last_sent_ok; }
/*---------------------------------------------------------------------------*/ static int transmit(unsigned short transmit_len) { uint8_t counter; int ret = RADIO_TX_ERR; rtimer_clock_t t0; transmit_len; /* hush the warning */ if(!(rf_flags & RX_ACTIVE)) { t0 = RTIMER_NOW(); on(); rf_flags |= WAS_OFF; while (RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + ONOFF_TIME)); } if(channel_clear() == CC2530_RF_CCA_BUSY) { RIMESTATS_ADD(contentiondrop); return RADIO_TX_COLLISION; } /* * prepare() double checked that TX_ACTIVE is low. If SFD is high we are * receiving. Abort transmission and bail out with RADIO_TX_COLLISION */ if(FSMSTAT1 & FSMSTAT1_SFD) { RIMESTATS_ADD(contentiondrop); return RADIO_TX_COLLISION; } /* Start the transmission */ RF_TX_LED_ON(); ENERGEST_OFF(ENERGEST_TYPE_LISTEN); ENERGEST_ON(ENERGEST_TYPE_TRANSMIT); CC2530_CSP_ISTXON(); counter = 0; while(!(FSMSTAT1 & FSMSTAT1_TX_ACTIVE) && (counter++ < 3)) { clock_delay_usec(6); } if(!(FSMSTAT1 & FSMSTAT1_TX_ACTIVE)) { PUTSTRING("RF: TX never active.\n"); CC2530_CSP_ISFLUSHTX(); ret = RADIO_TX_ERR; } else { /* Wait for the transmission to finish */ while(FSMSTAT1 & FSMSTAT1_TX_ACTIVE); ret = RADIO_TX_OK; } ENERGEST_OFF(ENERGEST_TYPE_TRANSMIT); ENERGEST_ON(ENERGEST_TYPE_LISTEN); if(rf_flags & WAS_OFF){ off(); } RIMESTATS_ADD(lltx); RF_TX_LED_OFF(); /* OK, sent. We are now ready to send more */ return ret; }
/*---------------------------------------------------------------------------*/ static int send_packet(void) { rtimer_clock_t t0; rtimer_clock_t t; rtimer_clock_t encounter_time = 0; int strobes; int ret; #if 0 struct xmac_hdr *hdr; #endif uint8_t got_strobe_ack = 0; uint8_t got_ack = 0; uint8_t strobe[MAX_STROBE_SIZE]; int strobe_len, len; int is_broadcast = 0; /*int is_reliable; */ struct encounter *e; struct queuebuf *packet; int is_already_streaming = 0; uint8_t collisions; /* Create the X-MAC header for the data packet. */ packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &rimeaddr_node_addr); if(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), &rimeaddr_null)) { is_broadcast = 1; PRINTDEBUG("xmac: send broadcast\n"); } else { #if UIP_CONF_IPV6 PRINTDEBUG("xmac: send unicast to %02x%02x:%02x%02x:%02x%02x:%02x%02x\n", packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[1], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[2], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[3], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[4], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[5], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[6], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[7]); #else PRINTDEBUG("xmac: send unicast to %u.%u\n", packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[1]); #endif /* UIP_CONF_IPV6 */ } /* is_reliable = packetbuf_attr(PACKETBUF_ATTR_RELIABLE) || packetbuf_attr(PACKETBUF_ATTR_ERELIABLE); */ packetbuf_set_attr(PACKETBUF_ATTR_MAC_ACK, 1); len = NETSTACK_FRAMER.create(); strobe_len = len + sizeof(struct xmac_hdr); if(len < 0 || strobe_len > (int)sizeof(strobe)) { /* Failed to send */ PRINTF("xmac: send failed, too large header\n"); return MAC_TX_ERR_FATAL; } memcpy(strobe, packetbuf_hdrptr(), len); strobe[len] = DISPATCH; /* dispatch */ strobe[len + 1] = TYPE_STROBE; /* type */ packetbuf_compact(); packet = queuebuf_new_from_packetbuf(); if(packet == NULL) { /* No buffer available */ PRINTF("xmac: send failed, no queue buffer available (of %u)\n", QUEUEBUF_CONF_NUM); return MAC_TX_ERR; } #if WITH_STREAMING if(is_streaming == 1 && (rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), &is_streaming_to) || rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), &is_streaming_to_too))) { is_already_streaming = 1; } if(packetbuf_attr(PACKETBUF_ATTR_PACKET_TYPE) == PACKETBUF_ATTR_PACKET_TYPE_STREAM) { is_streaming = 1; if(rimeaddr_cmp(&is_streaming_to, &rimeaddr_null)) { rimeaddr_copy(&is_streaming_to, packetbuf_addr(PACKETBUF_ADDR_RECEIVER)); } else if(!rimeaddr_cmp(&is_streaming_to, packetbuf_addr(PACKETBUF_ADDR_RECEIVER))) { rimeaddr_copy(&is_streaming_to_too, packetbuf_addr(PACKETBUF_ADDR_RECEIVER)); } stream_until = RTIMER_NOW() + DEFAULT_STREAM_TIME; } #endif /* WITH_STREAMING */ off(); #if WITH_ENCOUNTER_OPTIMIZATION /* We go through the list of encounters to find if we have recorded an encounter with this particular neighbor. If so, we can compute the time for the next expected encounter and setup a ctimer to switch on the radio just before the encounter. */ for(e = list_head(encounter_list); e != NULL; e = list_item_next(e)) { const rimeaddr_t *neighbor = packetbuf_addr(PACKETBUF_ADDR_RECEIVER); if(rimeaddr_cmp(neighbor, &e->neighbor)) { rtimer_clock_t wait, now, expected; /* We expect encounters to happen every DEFAULT_PERIOD time units. The next expected encounter is at time e->time + DEFAULT_PERIOD. To compute a relative offset, we subtract with clock_time(). Because we are only interested in turning on the radio within the DEFAULT_PERIOD period, we compute the waiting time with modulo DEFAULT_PERIOD. */ now = RTIMER_NOW(); wait = ((rtimer_clock_t)(e->time - now)) % (DEFAULT_PERIOD); if(wait < 2 * DEFAULT_ON_TIME) { wait = DEFAULT_PERIOD; } expected = now + wait - 2 * DEFAULT_ON_TIME; #if WITH_ACK_OPTIMIZATION /* Wait until the receiver is expected to be awake */ if(packetbuf_attr(PACKETBUF_ATTR_PACKET_TYPE) != PACKETBUF_ATTR_PACKET_TYPE_ACK && is_streaming == 0) { /* Do not wait if we are sending an ACK, because then the receiver will already be awake. */ while(RTIMER_CLOCK_LT(RTIMER_NOW(), expected)); } #else /* WITH_ACK_OPTIMIZATION */ /* Wait until the receiver is expected to be awake */ while(RTIMER_CLOCK_LT(RTIMER_NOW(), expected)); #endif /* WITH_ACK_OPTIMIZATION */ } } #endif /* WITH_ENCOUNTER_OPTIMIZATION */ /* By setting we_are_sending to one, we ensure that the rtimer powercycle interrupt do not interfere with us sending the packet. */ we_are_sending = 1; t0 = RTIMER_NOW(); strobes = 0; LEDS_ON(LEDS_BLUE); /* Send a train of strobes until the receiver answers with an ACK. */ /* Turn on the radio to listen for the strobe ACK. */ // on(); collisions = 0; if(!is_already_streaming) { watchdog_stop(); got_strobe_ack = 0; t = RTIMER_NOW(); for(strobes = 0, collisions = 0; got_strobe_ack == 0 && collisions == 0 && RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + xmac_config.strobe_time); strobes++) { while(got_strobe_ack == 0 && RTIMER_CLOCK_LT(RTIMER_NOW(), t + xmac_config.strobe_wait_time)) { #if 0 rtimer_clock_t now = RTIMER_NOW(); /* See if we got an ACK */ packetbuf_clear(); len = NETSTACK_RADIO.read(packetbuf_dataptr(), PACKETBUF_SIZE); if(len > 0) { packetbuf_set_datalen(len); if(NETSTACK_FRAMER.parse() >= 0) { hdr = packetbuf_dataptr(); if(hdr->dispatch == DISPATCH && hdr->type == TYPE_STROBE_ACK) { if(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), &rimeaddr_node_addr)) { /* We got an ACK from the receiver, so we can immediately send the packet. */ got_strobe_ack = 1; encounter_time = now; } else { PRINTDEBUG("xmac: strobe ack for someone else\n"); } } else /*if(hdr->dispatch == DISPATCH && hdr->type == TYPE_STROBE)*/ { PRINTDEBUG("xmac: strobe from someone else\n"); collisions++; } } else { PRINTF("xmac: send failed to parse %u\n", len); } } #endif /* 0 */ } t = RTIMER_NOW(); /* Send the strobe packet. */ if(got_strobe_ack == 0 && collisions == 0) { if(is_broadcast) { #if WITH_STROBE_BROADCAST ret = NETSTACK_RADIO.send(strobe, strobe_len); #else /* restore the packet to send */ queuebuf_to_packetbuf(packet); ret = NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen()); #endif off(); } else { #if 0 rtimer_clock_t wt; #endif on(); ret = NETSTACK_RADIO.send(strobe, strobe_len); #if 0 /* Turn off the radio for a while to let the other side respond. We don't need to keep our radio on when we know that the other side needs some time to produce a reply. */ off(); wt = RTIMER_NOW(); while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + WAIT_TIME_BEFORE_STROBE_ACK)); #endif /* 0 */ #if RDC_CONF_HARDWARE_ACK if(ret == RADIO_TX_OK) { got_strobe_ack = 1; } else { off(); } #else if(detect_ack()) { got_strobe_ack = 1; } else { off(); } #endif /* RDC_CONF_HARDWARE_ACK */ } } } } #if WITH_ACK_OPTIMIZATION /* If we have received the strobe ACK, and we are sending a packet that will need an upper layer ACK (as signified by the PACKETBUF_ATTR_RELIABLE packet attribute), we keep the radio on. */ if(got_strobe_ack && (packetbuf_attr(PACKETBUF_ATTR_RELIABLE) || packetbuf_attr(PACKETBUF_ATTR_ERELIABLE) || packetbuf_attr(PACKETBUF_ATTR_PACKET_TYPE) == PACKETBUF_ATTR_PACKET_TYPE_STREAM)) { on(); /* Wait for ACK packet */ waiting_for_packet = 1; } else { off(); } #endif /* WITH_ACK_OPTIMIZATION */ /* restore the packet to send */ queuebuf_to_packetbuf(packet); queuebuf_free(packet); /* Send the data packet. */ if((is_broadcast || got_strobe_ack || is_streaming) && collisions == 0) { ret = NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen()); if(!is_broadcast) { #if RDC_CONF_HARDWARE_ACK if(ret == RADIO_TX_OK) { got_ack = 1; } #else if(detect_ack()) { got_ack = 1; } #endif /* RDC_CONF_HARDWARE_ACK */ } } off(); #if WITH_ENCOUNTER_OPTIMIZATION if(got_strobe_ack && !is_streaming) { register_encounter(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), encounter_time); } #endif /* WITH_ENCOUNTER_OPTIMIZATION */ watchdog_start(); PRINTF("xmac: send (strobes=%u,len=%u,%s), done\n", strobes, packetbuf_totlen(), got_strobe_ack ? "ack" : "no ack"); #if XMAC_CONF_COMPOWER /* Accumulate the power consumption for the packet transmission. */ compower_accumulate(¤t_packet); /* Convert the accumulated power consumption for the transmitted packet to packet attributes so that the higher levels can keep track of the amount of energy spent on transmitting the packet. */ compower_attrconv(¤t_packet); /* Clear the accumulated power consumption so that it is ready for the next packet. */ compower_clear(¤t_packet); #endif /* XMAC_CONF_COMPOWER */ we_are_sending = 0; LEDS_OFF(LEDS_BLUE); if(collisions == 0) { if(is_broadcast == 0 && got_ack == 0) { return MAC_TX_NOACK; } else { return MAC_TX_OK; } } else { someone_is_sending++; return MAC_TX_COLLISION; } }
/*---------------------------------------------------------------------------*/ static PT_THREAD(ajax_call(struct httpd_state *s, char *ptr)) { static struct timer t; static int iter; static char buf[128]; static uint8_t numprinted; PSOCK_BEGIN(&s->sout); /*TODO:pick up time from ? parameter */ timer_set(&t, 2*CLOCK_SECOND); iter = 0; while(1) { iter++; #if CONTIKI_TARGET_SKY SENSORS_ACTIVATE(sht11_sensor); SENSORS_ACTIVATE(light_sensor); numprinted = snprintf(buf, sizeof(buf), "t(%d);h(%d);l1(%d);l2(%d);", sht11_sensor.value(SHT11_SENSOR_TEMP), sht11_sensor.value(SHT11_SENSOR_HUMIDITY), light_sensor.value(LIGHT_SENSOR_PHOTOSYNTHETIC), light_sensor.value(LIGHT_SENSOR_TOTAL_SOLAR)); SENSORS_DEACTIVATE(sht11_sensor); SENSORS_DEACTIVATE(light_sensor); #elif CONTIKI_TARGET_MB851 SENSORS_ACTIVATE(acc_sensor); numprinted = snprintf(buf, sizeof(buf),"t(%d);ax(%d);ay(%d);az(%d);", temperature_sensor.value(0), acc_sensor.value(ACC_X_AXIS), acc_sensor.value(ACC_Y_AXIS), acc_sensor.value(ACC_Z_AXIS)); SENSORS_DEACTIVATE(acc_sensor); #elif CONTIKI_TARGET_REDBEE_ECONOTAG { uint8_t c; adc_reading[8]=0; adc_init(); while (adc_reading[8]==0) adc_service(); adc_disable(); numprinted = snprintf(buf, sizeof(buf),"b(%u);adc(%u,%u,%u,%u,%u,%u,%u,%u);", 1200*0xfff/adc_reading[8],adc_reading[0],adc_reading[1],adc_reading[2],adc_reading[3],adc_reading[4],adc_reading[5],adc_reading[6],adc_reading[7]); } #elif CONTIKI_TARGET_MINIMAL_NET static uint16_t c0=0x3ff,c1=0x3ff,c2=0x3ff,c3=0x3ff,c4=0x3ff,c5=0x3ff,c6=0x3ff,c7=0x3ff; numprinted = snprintf(buf, sizeof(buf), "t(%d);b(%u);v(%u);",273+(rand()&0x3f),3300-iter/10,iter); numprinted += snprintf(buf+numprinted, sizeof(buf)-numprinted,"adc(%u,%u,%u,%u,%u,%u,%u,%u);",c0,c1,c2,c3,c4,c5,c6,c7); c0+=(rand()&0xf)-8; c1+=(rand()&0xf)-8; c2+=(rand()&0xf)-7; c3+=(rand()&0x1f)-15; c4+=(rand()&0x3)-1; c5+=(rand()&0xf)-8; c6+=(rand()&0xf)-8; c7+=(rand()&0xf)-8; if (iter==1) { static const char httpd_cgi_ajax11[] HTTPD_STRING_ATTR = "wt('Minimal-net "; static const char httpd_cgi_ajax12[] HTTPD_STRING_ATTR = "');"; numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax11); #if WEBSERVER_CONF_PRINTADDR /* Note address table is filled from the end down */ {int i; for (i=0; i<UIP_DS6_ADDR_NB;i++) { if (uip_ds6_if.addr_list[i].isused) { numprinted += httpd_cgi_sprint_ip6(uip_ds6_if.addr_list[i].ipaddr, buf + numprinted); break; } } } #endif numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax12); } #elif CONTIKI_TARGET_AVR_ATMEGA128RFA1 { uint8_t i;int16_t tmp,bat; BATMON = 16; //give BATMON time to stabilize at highest range and lowest voltage /* Measure internal temperature sensor, see atmega128rfa1 datasheet */ /* This code disabled by default for safety. Selecting an internal reference will short it to anything connected to the AREF pin */ #if 1 ADCSRB|=1<<MUX5; //this bit buffered till ADMUX written to! ADMUX =0xc9; // Select internal 1.6 volt ref, temperature sensor ADC channel ADCSRA=0x85; //Enable ADC, not free running, interrupt disabled, clock divider 32 (250 KHz@ 8 MHz) // while ((ADCSRB&(1<<AVDDOK))==0); //wait for AVDD ok // while ((ADCSRB&(1<<REFOK))==0); //wait for ref ok ADCSRA|=1<<ADSC; //Start throwaway conversion while (ADCSRA&(1<<ADSC)); //Wait till done ADCSRA|=1<<ADSC; //Start another conversion while (ADCSRA&(1<<ADSC)); //Wait till done tmp=ADC; //Read adc tmp=11*tmp-2728+(tmp>>2); //Convert to celcius*10 (should be 11.3*h, approximate with 11.25*h) ADCSRA=0; //disable ADC ADMUX=0; //turn off internal vref #endif /* Bandgap can't be measured against supply voltage in this chip. */ /* Use BATMON register instead */ for ( i=16; i<31; i++) { BATMON = i; if ((BATMON&(1<<BATMON_OK))==0) break; } bat=2550-75*16-75+75*i; //-75 to take the floor of the 75 mv transition window static const char httpd_cgi_ajax10[] HTTPD_STRING_ATTR ="t(%u),b(%u);adc(%d,%d,%u,%u,%u,%u,%u,%lu);"; numprinted = httpd_snprintf(buf, sizeof(buf),httpd_cgi_ajax10,tmp,bat,iter,tmp,bat,sleepcount,OCR2A,0,clock_time(),clock_seconds()); if (iter==1) { static const char httpd_cgi_ajax11[] HTTPD_STRING_ATTR = "wt('128rfa1 ["; static const char httpd_cgi_ajax12[] HTTPD_STRING_ATTR = "]');"; numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax11); #if WEBSERVER_CONF_PRINTADDR /* Note address table is filled from the end down */ {int i; for (i=0; i<UIP_DS6_ADDR_NB;i++) { if (uip_ds6_if.addr_list[i].isused) { numprinted += httpd_cgi_sprint_ip6(uip_ds6_if.addr_list[i].ipaddr, buf + numprinted); break; } } } #endif numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax12); } } #elif CONTIKI_TARGET_AVR_RAVEN { int16_t tmp,bat; #if 1 /* Usual way to get AVR supply voltage, measure 1.1v bandgap using Vcc as reference. * This connects the bandgap to the AREF pin, so enable only if there is no external AREF! * A capacitor may be connected to this pin to reduce reference noise. */ ADMUX =0x5E; //Select AVCC as reference, measure 1.1 volt bandgap reference. ADCSRA=0x87; //Enable ADC, not free running, interrupt disabled, clock divider 128 (62 KHz@ 8 MHz) ADCSRA|=1<<ADSC; //Start throwaway conversion while (ADCSRA&(1<<ADSC)); //Wait till done ADCSRA|=1<<ADSC; //Start another conversion while (ADCSRA&(1<<ADSC)); //Wait till done //bat=1126400UL/ADC; //Get supply voltage (factor nominally 1100*1024) bat=1198070UL/ADC; //My Raven ADCSRA=0; //disable ADC ADMUX=0; //turn off internal vref #else bat=3300; #endif tmp=420; static const char httpd_cgi_ajax10[] HTTPD_STRING_ATTR ="t(%u),b(%u);adc(%d,%d,%u,%u,%u,%u,%u,%lu);"; numprinted = httpd_snprintf(buf, sizeof(buf),httpd_cgi_ajax10,tmp,bat,iter,tmp,bat,sleepcount,OCR2A,0,clock_time(),clock_seconds()); if (iter<3) { static const char httpd_cgi_ajax11[] HTTPD_STRING_ATTR = "wt('Raven ["; static const char httpd_cgi_ajax12[] HTTPD_STRING_ATTR = "]');"; numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax11); #if WEBSERVER_CONF_PRINTADDR /* Note address table is filled from the end down */ {int i; for (i=0; i<UIP_DS6_ADDR_NB;i++) { if (uip_ds6_if.addr_list[i].isused) { numprinted += httpd_cgi_sprint_ip6(uip_ds6_if.addr_list[i].ipaddr, buf + numprinted); break; } } } #endif numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax12); } } //#elif CONTIKI_TARGET_IS_SOMETHING_ELSE #else { static const char httpd_cgi_ajax10[] HTTPD_STRING_ATTR ="v(%u);"; numprinted = httpd_snprintf(buf, sizeof(buf),httpd_cgi_ajax10,iter); if (iter==1) { static const char httpd_cgi_ajax11[] HTTPD_STRING_ATTR = "wt('Contiki Ajax "; static const char httpd_cgi_ajax12[] HTTPD_STRING_ATTR = "');"; numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax11); #if WEBSERVER_CONF_PRINTADDR /* Note address table is filled from the end down */ {int i; for (i=0; i<UIP_DS6_ADDR_NB;i++) { if (uip_ds6_if.addr_list[i].isused) { numprinted += httpd_cgi_sprint_ip6(uip_ds6_if.addr_list[i].ipaddr, buf + numprinted); break; } } } #endif numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajax12); } } #endif #if CONTIKIMAC_CONF_COMPOWER #include "sys/compower.h" { //sl=compower_idle_activity.transmit/RTIMER_ARCH_SECOND; //sl=compower_idle_activity.listen/RTIMER_ARCH_SECOND; } #endif #if RIMESTATS_CONF_ON #include "net/rime/rimestats.h" static const char httpd_cgi_ajaxr1[] HTTPD_STRING_ATTR ="rime(%lu,%lu,%lu,%lu);"; numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajaxr1, rimestats.tx,rimestats.rx,rimestats.lltx-rimestats.tx,rimestats.llrx-rimestats.rx); #endif #if ENERGEST_CONF_ON { #if 1 /* Send on times in percent since last update. Handle 16 bit rtimer wraparound. */ /* Javascript must convert based on platform cpu, tx, rx power, e.g. 20ma*3v3=66mW*(% on time/100) */ static rtimer_clock_t last_send; rtimer_clock_t delta_time; static unsigned long last_cpu, last_lpm, last_listen, last_transmit; energest_flush(); delta_time=RTIMER_NOW()-last_send; if (RTIMER_CLOCK_LT(RTIMER_NOW(),last_send)) delta_time+=RTIMER_ARCH_SECOND; last_send=RTIMER_NOW(); static const char httpd_cgi_ajaxe1[] HTTPD_STRING_ATTR = "p(%lu,%lu,%lu,%lu);"; numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajaxe1, (100UL*(energest_total_time[ENERGEST_TYPE_CPU].current - last_cpu))/delta_time, (100UL*(energest_total_time[ENERGEST_TYPE_LPM].current - last_lpm))/delta_time, (100UL*(energest_total_time[ENERGEST_TYPE_TRANSMIT].current - last_transmit))/delta_time, (100UL*(energest_total_time[ENERGEST_TYPE_LISTEN].current - last_listen))/delta_time); last_cpu = energest_total_time[ENERGEST_TYPE_CPU].current; last_lpm = energest_total_time[ENERGEST_TYPE_LPM].current; last_transmit = energest_total_time[ENERGEST_TYPE_TRANSMIT].current; last_listen = energest_total_time[ENERGEST_TYPE_LISTEN].current; #endif #if 1 /* Send cumulative on times in percent*100 */ uint16_t cpp,txp,rxp; uint32_t sl,clockseconds=clock_seconds(); // energest_flush(); // sl=((10000UL*energest_total_time[ENERGEST_TYPE_CPU].current)/RTIMER_ARCH_SECOND)/clockseconds; sl=energest_total_time[ENERGEST_TYPE_CPU].current/RTIMER_ARCH_SECOND; cpp=(10000UL*sl)/clockseconds; // txp=((10000UL*energest_total_time[ENERGEST_TYPE_TRANSMIT].current)/RTIMER_ARCH_SECOND)/clockseconds; sl=energest_total_time[ENERGEST_TYPE_TRANSMIT].current/RTIMER_ARCH_SECOND; txp=(10000UL*sl)/clockseconds; // rxp=((10000UL*energest_total_time[ENERGEST_TYPE_LISTEN].current)/RTIMER_ARCH_SECOND)/clockseconds; sl=energest_total_time[ENERGEST_TYPE_LISTEN].current/RTIMER_ARCH_SECOND; rxp=(10000UL*sl)/clockseconds; static const char httpd_cgi_ajaxe2[] HTTPD_STRING_ATTR = "ener(%u,%u,%u);"; numprinted += httpd_snprintf(buf+numprinted, sizeof(buf)-numprinted,httpd_cgi_ajaxe2,cpp,txp,rxp); #endif } #endif /* ENERGEST_CONF_ON */ PSOCK_SEND_STR(&s->sout, buf); timer_restart(&t); PSOCK_WAIT_UNTIL(&s->sout, timer_expired(&t)); } PSOCK_END(&s->sout); }
/*---------------------------------------------------------------------------*/ static char powercycle(struct rtimer *t, void *ptr) { #if SYNC_CYCLE_STARTS static volatile rtimer_clock_t sync_cycle_start; static volatile uint8_t sync_cycle_phase; #endif PT_BEGIN(&pt); #if SYNC_CYCLE_STARTS sync_cycle_start = RTIMER_NOW(); #else cycle_start = RTIMER_NOW(); #endif while(1) { static uint8_t packet_seen; static rtimer_clock_t t0; static uint8_t count; #if SYNC_CYCLE_STARTS /* Compute cycle start when RTIMER_ARCH_SECOND is not a multiple of CHANNEL_CHECK_RATE */ if(sync_cycle_phase++ == NETSTACK_RDC_CHANNEL_CHECK_RATE) { sync_cycle_phase = 0; sync_cycle_start += RTIMER_ARCH_SECOND; cycle_start = sync_cycle_start; } else { #if (RTIMER_ARCH_SECOND * NETSTACK_RDC_CHANNEL_CHECK_RATE) > 65535 cycle_start = sync_cycle_start + ((unsigned long)(sync_cycle_phase*RTIMER_ARCH_SECOND))/NETSTACK_RDC_CHANNEL_CHECK_RATE; #else cycle_start = sync_cycle_start + (sync_cycle_phase*RTIMER_ARCH_SECOND)/NETSTACK_RDC_CHANNEL_CHECK_RATE; #endif } #else cycle_start += CYCLE_TIME; #endif packet_seen = 0; for(count = 0; count < CCA_COUNT_MAX; ++count) { t0 = RTIMER_NOW(); if(we_are_sending == 0 && we_are_receiving_burst == 0) { powercycle_turn_radio_on(); /* Check if a packet is seen in the air. If so, we keep the radio on for a while (LISTEN_TIME_AFTER_PACKET_DETECTED) to be able to receive the packet. We also continuously check the radio medium to make sure that we wasn't woken up by a false positive: a spurious radio interference that was not caused by an incoming packet. */ if(NETSTACK_RADIO.channel_clear() == 0) { packet_seen = 1; break; } powercycle_turn_radio_off(); } schedule_powercycle_fixed(t, RTIMER_NOW() + CCA_SLEEP_TIME); PT_YIELD(&pt); } if(packet_seen) { static rtimer_clock_t start; static uint8_t silence_periods, periods; start = RTIMER_NOW(); periods = silence_periods = 0; while(we_are_sending == 0 && radio_is_on && RTIMER_CLOCK_LT(RTIMER_NOW(), (start + LISTEN_TIME_AFTER_PACKET_DETECTED))) { /* Check for a number of consecutive periods of non-activity. If we see two such periods, we turn the radio off. Also, if a packet has been successfully received (as indicated by the NETSTACK_RADIO.pending_packet() function), we stop snooping. */ #if !RDC_CONF_HARDWARE_CSMA /* A cca cycle will disrupt rx on some radios, e.g. mc1322x, rf230 */ /*TODO: Modify those drivers to just return the internal RSSI when already in rx mode */ if(NETSTACK_RADIO.channel_clear()) { ++silence_periods; } else { silence_periods = 0; } #endif ++periods; if(NETSTACK_RADIO.receiving_packet()) { silence_periods = 0; } if(silence_periods > MAX_SILENCE_PERIODS) { powercycle_turn_radio_off(); break; } if(WITH_FAST_SLEEP && periods > MAX_NONACTIVITY_PERIODS && !(NETSTACK_RADIO.receiving_packet() || NETSTACK_RADIO.pending_packet())) { powercycle_turn_radio_off(); break; } if(NETSTACK_RADIO.pending_packet()) { break; } schedule_powercycle(t, CCA_CHECK_TIME + CCA_SLEEP_TIME); PT_YIELD(&pt); } if(radio_is_on) { if(!(NETSTACK_RADIO.receiving_packet() || NETSTACK_RADIO.pending_packet()) || !RTIMER_CLOCK_LT(RTIMER_NOW(), (start + LISTEN_TIME_AFTER_PACKET_DETECTED))) { powercycle_turn_radio_off(); } } } if(RTIMER_CLOCK_LT(RTIMER_NOW() - cycle_start, CYCLE_TIME - CHECK_TIME * 4)) { /* Schedule the next powercycle interrupt, or sleep the mcu until then. Sleeping will not exit from this interrupt, so ensure an occasional wake cycle or foreground processing will be blocked until a packet is detected */ #if RDC_CONF_MCU_SLEEP static uint8_t sleepcycle; if((sleepcycle++ < 16) && !we_are_sending && !radio_is_on) { rtimer_arch_sleep(CYCLE_TIME - (RTIMER_NOW() - cycle_start)); } else { sleepcycle = 0; schedule_powercycle_fixed(t, CYCLE_TIME + cycle_start); PT_YIELD(&pt); } #else schedule_powercycle_fixed(t, CYCLE_TIME + cycle_start); PT_YIELD(&pt); #endif } } PT_END(&pt); }
/*---------------------------------------------------------------------------*/ static int send_packet(mac_callback_t mac_callback, void *mac_callback_ptr, struct rdc_buf_list *buf_list, int is_receiver_awake) { rtimer_clock_t t0; rtimer_clock_t encounter_time = 0; int strobes; uint8_t got_strobe_ack = 0; int hdrlen, len; uint8_t is_broadcast = 0; uint8_t is_reliable = 0; uint8_t is_known_receiver = 0; uint8_t collisions; int transmit_len; int ret; uint8_t contikimac_was_on; uint8_t seqno; #if WITH_CONTIKIMAC_HEADER struct hdr *chdr; #endif /* WITH_CONTIKIMAC_HEADER */ /* Exit if RDC and radio were explicitly turned off */ if(!contikimac_is_on && !contikimac_keep_radio_on) { PRINTF("contikimac: radio is turned off\n"); return MAC_TX_ERR_FATAL; } if(packetbuf_totlen() == 0) { PRINTF("contikimac: send_packet data len 0\n"); return MAC_TX_ERR_FATAL; } #if !NETSTACK_CONF_BRIDGE_MODE /* If NETSTACK_CONF_BRIDGE_MODE is set, assume PACKETBUF_ADDR_SENDER is already set. */ packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &rimeaddr_node_addr); #endif if(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), &rimeaddr_null)) { is_broadcast = 1; PRINTDEBUG("contikimac: send broadcast\n"); if(broadcast_rate_drop()) { return MAC_TX_COLLISION; } } else { #if UIP_CONF_IPV6 PRINTDEBUG("contikimac: send unicast to %02x%02x:%02x%02x:%02x%02x:%02x%02x\n", packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[1], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[2], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[3], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[4], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[5], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[6], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[7]); #else /* UIP_CONF_IPV6 */ PRINTDEBUG("contikimac: send unicast to %u.%u\n", packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0], packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[1]); #endif /* UIP_CONF_IPV6 */ } is_reliable = packetbuf_attr(PACKETBUF_ATTR_RELIABLE) || packetbuf_attr(PACKETBUF_ATTR_ERELIABLE); packetbuf_set_attr(PACKETBUF_ATTR_MAC_ACK, 1); #if WITH_CONTIKIMAC_HEADER hdrlen = packetbuf_totlen(); if(packetbuf_hdralloc(sizeof(struct hdr)) == 0) { /* Failed to allocate space for contikimac header */ PRINTF("contikimac: send failed, too large header\n"); return MAC_TX_ERR_FATAL; } chdr = packetbuf_hdrptr(); chdr->id = CONTIKIMAC_ID; chdr->len = hdrlen; /* Create the MAC header for the data packet. */ hdrlen = NETSTACK_FRAMER.create(); if(hdrlen < 0) { /* Failed to send */ PRINTF("contikimac: send failed, too large header\n"); packetbuf_hdr_remove(sizeof(struct hdr)); return MAC_TX_ERR_FATAL; } hdrlen += sizeof(struct hdr); #else /* Create the MAC header for the data packet. */ hdrlen = NETSTACK_FRAMER.create(); if(hdrlen < 0) { /* Failed to send */ PRINTF("contikimac: send failed, too large header\n"); return MAC_TX_ERR_FATAL; } #endif /* Make sure that the packet is longer or equal to the shortest packet length. */ transmit_len = packetbuf_totlen(); if(transmit_len < SHORTEST_PACKET_SIZE) { /* Pad with zeroes */ uint8_t *ptr; ptr = packetbuf_dataptr(); memset(ptr + packetbuf_datalen(), 0, SHORTEST_PACKET_SIZE - packetbuf_totlen()); PRINTF("contikimac: shorter than shortest (%d)\n", packetbuf_totlen()); transmit_len = SHORTEST_PACKET_SIZE; } packetbuf_compact(); #ifdef NETSTACK_ENCRYPT NETSTACK_ENCRYPT(); #endif /* NETSTACK_ENCRYPT */ transmit_len = packetbuf_totlen(); NETSTACK_RADIO.prepare(packetbuf_hdrptr(), transmit_len); /* Remove the MAC-layer header since it will be recreated next time around. */ packetbuf_hdr_remove(hdrlen); if(!is_broadcast && !is_receiver_awake) { #if WITH_PHASE_OPTIMIZATION ret = phase_wait(&phase_list, packetbuf_addr(PACKETBUF_ADDR_RECEIVER), CYCLE_TIME, GUARD_TIME, mac_callback, mac_callback_ptr, buf_list); if(ret == PHASE_DEFERRED) { return MAC_TX_DEFERRED; } if(ret != PHASE_UNKNOWN) { is_known_receiver = 1; } #endif /* WITH_PHASE_OPTIMIZATION */ } /* By setting we_are_sending to one, we ensure that the rtimer powercycle interrupt do not interfere with us sending the packet. */ we_are_sending = 1; /* If we have a pending packet in the radio, we should not send now, because we will trash the received packet. Instead, we signal that we have a collision, which lets the packet be received. This packet will be retransmitted later by the MAC protocol instread. */ if(NETSTACK_RADIO.receiving_packet() || NETSTACK_RADIO.pending_packet()) { we_are_sending = 0; PRINTF("contikimac: collision receiving %d, pending %d\n", NETSTACK_RADIO.receiving_packet(), NETSTACK_RADIO.pending_packet()); return MAC_TX_COLLISION; } /* Switch off the radio to ensure that we didn't start sending while the radio was doing a channel check. */ off(); strobes = 0; /* Send a train of strobes until the receiver answers with an ACK. */ collisions = 0; got_strobe_ack = 0; /* Set contikimac_is_on to one to allow the on() and off() functions to control the radio. We restore the old value of contikimac_is_on when we are done. */ contikimac_was_on = contikimac_is_on; contikimac_is_on = 1; #if !RDC_CONF_HARDWARE_CSMA /* Check if there are any transmissions by others. */ /* TODO: why does this give collisions before sending with the mc1322x? */ if(is_receiver_awake == 0) { int i; for(i = 0; i < CCA_COUNT_MAX_TX; ++i) { t0 = RTIMER_NOW(); on(); #if CCA_CHECK_TIME > 0 while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + CCA_CHECK_TIME)) { } #endif if(NETSTACK_RADIO.channel_clear() == 0) { collisions++; off(); break; } off(); t0 = RTIMER_NOW(); while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + CCA_SLEEP_TIME)) { } } } if(collisions > 0) { we_are_sending = 0; off(); PRINTF("contikimac: collisions before sending\n"); contikimac_is_on = contikimac_was_on; return MAC_TX_COLLISION; } #endif /* RDC_CONF_HARDWARE_CSMA */ #if !RDC_CONF_HARDWARE_ACK if(!is_broadcast) { /* Turn radio on to receive expected unicast ack. Not necessary with hardware ack detection, and may trigger an unnecessary cca or rx cycle */ on(); } #endif watchdog_periodic(); t0 = RTIMER_NOW(); seqno = packetbuf_attr(PACKETBUF_ATTR_MAC_SEQNO); for(strobes = 0, collisions = 0; got_strobe_ack == 0 && collisions == 0 && RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + STROBE_TIME); strobes++) { watchdog_periodic(); if(!is_broadcast && (is_receiver_awake || is_known_receiver) && !RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + MAX_PHASE_STROBE_TIME)) { PRINTF("miss to %d\n", packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0]); break; } len = 0; { rtimer_clock_t wt; rtimer_clock_t txtime; int ret; txtime = RTIMER_NOW(); ret = NETSTACK_RADIO.transmit(transmit_len); #if RDC_CONF_HARDWARE_ACK /* For radios that block in the transmit routine and detect the ACK in hardware */ if(ret == RADIO_TX_OK) { if(!is_broadcast) { got_strobe_ack = 1; encounter_time = txtime; break; } } else if (ret == RADIO_TX_NOACK) { } else if (ret == RADIO_TX_COLLISION) { PRINTF("contikimac: collisions while sending\n"); collisions++; } wt = RTIMER_NOW(); while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + INTER_PACKET_INTERVAL)) { } #else /* RDC_CONF_HARDWARE_ACK */ /* Wait for the ACK packet */ wt = RTIMER_NOW(); while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + INTER_PACKET_INTERVAL)) { } if(!is_broadcast && (NETSTACK_RADIO.receiving_packet() || NETSTACK_RADIO.pending_packet() || NETSTACK_RADIO.channel_clear() == 0)) { uint8_t ackbuf[ACK_LEN]; wt = RTIMER_NOW(); while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + AFTER_ACK_DETECTECT_WAIT_TIME)) { } len = NETSTACK_RADIO.read(ackbuf, ACK_LEN); if(len == ACK_LEN && seqno == ackbuf[ACK_LEN - 1]) { got_strobe_ack = 1; encounter_time = txtime; break; } else { PRINTF("contikimac: collisions while sending\n"); collisions++; } } #endif /* RDC_CONF_HARDWARE_ACK */ } } off(); PRINTF("contikimac: send (strobes=%u, len=%u, %s, %s), done\n", strobes, packetbuf_totlen(), got_strobe_ack ? "ack" : "no ack", collisions ? "collision" : "no collision"); #if CONTIKIMAC_CONF_COMPOWER /* Accumulate the power consumption for the packet transmission. */ compower_accumulate(¤t_packet); /* Convert the accumulated power consumption for the transmitted packet to packet attributes so that the higher levels can keep track of the amount of energy spent on transmitting the packet. */ compower_attrconv(¤t_packet); /* Clear the accumulated power consumption so that it is ready for the next packet. */ compower_clear(¤t_packet); #endif /* CONTIKIMAC_CONF_COMPOWER */ contikimac_is_on = contikimac_was_on; we_are_sending = 0; /* Determine the return value that we will return from the function. We must pass this value to the phase module before we return from the function. */ if(collisions > 0) { ret = MAC_TX_COLLISION; } else if(!is_broadcast && !got_strobe_ack) { ret = MAC_TX_NOACK; } else { ret = MAC_TX_OK; } #if WITH_PHASE_OPTIMIZATION if(is_known_receiver && got_strobe_ack) { PRINTF("no miss %d wake-ups %d\n", packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0], strobes); } if(!is_broadcast) { if(collisions == 0 && is_receiver_awake == 0) { phase_update(&phase_list, packetbuf_addr(PACKETBUF_ADDR_RECEIVER), encounter_time, ret); } } #endif /* WITH_PHASE_OPTIMIZATION */ return ret; }
/*---------------------------------------------------------------------------*/ static int transmit(unsigned short transmit_len) { uint8_t counter; int ret = RADIO_TX_ERR; rtimer_clock_t t0; uint8_t was_off = 0; PRINTF("RF: Transmit\n"); if(!(rf_flags & RX_ACTIVE)) { t0 = RTIMER_NOW(); on(); was_off = 1; while(RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + ONOFF_TIME)); } if(channel_clear() == CC2538_RF_CCA_BUSY) { RIMESTATS_ADD(contentiondrop); return RADIO_TX_COLLISION; } /* * prepare() double checked that TX_ACTIVE is low. If SFD is high we are * receiving. Abort transmission and bail out with RADIO_TX_COLLISION */ if(REG(RFCORE_XREG_FSMSTAT1) & RFCORE_XREG_FSMSTAT1_SFD) { RIMESTATS_ADD(contentiondrop); return RADIO_TX_COLLISION; } /* Start the transmission */ ENERGEST_OFF(ENERGEST_TYPE_LISTEN); ENERGEST_ON(ENERGEST_TYPE_TRANSMIT); CC2538_RF_CSP_ISTXON(); counter = 0; while(!((REG(RFCORE_XREG_FSMSTAT1) & RFCORE_XREG_FSMSTAT1_TX_ACTIVE)) && (counter++ < 3)) { clock_delay_usec(6); } if(!(REG(RFCORE_XREG_FSMSTAT1) & RFCORE_XREG_FSMSTAT1_TX_ACTIVE)) { PRINTF("RF: TX never active.\n"); CC2538_RF_CSP_ISFLUSHTX(); ret = RADIO_TX_ERR; } else { /* Wait for the transmission to finish */ while(REG(RFCORE_XREG_FSMSTAT1) & RFCORE_XREG_FSMSTAT1_TX_ACTIVE); ret = RADIO_TX_OK; } ENERGEST_OFF(ENERGEST_TYPE_TRANSMIT); ENERGEST_ON(ENERGEST_TYPE_LISTEN); if(was_off) { off(); } RIMESTATS_ADD(lltx); return ret; }