static void _tx_management_stopped(gnrc_netif_t *netif)
{
/* If there is packet remaining for retransmission,
* retransmit it (i.e., the retransmission scheme of LWMAC). */
if (netif->mac.tx.packet != NULL) {
LOG_WARNING("WARNING: [LWMAC] TX %d times retry\n",
netif->mac.tx.tx_retry_count);
netif->mac.tx.state = GNRC_LWMAC_TX_STATE_INIT;
netif->mac.tx.wr_sent = 0;
gnrc_lwmac_tx_update(netif);
}
else {
gnrc_pktsnip_t *pkt;
if ((pkt = gnrc_priority_pktqueue_pop(
&netif->mac.tx.current_neighbor->queue))) {
netif->mac.tx.tx_retry_count = 0;
gnrc_lwmac_tx_start(netif, pkt, netif->mac.tx.current_neighbor);
gnrc_lwmac_tx_update(netif);
}
else {
/* Shouldn't happen, but never observed this case */
lwmac_set_state(netif, GNRC_LWMAC_SLEEPING);
}
}
}
bool gnrc_gomach_find_next_tx_neighbor(gnrc_netif_t *netif)
{
assert(netif != NULL);
int next = -1;
/* If current neighbor pointer is not NULL, it means we have pending packet from last
* t2u or t2k or bcast to send. In this case, return immediately. */
if (netif->mac.tx.current_neighbor != NULL) {
return true;
}
/* First check whether we have broadcast packet to send. */
if (gnrc_priority_pktqueue_length(&netif->mac.tx.neighbors[0].queue) > 0) {
next = 0;
}
else {
/* Find the next neighbor to send data packet to. */
/* Don't always start checking with ID 0, take turns to check every neighbor's queue,
* thus to be more fair. */
uint8_t j = netif->mac.tx.last_tx_neighbor_id + 1;
if (j >= GNRC_MAC_NEIGHBOR_COUNT) {
j = 1;
}
for (uint8_t i = 1; i < GNRC_MAC_NEIGHBOR_COUNT; i++) {
if (gnrc_priority_pktqueue_length(&netif->mac.tx.neighbors[j].queue) > 0) {
netif->mac.tx.last_tx_neighbor_id = j;
next = (int) j;
break;
}
else {
j++;
if (j >= GNRC_MAC_NEIGHBOR_COUNT) {
j = 1;
}
}
}
}
if (next >= 0) {
gnrc_pktsnip_t *pkt = gnrc_priority_pktqueue_pop(&netif->mac.tx.neighbors[next].queue);
if (pkt != NULL) {
netif->mac.tx.packet = pkt;
netif->mac.tx.current_neighbor = &netif->mac.tx.neighbors[next];
netif->mac.tx.tx_seq = 0;
netif->mac.tx.t2u_retry_counter = 0;
return true;
}
else {
return false;
}
}
return false;
}
static uint8_t _packet_process_in_wait_for_wr(gnrc_netdev_t *gnrc_netdev)
{
uint8_t rx_info = 0;
gnrc_pktsnip_t *pkt;
assert(gnrc_netdev != NULL);
while ((pkt = gnrc_priority_pktqueue_pop(&gnrc_netdev->rx.queue)) != NULL) {
LOG_DEBUG("[LWMAC-rx] Inspecting pkt @ %p\n", pkt);
/* Parse packet */
gnrc_lwmac_packet_info_t info;
if (_gnrc_lwmac_parse_packet(pkt, &info) != 0) {
LOG_DEBUG("[LWMAC-rx] Packet could not be parsed\n");
gnrc_pktbuf_release(pkt);
continue;
}
if (info.header->type == GNRC_LWMAC_FRAMETYPE_BROADCAST) {
_gnrc_lwmac_dispatch_defer(gnrc_netdev->rx.dispatch_buffer, pkt);
gnrc_mac_dispatch(&gnrc_netdev->rx);
rx_info |= GNRC_LWMAC_RX_FOUND_BROADCAST;
/* quit listening period to avoid receiving duplicate broadcast packets */
gnrc_netdev_lwmac_set_quit_rx(gnrc_netdev, true);
/* quit TX in this cycle to avoid collisions with broadcast packets */
gnrc_netdev_lwmac_set_quit_tx(gnrc_netdev, true);
break;
}
if (info.header->type != GNRC_LWMAC_FRAMETYPE_WR) {
LOG_DEBUG("[LWMAC-rx] Packet is not WR: 0x%02x\n", info.header->type);
gnrc_pktbuf_release(pkt);
continue;
}
/* No need to keep pkt anymore */
gnrc_pktbuf_release(pkt);
if (!(memcmp(&info.dst_addr.addr, &gnrc_netdev->l2_addr,
gnrc_netdev->l2_addr_len) == 0)) {
LOG_DEBUG("[LWMAC-rx] Packet is WR but not for us\n");
/* quit TX in this cycle to avoid collisions with other senders, since
* found ongoing WR (preamble) stream */
gnrc_netdev_lwmac_set_quit_tx(gnrc_netdev, true);
continue;
}
/* If reach here, the node gets a WR for itself. */
/* Save source address for later addressing */
gnrc_netdev->rx.l2_addr = info.src_addr;
rx_info |= GNRC_LWMAC_RX_FOUND_WR;
break;
}
return rx_info;
}
void gnrc_gomach_process_pkt_in_wait_preamble_ack(gnrc_netif_t *netif)
{
assert(netif != NULL);
gnrc_pktsnip_t *pkt;
gnrc_gomach_packet_info_t receive_packet_info;
while ((pkt = gnrc_priority_pktqueue_pop(&netif->mac.rx.queue)) != NULL) {
/* Parse the received packet. */
int res = _parse_packet(netif, pkt, &receive_packet_info);
if (res != 0) {
LOG_DEBUG("[GOMACH] t2u: Packet could not be parsed: %i\n", res);
gnrc_pktbuf_release(pkt);
continue;
}
switch (receive_packet_info.header->type) {
case GNRC_GOMACH_FRAME_PREAMBLE: {
_wait_preamble_ack_preamble(netif, pkt);
break;
}
case GNRC_GOMACH_FRAME_PREAMBLE_ACK: {
if (!_wait_preamble_ack_preambleack(netif, &receive_packet_info, pkt)) {
return;
}
break;
}
case GNRC_GOMACH_FRAME_DATA: {
if (!_wait_preamble_ack_data(netif, &receive_packet_info, pkt)) {
return;
}
break;
}
case GNRC_GOMACH_FRAME_BROADCAST: {
_wait_preamble_ack_bcast(netif, pkt);
break;
}
default: {
gnrc_pktbuf_release(pkt);
break;
}
}
}
}
void gnrc_gomach_packet_process_in_vtdma(gnrc_netif_t *netif)
{
assert(netif != NULL);
gnrc_pktsnip_t *pkt;
gnrc_gomach_packet_info_t receive_packet_info;
while ((pkt = gnrc_priority_pktqueue_pop(&netif->mac.rx.queue)) != NULL) {
/* Parse the received packet. */
int res = _parse_packet(netif, pkt, &receive_packet_info);
if (res != 0) {
LOG_DEBUG("[GOMACH] vtdma: Packet could not be parsed: %i\n", res);
gnrc_pktbuf_release(pkt);
continue;
}
switch (receive_packet_info.header->type) {
case GNRC_GOMACH_FRAME_DATA: {
gnrc_gomach_indicator_update(netif, pkt, &receive_packet_info);
if ((gnrc_gomach_check_duplicate(netif, &receive_packet_info))) {
gnrc_pktbuf_release(pkt);
LOG_DEBUG("[GOMACH] vtdma: received a duplicate packet.\n");
return;
}
gnrc_gomach_dispatch_defer(netif->mac.rx.dispatch_buffer, pkt);
gnrc_mac_dispatch(&netif->mac.rx);
break;
}
default: {
gnrc_pktbuf_release(pkt);
break;
}
}
}
}
static uint8_t _packet_process_in_wait_for_wa(gnrc_netif_t *netif)
{
assert(netif != NULL);
uint8_t tx_info = 0;
gnrc_pktsnip_t *pkt;
bool found_wa = false;
bool postponed = false;
bool from_expected_destination = false;
while ((pkt = gnrc_priority_pktqueue_pop(&netif->mac.rx.queue)) != NULL) {
LOG_DEBUG("[LWMAC-tx] Inspecting pkt @ %p\n", pkt);
/* Parse packet */
gnrc_lwmac_packet_info_t info;
int ret = _gnrc_lwmac_parse_packet(pkt, &info);
if (ret != 0) {
LOG_DEBUG("[LWMAC-tx] Packet could not be parsed: %i\n", ret);
gnrc_pktbuf_release(pkt);
continue;
}
if (memcmp(&info.src_addr.addr, &netif->mac.tx.current_neighbor->l2_addr,
netif->mac.tx.current_neighbor->l2_addr_len) == 0) {
from_expected_destination = true;
}
if (info.header->type == GNRC_LWMAC_FRAMETYPE_BROADCAST) {
_gnrc_lwmac_dispatch_defer(netif->mac.rx.dispatch_buffer, pkt);
gnrc_mac_dispatch(&netif->mac.rx);
/* Drop pointer to it can't get released */
pkt = NULL;
continue;
}
/* Check if destination is talking to another node. It will sleep
* after a finished transaction so there's no point in trying any
* further now. */
if (!(memcmp(&info.dst_addr.addr, &netif->l2addr,
netif->l2addr_len) == 0) && from_expected_destination) {
if (!gnrc_mac_queue_tx_packet(&netif->mac.tx, 0, netif->mac.tx.packet)) {
gnrc_pktbuf_release(netif->mac.tx.packet);
LOG_WARNING("WARNING: [LWMAC-tx] TX queue full, drop packet\n");
}
/* drop pointer so it wont be free'd */
netif->mac.tx.packet = NULL;
postponed = true;
gnrc_pktbuf_release(pkt);
break;
}
/* if found anther node is also trying to send data,
* quit this cycle for collision avoidance. */
if (info.header->type == GNRC_LWMAC_FRAMETYPE_WR) {
if (!gnrc_mac_queue_tx_packet(&netif->mac.tx, 0, netif->mac.tx.packet)) {
gnrc_pktbuf_release(netif->mac.tx.packet);
LOG_WARNING("WARNING: [LWMAC-tx] TX queue full, drop packet\n");
}
/* drop pointer so it wont be free'd */
netif->mac.tx.packet = NULL;
postponed = true;
gnrc_pktbuf_release(pkt);
break;
}
if (info.header->type != GNRC_LWMAC_FRAMETYPE_WA) {
LOG_DEBUG("[LWMAC-tx] Packet is not WA: 0x%02x\n", info.header->type);
gnrc_pktbuf_release(pkt);
continue;
}
if (from_expected_destination) {
/* calculate the phase of the receiver based on WA */
netif->mac.tx.timestamp = _gnrc_lwmac_phase_now();
gnrc_lwmac_frame_wa_t *wa_hdr;
wa_hdr = (gnrc_pktsnip_search_type(pkt, GNRC_NETTYPE_LWMAC))->data;
if (netif->mac.tx.timestamp >= wa_hdr->current_phase) {
netif->mac.tx.timestamp = netif->mac.tx.timestamp -
wa_hdr->current_phase;
}
else {
netif->mac.tx.timestamp += RTT_US_TO_TICKS(GNRC_LWMAC_WAKEUP_INTERVAL_US);
netif->mac.tx.timestamp -= wa_hdr->current_phase;
}
uint32_t own_phase;
own_phase = _gnrc_lwmac_ticks_to_phase(netif->mac.prot.lwmac.last_wakeup);
if (own_phase >= netif->mac.tx.timestamp) {
own_phase = own_phase - netif->mac.tx.timestamp;
}
else {
own_phase = netif->mac.tx.timestamp - own_phase;
}
if ((own_phase < RTT_US_TO_TICKS((3 * GNRC_LWMAC_WAKEUP_DURATION_US / 2))) ||
(own_phase > RTT_US_TO_TICKS(GNRC_LWMAC_WAKEUP_INTERVAL_US -
(3 * GNRC_LWMAC_WAKEUP_DURATION_US / 2)))) {
gnrc_lwmac_set_phase_backoff(netif, true);
LOG_WARNING("WARNING: [LWMAC-tx] phase close\n");
}
}
/* No need to keep pkt anymore */
gnrc_pktbuf_release(pkt);
if (!from_expected_destination) {
LOG_DEBUG("[LWMAC-tx] Packet is not from expected destination\n");
break;
}
/* All checks passed so this must be a valid WA */
gnrc_lwmac_clear_timeout(netif, GNRC_LWMAC_TIMEOUT_WR);
found_wa = true;
break;
}
if (postponed) {
LOG_INFO("[LWMAC-tx] Destination is talking to another node, postpone\n");
tx_info |= GNRC_LWMAC_TX_FAIL;
return tx_info;
}
if (!found_wa) {
LOG_DEBUG("[LWMAC-tx] No WA yet\n");
return tx_info;
}
/* Save newly calculated phase for destination */
netif->mac.tx.current_neighbor->phase = netif->mac.tx.timestamp;
LOG_INFO("[LWMAC-tx] New phase: %" PRIu32 "\n", netif->mac.tx.timestamp);
/* We've got our WA, so discard the rest, TODO: no flushing */
gnrc_priority_pktqueue_flush(&netif->mac.rx.queue);
tx_info |= GNRC_LWMAC_TX_SUCCESS;
return tx_info;
}
void gnrc_gomach_packet_process_in_wait_beacon(gnrc_netif_t *netif)
{
assert(netif != NULL);
gnrc_pktsnip_t *pkt;
gnrc_gomach_packet_info_t receive_packet_info;
while ((pkt = gnrc_priority_pktqueue_pop(&netif->mac.rx.queue)) != NULL) {
/* Parse the received packet. */
int res = _parse_packet(netif, pkt, &receive_packet_info);
if (res != 0) {
LOG_DEBUG("[GOMACH] t2k: Packet could not be parsed: %i\n", res);
gnrc_pktbuf_release(pkt);
continue;
}
switch (receive_packet_info.header->type) {
case GNRC_GOMACH_FRAME_BEACON: {
if (memcmp(&netif->mac.tx.current_neighbor->l2_addr,
&receive_packet_info.src_addr.addr,
netif->mac.tx.current_neighbor->l2_addr_len) == 0) {
gnrc_gomach_clear_timeout(netif, GNRC_GOMACH_TIMEOUT_WAIT_BEACON);
gnrc_gomach_beacon_process(netif, pkt);
}
gnrc_pktbuf_release(pkt);
break;
}
case GNRC_GOMACH_FRAME_PREAMBLE: {
/* Release preamble packet no matter the preamble is for it or not,
* and quit the t2k procedure. */
gnrc_gomach_set_quit_cycle(netif, true);
gnrc_pktbuf_release(pkt);
break;
}
case GNRC_GOMACH_FRAME_DATA: {
/* It is unlikely that we will received a data for us here.
* This means the device' CP is close with its destination's. */
if (memcmp(&netif->l2addr, &receive_packet_info.dst_addr.addr,
netif->l2addr_len) == 0) {
gnrc_gomach_indicator_update(netif, pkt, &receive_packet_info);
if ((gnrc_gomach_check_duplicate(netif, &receive_packet_info))) {
gnrc_pktbuf_release(pkt);
LOG_DEBUG("[GOMACH]: received a duplicate packet.\n");
return;
}
gnrc_gomach_dispatch_defer(netif->mac.rx.dispatch_buffer, pkt);
gnrc_mac_dispatch(&netif->mac.rx);
}
else {
gnrc_pktbuf_release(pkt);
}
break;
}
case GNRC_GOMACH_FRAME_BROADCAST: {
gnrc_gomach_set_quit_cycle(netif, true);
gnrc_pktbuf_release(pkt);
break;
}
default: {
gnrc_pktbuf_release(pkt);
break;
}
}
}
}
static uint8_t _packet_process_in_wait_for_data(gnrc_netdev_t *gnrc_netdev)
{
uint8_t rx_info = 0;
gnrc_pktsnip_t *pkt;
assert(gnrc_netdev != NULL);
pkt = NULL;
while ((pkt = gnrc_priority_pktqueue_pop(&gnrc_netdev->rx.queue)) != NULL) {
LOG_DEBUG("[LWMAC-rx] Inspecting pkt @ %p\n", pkt);
/* Parse packet */
gnrc_lwmac_packet_info_t info;
if (_gnrc_lwmac_parse_packet(pkt, &info) != 0) {
LOG_DEBUG("[LWMAC-rx] Packet could not be parsed\n");
gnrc_pktbuf_release(pkt);
continue;
}
if (info.header->type == GNRC_LWMAC_FRAMETYPE_BROADCAST) {
_gnrc_lwmac_dispatch_defer(gnrc_netdev->rx.dispatch_buffer, pkt);
gnrc_mac_dispatch(&gnrc_netdev->rx);
/* quit listening period to avoid receiving duplicate broadcast packets */
gnrc_netdev_lwmac_set_quit_rx(gnrc_netdev, true);
continue;
}
if (!(memcmp(&info.src_addr.addr, &gnrc_netdev->rx.l2_addr.addr,
gnrc_netdev->rx.l2_addr.len) == 0)) {
LOG_DEBUG("[LWMAC-rx] Packet is not from destination\n");
gnrc_pktbuf_release(pkt);
/* Reset timeout to wait for the data packet */
gnrc_lwmac_clear_timeout(gnrc_netdev, GNRC_LWMAC_TIMEOUT_DATA);
gnrc_lwmac_set_timeout(gnrc_netdev, GNRC_LWMAC_TIMEOUT_DATA, GNRC_LWMAC_DATA_DELAY_US);
continue;
}
if (!(memcmp(&info.dst_addr.addr, &gnrc_netdev->l2_addr,
gnrc_netdev->l2_addr_len) == 0)) {
LOG_DEBUG("[LWMAC-rx] Packet is not for us\n");
gnrc_pktbuf_release(pkt);
/* Reset timeout to wait for the data packet */
gnrc_lwmac_clear_timeout(gnrc_netdev, GNRC_LWMAC_TIMEOUT_DATA);
gnrc_lwmac_set_timeout(gnrc_netdev, GNRC_LWMAC_TIMEOUT_DATA, GNRC_LWMAC_DATA_DELAY_US);
continue;
}
/* Sender maybe didn't get the WA */
if (info.header->type == GNRC_LWMAC_FRAMETYPE_WR) {
LOG_DEBUG("[LWMAC-rx] Found a WR while waiting for DATA\n");
gnrc_lwmac_clear_timeout(gnrc_netdev, GNRC_LWMAC_TIMEOUT_DATA);
rx_info |= GNRC_LWMAC_RX_FOUND_WR;
/* Push WR back to rx queue */
gnrc_mac_queue_rx_packet(&gnrc_netdev->rx, 0, pkt);
break;
}
switch (info.header->type) {
case GNRC_LWMAC_FRAMETYPE_DATA:
case GNRC_LWMAC_FRAMETYPE_DATA_PENDING: {
/* Receiver gets the data packet */
_gnrc_lwmac_dispatch_defer(gnrc_netdev->rx.dispatch_buffer, pkt);
gnrc_mac_dispatch(&gnrc_netdev->rx);
LOG_DEBUG("[LWMAC-rx] Found DATA!\n");
gnrc_lwmac_clear_timeout(gnrc_netdev, GNRC_LWMAC_TIMEOUT_DATA);
rx_info |= GNRC_LWMAC_RX_FOUND_DATA;
return rx_info;
}
default: {
gnrc_pktbuf_release(pkt);
}
}
}
return rx_info;
}
