/*---------------------------------------------------------------------------*/
static void
send(mac_callback_t sent, void *ptr)
{
struct akes_nbr_entry *entry;
packetbuf_set_attr(PACKETBUF_ATTR_FRAME_TYPE, FRAME802154_DATAFRAME);
if(packetbuf_holds_broadcast()) {
if(!akes_nbr_count(AKES_NBR_PERMANENT)) {
mac_call_sent_callback(sent, ptr, MAC_TX_ERR, 0);
return;
}
adaptivesec_add_security_header(NULL);
} else {
entry = akes_nbr_get_receiver_entry();
if(!entry || !entry->permanent) {
mac_call_sent_callback(sent, ptr, MAC_TX_ERR, 0);
return;
}
adaptivesec_add_security_header(&entry->permanent->anti_replay_info);
#if ANTI_REPLAY_WITH_SUPPRESSION
packetbuf_set_attr(PACKETBUF_ATTR_NEIGHBOR_INDEX, entry->local_index);
#endif /* ANTI_REPLAY_WITH_SUPPRESSION */
}
#if !ANTI_REPLAY_WITH_SUPPRESSION && !POTR_ENABLED
framer_802154_set_seqno();
#endif /* ANTI_REPLAY_WITH_SUPPRESSION && !POTR_ENABLED */
ADAPTIVESEC_STRATEGY.send(sent, ptr);
}
/*---------------------------------------------------------------------------*/
static void
send_packet(mac_callback_t sent, void *ptr)
{
UNUSED(ptr);
PRINTF("IEEE8023_mac: tx\n");
if (NETSTACK_0_FRAMER.create() < 0) {
PRINTF("IEEE8023_MAC: framer-failed-to-create\n");
mac_call_sent_callback(sent, NULL, MAC_TX_ERR_FATAL, 0);
return;
}
/* Transmit packet to the Ethernet driver, passing the mac_sent_callback. */
ETHERNET_STACK.tx_packet(sent, NULL);
#if 0
switch(ETHERNET_STACK.tx_packet(NULL, NULL)) {
case ETHERNET_TX_OK:
mac_call_sent_callback(sent, NULL, MAC_TX_OK, 1);
break;
case ETHERNET_TX_ERR_FATAL:
case ETHERNET_TX_ERR_OFFLINE:
case ETHERNET_TX_ERR_FULL:
mac_call_sent_callback(sent, NULL, MAC_TX_ERR_FATAL, 0);
break;
case ETHERNET_TX_ERR_COLLISION:
case ETHERNET_TX_ERR_TIMEOUT:
mac_call_sent_callback(sent, NULL, MAC_TX_ERR, 1);
break;
default:
PRINTF("ieee8023_mac: unrecognized ETH return status\n");
break;
}
#endif
}
/*---------------------------------------------------------------------------*/
static void
send_packet(mac_callback_t sent, void *ptr)
{
int size;
/* 3 bytes per packet attribute is required for serialization */
uint8_t buf[PACKETBUF_NUM_ATTRS * 3 + PACKETBUF_SIZE + 3];
int sid;
packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &linkaddr_node_addr);
/* ack or not ? */
packetbuf_set_attr(PACKETBUF_ATTR_MAC_ACK, 1);
if(NETSTACK_FRAMER.create_and_secure() < 0) {
/* Failed to allocate space for headers */
LOG6LBR_ERROR("br-rdc: send failed, too large header\n");
mac_call_sent_callback(sent, ptr, MAC_TX_ERR_FATAL, 1);
} else {
/* here we send the data over SLIP to the radio-chip */
size = 0;
if(sixlbr_config_slip_serialize_tx_attrs) {
size = packetutils_serialize_atts(&buf[3], sizeof(buf) - 3);
}
if(size < 0 || size + packetbuf_totlen() + 3 > sizeof(buf)) {
LOG6LBR_ERROR("br-rdc: send failed, too large header\n");
mac_call_sent_callback(sent, ptr, MAC_TX_ERR_FATAL, 1);
} else {
sid = setup_callback(sent, ptr);
if (sid != -1) {
LOG6LBR_PRINTF(PACKET, RADIO_OUT, "write: %d (sid: %d, cb: %d)\n", packetbuf_datalen(), sid, callback_count);
LOG6LBR_DUMP_PACKET(RADIO_OUT, packetbuf_dataptr(), packetbuf_datalen());
buf[0] = '!';
buf[1] = 'S';
buf[2] = sid; /* sequence or session number for this packet */
/* Copy packet data */
memcpy(&buf[3 + size], packetbuf_hdrptr(), packetbuf_totlen());
callbacks[sid].buf_len = packetbuf_totlen() + size + 3;
memcpy(callbacks[sid].buf, buf, callbacks[sid].buf_len);
write_to_slip(buf, callbacks[sid].buf_len);
} else {
LOG6LBR_INFO("native-rdc queue full\n");
mac_call_sent_callback(sent, ptr, MAC_TX_NOACK, 1);
}
}
}
}
/*---------------------------------------------------------------------------*/
static void
qsend_list(mac_callback_t sent, void *ptr, struct rdc_buf_list *buf_list)
{
struct rdc_buf_list *curr = buf_list;
struct rdc_buf_list *next;
int ret;
int is_receiver_awake;
if(curr == NULL) {
return;
}
/* Do not send during reception of a burst */
if(we_are_receiving_burst) {
/* Prepare the packetbuf for callback */
queuebuf_to_packetbuf(curr->buf);
/* Return COLLISION so the MAC may try again later */
mac_call_sent_callback(sent, ptr, MAC_TX_COLLISION, 1);
return;
}
/* The receiver needs to be awoken before we send */
is_receiver_awake = 0;
do { /* A loop sending a burst of packets from buf_list */
next = list_item_next(curr);
/* Prepare the packetbuf */
queuebuf_to_packetbuf(curr->buf);
if(next != NULL) {
packetbuf_set_attr(PACKETBUF_ATTR_PENDING, 1);
}
/* Send the current packet */
ret = send_packet(sent, ptr, curr, is_receiver_awake);
if(ret != MAC_TX_DEFERRED) {
mac_call_sent_callback(sent, ptr, ret, 1);
}
if(ret == MAC_TX_OK) {
if(next != NULL) {
/* We're in a burst, no need to wake the receiver up again */
is_receiver_awake = 1;
curr = next;
}
} else {
/* The transmission failed, we stop the burst */
next = NULL;
}
} while(next != NULL);
}
static void send_packet(mac_callback_t sent, void *ptr) {
struct queuebuf *packet;
packet = queuebuf_new_from_packetbuf();
if(packet == NULL) {
/* No buffer available */
printf("WPI-MAC: send failed, no queue buffer available (of %u)\n", QUEUEBUF_CONF_NUM);
mac_call_sent_callback(sent, ptr, MAC_TX_ERR, 1);
} else {
// schedule for proper slot
// if broadcast, slot 0
// if uni, slot of dest->u8[7]
rimeaddr_t *dest = (rimeaddr_t*)packetbuf_addr(PACKETBUF_ADDR_RECEIVER);
if(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), &rimeaddr_null)) {
// schedule for slot 0
// printf("scheduling bcast\n");
schedule_outgoing_packet(BROADCAST_SLOT, sent, ptr, packet);
} else {
// schedule for slot dest_node
schedule_outgoing_packet((unsigned short)dest->u8[7], sent, ptr, packet);
}
}
}
/*---------------------------------------------------------------------------*/
static void
tx_done(int status, struct rdc_buf_list *q, struct neighbor_queue *n)
{
mac_callback_t sent;
struct qbuf_metadata *metadata;
void *cptr;
uint8_t ntx;
metadata = (struct qbuf_metadata *)q->ptr;
sent = metadata->sent;
cptr = metadata->cptr;
ntx = n->transmissions;
switch(status) {
case MAC_TX_OK:
PRINTF("csma: rexmit ok %d\n", n->transmissions);
break;
case MAC_TX_COLLISION:
case MAC_TX_NOACK:
PRINTF("csma: drop with status %d after %d transmissions, %d collisions\n",
status, n->transmissions, n->collisions);
break;
default:
PRINTF("csma: rexmit failed %d: %d\n", n->transmissions, status);
break;
}
free_packet(n, q, status);
mac_call_sent_callback(sent, cptr, status, ntx);
}
/*---------------------------------------------------------------------------*/
static void
plb_send(mac_callback_t sent, void *ptr)
{
PRINTF("plb_send\n");
if ( packetbuf_attr(PACKETBUF_ATTR_PACKET_TYPE) == 0 ) //data
{
PRINTF("plb_send : DATA\n");
send_req = 1;
sent_callback = sent;
sent_ptr = ptr;
//packetbuf_clear_hdr();
temp_len=packetbuf_datalen();
packetbuf_copyto(dataptr_temp);
print_packet(dataptr_temp,packetbuf_totlen());//JJH3
}
//kdw sync
else if ( packetbuf_attr(PACKETBUF_ATTR_PACKET_TYPE) == 1 ) //sync
{
sent_callback = sent;
sent_ptr = ptr;
plb_send_sync_start();
}
else // error
{
mac_call_sent_callback(sent, ptr, MAC_TX_ERR, 1); //error fill this
}
return;
}
/*---------------------------------------------------------------------------*/
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 void
qsend_packet(mac_callback_t sent, void *ptr)
{
int ret = send_packet(sent, ptr);
if(ret != MAC_TX_DEFERRED) {
// printf("contikimac qsend_packet %p\n", ptr);
mac_call_sent_callback(sent, ptr, ret, 1);
}
}
/*---------------------------------------------------------------------------*/
static void
send_packet(mac_callback_t sent, void *ptr)
{
int size;
/* 3 bytes per packet attribute is required for serialization */
uint8_t buf[PACKETBUF_NUM_ATTRS * 3 + PACKETBUF_SIZE + 3];
uint8_t sid;
packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &rimeaddr_node_addr);
/* ack or not ? */
packetbuf_set_attr(PACKETBUF_ATTR_MAC_ACK, 1);
if(NETSTACK_FRAMER.create() < 0) {
/* Failed to allocate space for headers */
PRINTF("br-rdc: send failed, too large header\n");
mac_call_sent_callback(sent, ptr, MAC_TX_ERR_FATAL, 1);
} else {
/* here we send the data over SLIP to the radio-chip */
size = 0;
#if SERIALIZE_ATTRIBUTES
size = packetutils_serialize_atts(&buf[3], sizeof(buf) - 3);
#endif
if(size < 0 || size + packetbuf_totlen() + 3 > sizeof(buf)) {
PRINTF("br-rdc: send failed, too large header\n");
mac_call_sent_callback(sent, ptr, MAC_TX_ERR_FATAL, 1);
} else {
PRINTF("SLIP: Sending %d\n", packetbuf_totlen());
sid = setup_callback(sent, ptr);
buf[0] = '!';
buf[1] = 'S';
buf[2] = sid; /* sequence or session number for this packet */
/* Copy packet data */
memcpy(&buf[3 + size], packetbuf_hdrptr(), packetbuf_totlen());
write_to_slip(buf, packetbuf_totlen() + size + 3);
}
}
}
/*---------------------------------------------------------------------------*/
static void
send_packet(mac_callback_t sent, void *ptr)
{
int ret;
if(NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen()) == RADIO_TX_OK) {
ret = MAC_TX_OK;
} else {
ret = MAC_TX_ERR;
}
mac_call_sent_callback(sent, ptr, ret, 1);
}
/*---------------------------------------------------------------------------*/
void packet_sent(uint8_t sessionid, uint8_t status, uint8_t tx)
{
if(sessionid < MAX_CALLBACKS) {
struct tx_callback *callback;
callback = &callbacks[sessionid];
packetbuf_clear();
packetbuf_attr_copyfrom(callback->attrs, callback->addrs);
mac_call_sent_callback(callback->cback, callback->ptr, status, tx);
} else {
PRINTF("*** ERROR: too high session id %d\n", sessionid);
}
}
/* Flush a neighbor queue */
static void
tsch_queue_flush_nbr_queue(struct tsch_neighbor *n)
{
while(!tsch_queue_is_empty(n)) {
struct tsch_packet *p = tsch_queue_remove_packet_from_queue(n);
if(p != NULL) {
/* Set return status for packet_sent callback */
p->ret = MAC_TX_ERR;
PRINTF("TSCH-queue:! flushing packet\n");
/* Call packet_sent callback */
mac_call_sent_callback(p->sent, p->ptr, p->ret, p->transmissions);
/* Free packet queuebuf */
tsch_queue_free_packet(p);
}
}
}
/*---------------------------------------------------------------------------*/
static void
qsend_packet(mac_callback_t sent, void *ptr)
{
int ret;
if(someone_is_sending) {
PRINTF("cxmac: should queue packet, now just dropping %d %d %d %d.\n",
waiting_for_packet, someone_is_sending, we_are_sending, radio_is_on);
RIMESTATS_ADD(sendingdrop);
ret = MAC_TX_COLLISION;
} else {
PRINTF("cxmac: send immediately.\n");
ret = send_packet();
}
mac_call_sent_callback(sent, ptr, ret, 1);
}
/*---------------------------------------------------------------------------*/
static void
packet_timeout(void *ptr)
{
struct tx_callback *callback = ptr;
if (callback->isused) {
callback_count--;
callback->isused = 0;
native_rdc_ack_timeout++;
LOG6LBR_ERROR("br-rdc: send failed, slip ack timeout (%d)\n", callback->sid);
packetbuf_clear();
packetbuf_attr_copyfrom(callback->attrs, callback->addrs);
mac_call_sent_callback(callback->cback, callback->ptr, MAC_TX_NOACK, 1);
} else {
LOG6LBR_ERROR("br-rdc: ack timeout for already acked packet (%d)\n", callback->sid);
}
}
/*---------------------------------------------------------------------------*/
static void
send_packet(mac_callback_t sent, void *ptr)
{
int ret;
packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &rimeaddr_node_addr);
if(NETSTACK_FRAMER.create() == 0) {
/* Failed to allocate space for headers */
PRINTF("nullrdc_framer: send failed, too large header\n");
ret = MAC_TX_ERR_FATAL;
} else if(NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen())
== RADIO_TX_OK) {
ret = MAC_TX_OK;
} else {
ret = MAC_TX_ERR;
}
mac_call_sent_callback(sent, ptr, ret, 1);
}
static uint8_t send_packet(struct net_buf *buf,
mac_callback_t sent_callback, void *ptr)
{
bool is_broadcast, ack_required;
uint8_t attempts;
uint8_t retries;
int ret;
#ifdef SIMPLERDC_802154_ACK_REQ
packetbuf_set_attr(buf, PACKETBUF_ATTR_MAC_ACK, 1);
#endif
retries = prepare_packet(buf);
if (!retries) {
return MAC_TX_ERR_FATAL;
}
ack_required = prepare_for_ack(buf);
is_broadcast = !!packetbuf_holds_broadcast(buf);
attempts = 0;
while (retries) {
attempts++;
retries--;
ret = NETSTACK_RADIO.transmit(buf, packetbuf_totlen(buf));
if (ret == RADIO_TX_COLLISION) {
continue;
}
ret = wait_for_ack(is_broadcast, ack_required);
if (ret == MAC_TX_OK) {
break;
}
}
mac_call_sent_callback(buf, sent_callback, ptr, ret, attempts);
if (ret == MAC_TX_OK) {
return 1;
}
return 0;
}
/* Pass sent packets to upper layer */
static void
tsch_tx_process_pending()
{
int16_t dequeued_index;
/* Loop on accessing (without removing) a pending input packet */
while((dequeued_index = ringbufindex_peek_get(&dequeued_ringbuf)) != -1) {
struct tsch_packet *p = dequeued_array[dequeued_index];
/* Put packet into packetbuf for packet_sent callback */
queuebuf_to_packetbuf(p->qb);
/* Call packet_sent callback */
mac_call_sent_callback(p->sent, p->ptr, p->ret, p->transmissions);
/* Free packet queuebuf */
tsch_queue_free_packet(p);
/* Free all unused neighbors */
tsch_queue_free_unused_neighbors();
/* Remove dequeued packet from ringbuf */
ringbufindex_get(&dequeued_ringbuf);
}
}
/*---------------------------------------------------------------------------*/
static void
send_packet(mac_callback_t sent_callback, void *ptr)
{
const rimeaddr_t *addr;
addr = packetbuf_addr(PACKETBUF_ADDR_RECEIVER);
PRINTF("rime-udp: Sending %d bytes to %d.%d\n", packetbuf_totlen(),
addr->u8[0], addr->u8[1]);
if(rimeaddr_cmp(&rimeaddr_null, addr)) {
uip_udp_packet_send(broadcast_conn,
packetbuf_hdrptr(), packetbuf_totlen());
mac_call_sent_callback(sent_callback, ptr, MAC_TX_OK, 1);
} else {
uip_ip6addr(&unicast_conn->ripaddr, 0xfe80, 0, 0, 0, 0, 0, 0, 0);
uip_netif_addr_autoconf_set(&unicast_conn->ripaddr, (uip_lladdr_t *)addr);
uip_udp_packet_send(unicast_conn,
packetbuf_hdrptr(), packetbuf_totlen());
uip_create_unspecified(&unicast_conn->ripaddr);
}
return;
}
/*---------------------------------------------------------------------------*/
void
packet_sent(uint8_t sessionid, uint8_t status, uint8_t tx)
{
LOG6LBR_PRINTF(PACKET, RADIO_OUT, "sid ack: %d (%d, %d)\n", sessionid, status, tx);
if(sessionid < MAX_CALLBACKS) {
struct tx_callback *callback;
callback = &callbacks[sessionid];
if (callback->isused) {
callback_count--;
callback->isused = 0;
packetbuf_clear();
packetbuf_attr_copyfrom(callback->attrs, callback->addrs);
ctimer_stop(&callback->timeout);
mac_call_sent_callback(callback->cback, callback->ptr, status, tx);
} else {
LOG6LBR_ERROR("br-rdc: ack received for unknown packet (%d)\n", callback->sid);
}
} else {
LOG6LBR_ERROR("*** ERROR: too high session id %d\n", sessionid);
}
}
/*---------------------------------------------------------------------------*/
static void
remove_queued_packet(struct queue_list_item *i, uint8_t tx_ok)
{
mac_callback_t sent;
void *ptr;
int num_transmissions = 0;
int status;
PRINTF("%d.%d: removing queued packet\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1]);
queuebuf_to_packetbuf(i->packet);
ctimer_stop(&i->removal_timer);
queuebuf_free(i->packet);
list_remove(pending_packets_list, i);
list_remove(queued_packets_list, i);
/* XXX potential optimization */
if(list_length(queued_packets_list) == 0 && is_listening == 0) {
turn_radio_off();
compower_accumulate(&i->compower);
}
sent = i->sent_callback;
ptr = i->sent_callback_ptr;
num_transmissions = i->num_transmissions;
memb_free(&queued_packets_memb, i);
if(num_transmissions == 0 || tx_ok == 0) {
status = MAC_TX_NOACK;
} else {
status = MAC_TX_OK;
}
mac_call_sent_callback(sent, ptr, status, num_transmissions);
}
/*---------------------------------------------------------------------------*/
static void
send_packet(mac_callback_t sent, void *ptr)
{
struct rdc_buf_list *q;
struct neighbor_queue *n;
static uint8_t initialized = 0;
static uint16_t seqno;
const rimeaddr_t *addr = packetbuf_addr(PACKETBUF_ADDR_RECEIVER);
if(!initialized) {
initialized = 1;
/* Initialize the sequence number to a random value as per 802.15.4. */
seqno = random_rand();
}
if(seqno == 0) {
/* PACKETBUF_ATTR_MAC_SEQNO cannot be zero, due to a pecuilarity
in framer-802154.c. */
seqno++;
}
packetbuf_set_attr(PACKETBUF_ATTR_MAC_SEQNO, seqno++);
/* Look for the neighbor entry */
n = neighbor_queue_from_addr(addr);
if(n == NULL) {
/* Allocate a new neighbor entry */
n = memb_alloc(&neighbor_memb);
if(n != NULL) {
/* Init neighbor entry */
rimeaddr_copy(&n->addr, addr);
n->transmissions = 0;
n->collisions = 0;
n->deferrals = 0;
/* Init packet list for this neighbor */
LIST_STRUCT_INIT(n, queued_packet_list);
/* Add neighbor to the list */
list_add(neighbor_list, n);
}
}
if(n != NULL) {
/* Add packet to the neighbor's queue */
q = memb_alloc(&packet_memb);
if(q != NULL) {
q->ptr = memb_alloc(&metadata_memb);
if(q->ptr != NULL) {
q->buf = queuebuf_new_from_packetbuf();
if(q->buf != NULL) {
struct qbuf_metadata *metadata = (struct qbuf_metadata *)q->ptr;
/* Neighbor and packet successfully allocated */
if(packetbuf_attr(PACKETBUF_ATTR_MAX_MAC_TRANSMISSIONS) == 0) {
/* Use default configuration for max transmissions */
metadata->max_transmissions = CSMA_MAX_MAC_TRANSMISSIONS;
} else {
metadata->max_transmissions =
packetbuf_attr(PACKETBUF_ATTR_MAX_MAC_TRANSMISSIONS);
}
metadata->sent = sent;
metadata->cptr = ptr;
if(packetbuf_attr(PACKETBUF_ATTR_PACKET_TYPE) ==
PACKETBUF_ATTR_PACKET_TYPE_ACK) {
list_push(n->queued_packet_list, q);
} else {
list_add(n->queued_packet_list, q);
}
/* If q is the first packet in the neighbor's queue, send asap */
if(list_head(n->queued_packet_list) == q) {
ctimer_set(&n->transmit_timer, 0, transmit_packet_list, n);
}
return;
}
memb_free(&metadata_memb, q->ptr);
PRINTF("csma: could not allocate queuebuf, dropping packet\n");
}
memb_free(&packet_memb, q);
PRINTF("csma: could not allocate queuebuf, dropping packet\n");
}
/* The packet allocation failed. Remove and free neighbor entry if empty. */
if(list_length(n->queued_packet_list) == 0) {
list_remove(neighbor_list, n);
memb_free(&neighbor_memb, n);
}
PRINTF("csma: could not allocate packet, dropping packet\n");
} else {
PRINTF("csma: could not allocate neighbor, dropping packet\n");
}
mac_call_sent_callback(sent, ptr, MAC_TX_ERR, 1);
}
/*---------------------------------------------------------------------------*/
static void
packet_sent(void *ptr, int status, int num_transmissions)
{
struct neighbor_queue *n;
struct rdc_buf_list *q;
struct qbuf_metadata *metadata;
clock_time_t time = 0;
mac_callback_t sent;
void *cptr;
int num_tx;
int backoff_exponent;
int backoff_transmissions;
n = ptr;
if(n == NULL) {
return;
}
switch(status) {
case MAC_TX_OK:
case MAC_TX_NOACK:
n->transmissions++;
break;
case MAC_TX_COLLISION:
n->collisions++;
break;
case MAC_TX_DEFERRED:
n->deferrals++;
break;
}
for(q = list_head(n->queued_packet_list);
q != NULL; q = list_item_next(q)) {
if(queuebuf_attr(q->buf, PACKETBUF_ATTR_MAC_SEQNO) ==
packetbuf_attr(PACKETBUF_ATTR_MAC_SEQNO)) {
break;
}
}
if(q != NULL) {
metadata = (struct qbuf_metadata *)q->ptr;
if(metadata != NULL) {
sent = metadata->sent;
cptr = metadata->cptr;
num_tx = n->transmissions;
if(status == MAC_TX_COLLISION ||
status == MAC_TX_NOACK) {
/* If the transmission was not performed because of a
collision or noack, we must retransmit the packet. */
switch(status) {
case MAC_TX_COLLISION:
PRINTF("csma: rexmit collision %d\n", n->transmissions);
break;
case MAC_TX_NOACK:
PRINTF("csma: rexmit noack %d\n", n->transmissions);
break;
default:
PRINTF("csma: rexmit err %d, %d\n", status, n->transmissions);
}
/* The retransmission time must be proportional to the channel
check interval of the underlying radio duty cycling layer. */
time = default_timebase();
/* The retransmission time uses a truncated exponential backoff
* so that the interval between the transmissions increase with
* each retransmit. */
backoff_exponent = num_tx;
/* Truncate the exponent if needed. */
if(backoff_exponent > CSMA_MAX_BACKOFF_EXPONENT) {
backoff_exponent = CSMA_MAX_BACKOFF_EXPONENT;
}
/* Proceed to exponentiation. */
backoff_transmissions = 1 << backoff_exponent;
/* Pick a time for next transmission, within the interval:
* [time, time + 2^backoff_exponent * time[ */
time = time + (random_rand() % (backoff_transmissions * time));
if(n->transmissions < metadata->max_transmissions) {
PRINTF("csma: retransmitting with time %lu %p\n", time, q);
ctimer_set(&n->transmit_timer, time,
transmit_packet_list, n);
/* This is needed to correctly attribute energy that we spent
transmitting this packet. */
queuebuf_update_attr_from_packetbuf(q->buf);
} else {
PRINTF("csma: drop with status %d after %d transmissions, %d collisions\n",
status, n->transmissions, n->collisions);
free_packet(n, q);
mac_call_sent_callback(sent, cptr, status, num_tx);
}
} else {
if(status == MAC_TX_OK) {
PRINTF("csma: rexmit ok %d\n", n->transmissions);
} else {
PRINTF("csma: rexmit failed %d: %d\n", n->transmissions, status);
}
free_packet(n, q);
mac_call_sent_callback(sent, cptr, status, num_tx);
}
}
}
}
/**
*
* Send a packet. This function builds a complete packet with an LPP
* header and queues the packet. When a probe is heard (in the
* read_packet() function), and the sender of the probe matches the
* receiver of the queued packet, the queued packet is sent.
*
* ACK packets are treated differently from other packets: if a node
* sends a packet that it expects to be ACKed, the sending node keeps
* its radio on for some time after sending its packet. So we do not
* need to wait for a probe packet: we just transmit the ACK packet
* immediately.
*
*/
static void
send_packet(mac_callback_t sent, void *ptr)
{
struct lpp_hdr hdr;
clock_time_t timeout;
uint8_t is_broadcast = 0;
rimeaddr_copy(&hdr.sender, &rimeaddr_node_addr);
rimeaddr_copy(&hdr.receiver, packetbuf_addr(PACKETBUF_ADDR_RECEIVER));
if(rimeaddr_cmp(&hdr.receiver, &rimeaddr_null)) {
is_broadcast = 1;
}
hdr.type = TYPE_DATA;
packetbuf_hdralloc(sizeof(struct lpp_hdr));
memcpy(packetbuf_hdrptr(), &hdr, sizeof(struct lpp_hdr));
packetbuf_compact();
packetbuf_set_attr(PACKETBUF_ATTR_MAC_ACK, 1);
{
int hdrlen = NETSTACK_FRAMER.create();
if(hdrlen == 0) {
/* Failed to send */
mac_call_sent_callback(sent, ptr, MAC_TX_ERR_FATAL, 0);
return;
}
}
PRINTF("%d.%d: queueing packet to %d.%d, channel %d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
hdr.receiver.u8[0], hdr.receiver.u8[1],
packetbuf_attr(PACKETBUF_ATTR_CHANNEL));
#if WITH_ACK_OPTIMIZATION
if(packetbuf_attr(PACKETBUF_ATTR_PACKET_TYPE) == PACKETBUF_ATTR_PACKET_TYPE_ACK) {
/* Send ACKs immediately. */
NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen());
mac_call_sent_callback(sent, ptr, MAC_TX_OK, 1);
return;
}
#endif /* WITH_ACK_OPTIMIZATION */
#if WITH_ADAPTIVE_OFF_TIME
off_time = LOWEST_OFF_TIME;
restart_dutycycle(off_time);
#endif /* WITH_ADAPTIVE_OFF_TIME */
{
struct queue_list_item *i;
i = memb_alloc(&queued_packets_memb);
if(i != NULL) {
i->sent_callback = sent;
i->sent_callback_ptr = ptr;
i->num_transmissions = 0;
i->packet = queuebuf_new_from_packetbuf();
if(i->packet == NULL) {
memb_free(&queued_packets_memb, i);
printf("null packet\n");
mac_call_sent_callback(sent, ptr, MAC_TX_ERR, 0);
return;
} else {
if(is_broadcast) {
timeout = PACKET_LIFETIME;
#if WITH_PENDING_BROADCAST
/* We set the broadcast state of the packet to be
waiting. This means that the packet is waiting for our
next probe to be sent. Our next probe is used to check if
there are any neighbors currently broadcasting a
packet. If so, we will get a broadcast packet in response
to our probe. If no broadcast packet is received in
response to our probe, we mark the packet as ready to be
sent. */
set_broadcast_flag(i, BROADCAST_FLAG_WAITING);
PRINTF("-> waiting\n");
#endif /* WITH_PENDING_BROADCAST */
} else {
timeout = UNICAST_TIMEOUT;
#if WITH_PENDING_BROADCAST
i->broadcast_flag = BROADCAST_FLAG_NONE;
#endif /* WITH_PENDING_BROADCAST */
}
ctimer_set(&i->removal_timer, timeout,
remove_queued_old_packet_callback, i);
/* Wait for a probe packet from a neighbor. The actual packet
transmission is handled by the read_packet() function,
which receives the probe from the neighbor. */
turn_radio_on_for_neighbor(&hdr.receiver, i);
}
} else {
printf("i == NULL\n");
mac_call_sent_callback(sent, ptr, MAC_TX_ERR, 0);
}
}
}
/*---------------------------------------------------------------------------*/
static int
plb_send_data(mac_callback_t sent, void *ptr)
{
PRINTF("plb_send_data\n");
int ret; //what is it? JJH
int last_sent_ok = 0;
int acked;
int temp=0;
acked = 0;
if(packetbuf_attr(PACKETBUF_ATTR_PACKET_TYPE)==0) //if packet_type ==0, DATA JJH_START
{
plb_send_strobe(packetbuf_addr(PACKETBUF_ADDR_NEXT),&acked,PREAMBLE);
if(acked==1)
{
PRINTF("plb_send_data DATA_PREAMBLE_ACKED!\n");
packetbuf_clear();
packetbuf_copyfrom(dataptr_temp,temp_len);
if (plb_create_header(packetbuf_addr(PACKETBUF_ADDR_NEXT),DATA) < 0)
{
PRINTF("ERROR: plb_create_header ");
return -1; //ERROR case : -1
}
// hold_time(INTER_PACKET_INTERVAL * 5000); //future
radio_on();
PRINTF("plb_send_data send DATA packet\n");
print_packet(packetbuf_hdrptr(), packetbuf_totlen());
if(NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen())!=RADIO_TX_OK)
{
PRINTF("plb_send_data DATA error!\n");
return -1; //ERROR case
ret = MAC_TX_ERR;
}
acked=plb_wait_data_ack(DATA); //just once?
if(acked==1) //data ack received
{
PRINTF("plb_send_data DATA_ACKED!\n");
last_sent_ok=1;
ret=MAC_TX_OK;
}
else if(!acked)
{
PRINTF("plb_send_data DATA error: no ack!\n");
ret=MAC_TX_ERR;
}
//sent connect
mac_call_sent_callback(sent, ptr, ret, 1);
radio_off();
packetbuf_clear(); // add kdw
return last_sent_ok;
}
else if(acked==2)//if receive preamble ack data
{
PRINTF("PREAMBLE ACK DATA RECEIVED!\n");
}
else//do not receive any ack, do nothing
{
PRINTF("DO NOT RECEIVED PREAMBLE ACK : error!!!\n");
}
}//JJH_END
return 0;
}
/*---------------------------------------------------------------------------*/
static void
qsend_list(mac_callback_t sent, void *ptr, struct rdc_buf_list *buf_list)
{
struct rdc_buf_list *curr;
struct rdc_buf_list *next;
int ret;
int is_receiver_awake;
if(buf_list == NULL) {
return;
}
/* Do not send during reception of a burst */
if(we_are_receiving_burst) {
/* Prepare the packetbuf for callback */
queuebuf_to_packetbuf(buf_list->buf);
/* Return COLLISION so the MAC may try again later */
mac_call_sent_callback(sent, ptr, MAC_TX_COLLISION, 1);
return;
}
/* Create and secure frames in advance */
curr = buf_list;
do {
next = list_item_next(curr);
queuebuf_to_packetbuf(curr->buf);
if(!packetbuf_attr(PACKETBUF_ATTR_IS_CREATED_AND_SECURED)) {
/* create and secure this frame */
if(next != NULL) {
packetbuf_set_attr(PACKETBUF_ATTR_PENDING, 1);
}
packetbuf_set_attr(PACKETBUF_ATTR_MAC_ACK, 1);
if(NETSTACK_FRAMER.create_and_secure() < 0) {
PRINTF("contikimac: framer failed\n");
mac_call_sent_callback(sent, ptr, MAC_TX_ERR_FATAL, 1);
return;
}
packetbuf_set_attr(PACKETBUF_ATTR_IS_CREATED_AND_SECURED, 1);
queuebuf_update_from_packetbuf(curr->buf);
}
curr = next;
} while(next != NULL);
/* The receiver needs to be awaken before we send */
is_receiver_awake = 0;
curr = buf_list;
do { /* A loop sending a burst of packets from buf_list */
next = list_item_next(curr);
/* Prepare the packetbuf */
queuebuf_to_packetbuf(curr->buf);
/* Send the current packet */
ret = send_packet(sent, ptr, curr, is_receiver_awake);
if(ret != MAC_TX_DEFERRED) {
mac_call_sent_callback(sent, ptr, ret, 1);
}
if(ret == MAC_TX_OK) {
if(next != NULL) {
/* We're in a burst, no need to wake the receiver up again */
is_receiver_awake = 1;
curr = next;
}
} else {
/* The transmission failed, we stop the burst */
next = NULL;
}
} while((next != NULL) && packetbuf_attr(PACKETBUF_ATTR_PENDING));
}
/*---------------------------------------------------------------------------*/
static void
packet_sent(void *ptr, int status, int num_transmissions)
{
struct neighbor_queue *n;
struct rdc_buf_list *q;
n = ptr;
if(n == NULL) {
return;
}
/* Find out what packet this callback refers to */
for(q = list_head(n->queued_packet_list);
q != NULL; q = list_item_next(q)) {
#if CETIC_6LBR_MULTI_RADIO
if(queuebuf_attr(q->buf, PACKETBUF_ATTR_MAC_SEQNO) ==
packetbuf_attr(PACKETBUF_ATTR_MAC_SEQNO) &&
(q->ptr == NULL ||
((struct qbuf_metadata *)q->ptr)->ifindex == multi_radio_input_ifindex)) {
#else
if(queuebuf_attr(q->buf, PACKETBUF_ATTR_MAC_SEQNO) ==
packetbuf_attr(PACKETBUF_ATTR_MAC_SEQNO)) {
#endif
break;
}
}
if(q == NULL) {
PRINTF("csma: seqno %d not found\n",
packetbuf_attr(PACKETBUF_ATTR_MAC_SEQNO));
return;
} else if(q->ptr == NULL) {
PRINTF("csma: no metadata\n");
return;
}
switch(status) {
case MAC_TX_OK:
tx_ok(q, n, num_transmissions);
break;
case MAC_TX_NOACK:
noack(q, n, num_transmissions);
break;
case MAC_TX_COLLISION:
collision(q, n, num_transmissions);
break;
case MAC_TX_DEFERRED:
break;
default:
tx_done(status, q, n);
break;
}
}
/*---------------------------------------------------------------------------*/
static void
send_packet(mac_callback_t sent, void *ptr)
{
struct rdc_buf_list *q;
struct neighbor_queue *n;
const linkaddr_t *addr = packetbuf_addr(PACKETBUF_ADDR_RECEIVER);
/* Look for the neighbor entry */
n = neighbor_queue_from_addr(addr);
if(n == NULL) {
/* Allocate a new neighbor entry */
n = memb_alloc(&neighbor_memb);
if(n != NULL) {
/* Init neighbor entry */
linkaddr_copy(&n->addr, addr);
n->transmissions = 0;
n->collisions = CSMA_MIN_BE;
/* Init packet list for this neighbor */
LIST_STRUCT_INIT(n, queued_packet_list);
/* Add neighbor to the list */
list_add(neighbor_list, n);
}
}
if(n != NULL) {
/* Add packet to the neighbor's queue */
if(list_length(n->queued_packet_list) < CSMA_MAX_PACKET_PER_NEIGHBOR) {
q = memb_alloc(&packet_memb);
if(q != NULL) {
q->ptr = memb_alloc(&metadata_memb);
if(q->ptr != NULL) {
q->buf = queuebuf_new_from_packetbuf();
if(q->buf != NULL) {
struct qbuf_metadata *metadata = (struct qbuf_metadata *)q->ptr;
/* Neighbor and packet successfully allocated */
if(packetbuf_attr(PACKETBUF_ATTR_MAX_MAC_TRANSMISSIONS) == 0) {
/* Use default configuration for max transmissions */
metadata->max_transmissions = CSMA_MAX_MAX_FRAME_RETRIES + 1;
} else {
metadata->max_transmissions =
packetbuf_attr(PACKETBUF_ATTR_MAX_MAC_TRANSMISSIONS);
}
metadata->sent = sent;
metadata->cptr = ptr;
#if CETIC_6LBR_MULTI_RADIO
metadata->ifindex = multi_radio_output_ifindex;
#endif
#if PACKETBUF_WITH_PACKET_TYPE
if(packetbuf_attr(PACKETBUF_ATTR_PACKET_TYPE) ==
PACKETBUF_ATTR_PACKET_TYPE_ACK) {
list_push(n->queued_packet_list, q);
} else
#endif
{
list_add(n->queued_packet_list, q);
}
PRINTF("csma: send_packet, queue length %d, free packets %d\n",
list_length(n->queued_packet_list), memb_numfree(&packet_memb));
/* If q is the first packet in the neighbor's queue, send asap */
if(list_head(n->queued_packet_list) == q) {
schedule_transmission(n);
}
return;
}
memb_free(&metadata_memb, q->ptr);
PRINTF("csma: could not allocate queuebuf, dropping packet\n");
}
memb_free(&packet_memb, q);
PRINTF("csma: could not allocate queuebuf, dropping packet\n");
}
/* The packet allocation failed. Remove and free neighbor entry if empty. */
if(list_length(n->queued_packet_list) == 0) {
list_remove(neighbor_list, n);
memb_free(&neighbor_memb, n);
}
} else {
PRINTF("csma: Neighbor queue full\n");
}
PRINTF("csma: could not allocate packet, dropping packet\n");
csma_packet_overflow++;
} else {
PRINTF("csma: could not allocate neighbor, dropping packet\n");
csma_neighbor_overflow++;
}
mac_call_sent_callback(sent, ptr, MAC_TX_ERR, 1);
}
/*---------------------------------------------------------------------------*/
static void
input_packet(void)
{
csma_received_packets++;
NETSTACK_LLSEC.input();
}
/* Function send for TSCH-MAC, puts the packet in packetbuf in the MAC queue */
static void
send_packet(mac_callback_t sent, void *ptr)
{
int ret = MAC_TX_DEFERRED;
int packet_count_before;
int hdr_len = 0;
const linkaddr_t *addr = packetbuf_addr(PACKETBUF_ADDR_RECEIVER);
if(!tsch_is_associated) {
if(!tsch_is_initialized) {
PRINTF("TSCH:! not initialized (see earlier logs), drop outgoing packet\n");
} else {
PRINTF("TSCH:! not associated, drop outgoing packet\n");
}
ret = MAC_TX_ERR;
mac_call_sent_callback(sent, ptr, ret, 1);
return;
}
/* PACKETBUF_ATTR_MAC_SEQNO cannot be zero, due to a pecuilarity
in framer-802154.c. */
if(++tsch_packet_seqno == 0) {
tsch_packet_seqno++;
}
/* Ask for ACK if we are sending anything other than broadcast */
if(!linkaddr_cmp(addr, &linkaddr_null)) {
packetbuf_set_attr(PACKETBUF_ATTR_MAC_ACK, 1);
} else {
/* Broadcast packets shall be added to broadcast queue
* The broadcast address in Contiki is linkaddr_null which is equal
* to tsch_eb_address */
addr = &tsch_broadcast_address;
}
packetbuf_set_attr(PACKETBUF_ATTR_FRAME_TYPE, FRAME802154_DATAFRAME);
packetbuf_set_attr(PACKETBUF_ATTR_MAC_SEQNO, tsch_packet_seqno);
#if TSCH_SECURITY_ENABLED
if(tsch_is_pan_secured) {
/* Set security level, key id and index */
packetbuf_set_attr(PACKETBUF_ATTR_SECURITY_LEVEL, TSCH_SECURITY_KEY_SEC_LEVEL_OTHER);
packetbuf_set_attr(PACKETBUF_ATTR_KEY_ID_MODE, FRAME802154_1_BYTE_KEY_ID_MODE); /* Use 1-byte key index */
packetbuf_set_attr(PACKETBUF_ATTR_KEY_INDEX, TSCH_SECURITY_KEY_INDEX_OTHER);
}
#endif /* TSCH_SECURITY_ENABLED */
packet_count_before = tsch_queue_packet_count(addr);
if((hdr_len = NETSTACK_FRAMER.create()) < 0) {
PRINTF("TSCH:! can't send packet due to framer error\n");
ret = MAC_TX_ERR;
} else {
struct tsch_packet *p;
/* Enqueue packet */
p = tsch_queue_add_packet(addr, sent, ptr);
if(p == NULL) {
PRINTF("TSCH:! can't send packet !tsch_queue_add_packet\n");
ret = MAC_TX_ERR;
} else {
p->header_len = hdr_len;
PRINTF("TSCH: send packet to %u with seqno %u, queue %u %u, len %u %u\n",
TSCH_LOG_ID_FROM_LINKADDR(addr), tsch_packet_seqno,
packet_count_before,
tsch_queue_packet_count(addr),
p->header_len,
queuebuf_datalen(p->qb));
}
}
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 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);
}
}
