gomach_internal.h

Go to the documentation of this file.

/*
 * Copyright (C) 2017 INRIA
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */
 
#ifndef GOMACH_INTERNAL_H
#define GOMACH_INTERNAL_H
 
#include <stdint.h>
 
#include "periph/rtt.h"
#include "net/gnrc/netif.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define GNRC_GOMACH_INFO_TX_FINISHED                     (0x0008U)
 
#define GNRC_GOMACH_INFO_PKT_RECEIVED                    (0x0010U)
 
#define GNRC_GOMACH_INTERNAL_INFO_ND_UPDATE              (0x0001U)
 
#define GNRC_GOMACH_INTERNAL_INFO_QUIT_CYCLE             (0x0002U)
 
#define GNRC_GOMACH_INTERNAL_INFO_CP_END                 (0x0004U)
 
#define GNRC_GOMACH_INTERNAL_INFO_VTDMA_END              (0x0008U)
 
#define GNRC_GOMACH_INTERNAL_INFO_UNINTD_PREAMBLE        (0x0010U)
 
#define GNRC_GOMACH_INTERNAL_INFO_GOT_PREAMBLE           (0x0020U)
 
#define GNRC_GOMACH_INTERNAL_INFO_DUTY_CYCLE_START       (0x0040U)
 
#define GNRC_GOMACH_INTERNAL_INFO_PHASE_BACKOFF          (0x0080U)
 
#define GNRC_GOMACH_INTERNAL_INFO_BEACON_FAIL            (0x0200U)
 
#define GNRC_GOMACH_INTERNAL_INFO_BUFFER_FULL            (0x0400U)
 
#define GNRC_GOMACH_INTERNAL_INFO_ENTER_NEW_CYCLE        (0x0800U)
 
#define GNRC_GOMACH_INTERNAL_INFO_GOT_PREAMBLEACK        (0x1000U)
 
#define GNRC_GOMACH_INTERNAL_INFO_ON_PUBCHAN_1           (0x2000U)
 
#define GNRC_GOMACH_INTERNAL_INFO_MAX_PREAM_INTERV       (0x4000U)
 
#define GNRC_GOMACH_INTERNAL_INFO_RADIO_IS_ON            (0x8000U)
 
static inline void gnrc_gomach_set_tx_finish(gnrc_netif_t *netif, bool tx_finish)
{
    if (tx_finish) {
        netif->mac.mac_info |= GNRC_GOMACH_INFO_TX_FINISHED;
    }
    else {
        netif->mac.mac_info &= ~GNRC_GOMACH_INFO_TX_FINISHED;
    }
}
 
static inline bool gnrc_gomach_get_tx_finish(gnrc_netif_t *netif)
{
    return (netif->mac.mac_info & GNRC_GOMACH_INFO_TX_FINISHED);
}
 
static inline void gnrc_gomach_set_pkt_received(gnrc_netif_t *netif, bool received)
{
    if (received) {
        netif->mac.mac_info |= GNRC_GOMACH_INFO_PKT_RECEIVED;
    }
    else {
        netif->mac.mac_info &= ~GNRC_GOMACH_INFO_PKT_RECEIVED;
    }
}
 
static inline bool gnrc_gomach_get_pkt_received(gnrc_netif_t *netif)
{
    return (netif->mac.mac_info & GNRC_GOMACH_INFO_PKT_RECEIVED);
}
 
static inline void gnrc_gomach_set_quit_cycle(gnrc_netif_t *netif, bool quit)
{
    if (quit) {
        netif->mac.prot.gomach.gomach_info |= GNRC_GOMACH_INTERNAL_INFO_QUIT_CYCLE;
    }
    else {
        netif->mac.prot.gomach.gomach_info &= ~GNRC_GOMACH_INTERNAL_INFO_QUIT_CYCLE;
    }
}
 
static inline bool gnrc_gomach_get_quit_cycle(gnrc_netif_t *netif)
{
    return (netif->mac.prot.gomach.gomach_info & GNRC_GOMACH_INTERNAL_INFO_QUIT_CYCLE);
}
 
static inline void gnrc_gomach_set_got_preamble(gnrc_netif_t *netif, bool got_preamble)
{
    if (got_preamble) {
        netif->mac.prot.gomach.gomach_info |= GNRC_GOMACH_INTERNAL_INFO_GOT_PREAMBLE;
    }
    else {
        netif->mac.prot.gomach.gomach_info &= ~GNRC_GOMACH_INTERNAL_INFO_GOT_PREAMBLE;
    }
}
 
static inline bool gnrc_gomach_get_got_preamble(gnrc_netif_t *netif)
{
    return (netif->mac.prot.gomach.gomach_info & GNRC_GOMACH_INTERNAL_INFO_GOT_PREAMBLE);
}
 
static inline void gnrc_gomach_set_cp_end(gnrc_netif_t *netif, bool cp_end)
{
    if (cp_end) {
        netif->mac.prot.gomach.gomach_info |= GNRC_GOMACH_INTERNAL_INFO_CP_END;
    }
    else {
        netif->mac.prot.gomach.gomach_info &= ~GNRC_GOMACH_INTERNAL_INFO_CP_END;
    }
}
 
static inline bool gnrc_gomach_get_cp_end(gnrc_netif_t *netif)
{
    return (netif->mac.prot.gomach.gomach_info & GNRC_GOMACH_INTERNAL_INFO_CP_END);
}
 
static inline void gnrc_gomach_set_vTDMA_end(gnrc_netif_t *netif, bool vtdma_end)
{
    if (vtdma_end) {
        netif->mac.prot.gomach.gomach_info |= GNRC_GOMACH_INTERNAL_INFO_VTDMA_END;
    }
    else {
        netif->mac.prot.gomach.gomach_info &= ~GNRC_GOMACH_INTERNAL_INFO_VTDMA_END;
    }
}
 
static inline bool gnrc_gomach_get_vTDMA_end(gnrc_netif_t *netif)
{
    return (netif->mac.prot.gomach.gomach_info & GNRC_GOMACH_INTERNAL_INFO_VTDMA_END);
}
 
static inline void gnrc_gomach_set_unintd_preamble(gnrc_netif_t *netif, bool uintd_preamble)
{
    if (uintd_preamble) {
        netif->mac.prot.gomach.gomach_info |= GNRC_GOMACH_INTERNAL_INFO_UNINTD_PREAMBLE;
    }
    else {
        netif->mac.prot.gomach.gomach_info &= ~GNRC_GOMACH_INTERNAL_INFO_UNINTD_PREAMBLE;
    }
}
 
static inline bool gnrc_gomach_get_unintd_preamble(gnrc_netif_t *netif)
{
    return (netif->mac.prot.gomach.gomach_info & GNRC_GOMACH_INTERNAL_INFO_UNINTD_PREAMBLE);
}
 
static inline void gnrc_gomach_set_update(gnrc_netif_t *netif, bool update)
{
    if (update) {
        netif->mac.prot.gomach.gomach_info |= GNRC_GOMACH_INTERNAL_INFO_ND_UPDATE;
    }
    else {
        netif->mac.prot.gomach.gomach_info &= ~GNRC_GOMACH_INTERNAL_INFO_ND_UPDATE;
    }
}
 
static inline bool gnrc_gomach_get_update(gnrc_netif_t *netif)
{
    return (netif->mac.prot.gomach.gomach_info & GNRC_GOMACH_INTERNAL_INFO_ND_UPDATE);
}
 
static inline void gnrc_gomach_set_duty_cycle_start(gnrc_netif_t *netif, bool start)
{
    if (start) {
        netif->mac.prot.gomach.gomach_info |= GNRC_GOMACH_INTERNAL_INFO_DUTY_CYCLE_START;
    }
    else {
        netif->mac.prot.gomach.gomach_info &= ~GNRC_GOMACH_INTERNAL_INFO_DUTY_CYCLE_START;
    }
}
 
static inline bool gnrc_gomach_get_duty_cycle_start(gnrc_netif_t *netif)
{
    return (netif->mac.prot.gomach.gomach_info & GNRC_GOMACH_INTERNAL_INFO_DUTY_CYCLE_START);
}
 
static inline void gnrc_gomach_set_phase_backoff(gnrc_netif_t *netif, bool backoff)
{
    if (backoff) {
        netif->mac.prot.gomach.gomach_info |= GNRC_GOMACH_INTERNAL_INFO_PHASE_BACKOFF;
    }
    else {
        netif->mac.prot.gomach.gomach_info &= ~GNRC_GOMACH_INTERNAL_INFO_PHASE_BACKOFF;
    }
}
 
static inline bool gnrc_gomach_get_phase_backoff(gnrc_netif_t *netif)
{
    return (netif->mac.prot.gomach.gomach_info & GNRC_GOMACH_INTERNAL_INFO_PHASE_BACKOFF);
}
 
static inline void gnrc_gomach_set_beacon_fail(gnrc_netif_t *netif, bool fail)
{
    if (fail) {
        netif->mac.prot.gomach.gomach_info |= GNRC_GOMACH_INTERNAL_INFO_BEACON_FAIL;
    }
    else {
        netif->mac.prot.gomach.gomach_info &= ~GNRC_GOMACH_INTERNAL_INFO_BEACON_FAIL;
    }
}
 
static inline bool gnrc_gomach_get_beacon_fail(gnrc_netif_t *netif)
{
    return (netif->mac.prot.gomach.gomach_info & GNRC_GOMACH_INTERNAL_INFO_BEACON_FAIL);
}
 
static inline void gnrc_gomach_set_buffer_full(gnrc_netif_t *netif, bool full)
{
    if (full) {
        netif->mac.prot.gomach.gomach_info |= GNRC_GOMACH_INTERNAL_INFO_BUFFER_FULL;
    }
    else {
        netif->mac.prot.gomach.gomach_info &= ~GNRC_GOMACH_INTERNAL_INFO_BUFFER_FULL;
    }
}
 
static inline bool gnrc_gomach_get_buffer_full(gnrc_netif_t *netif)
{
    return (netif->mac.prot.gomach.gomach_info & GNRC_GOMACH_INTERNAL_INFO_BUFFER_FULL);
}
 
static inline void gnrc_gomach_set_enter_new_cycle(gnrc_netif_t *netif, bool enter)
{
    if (enter) {
        netif->mac.prot.gomach.gomach_info |= GNRC_GOMACH_INTERNAL_INFO_ENTER_NEW_CYCLE;
    }
    else {
        netif->mac.prot.gomach.gomach_info &= ~GNRC_GOMACH_INTERNAL_INFO_ENTER_NEW_CYCLE;
    }
}
 
static inline bool gnrc_gomach_get_enter_new_cycle(gnrc_netif_t *netif)
{
    return (netif->mac.prot.gomach.gomach_info & GNRC_GOMACH_INTERNAL_INFO_ENTER_NEW_CYCLE);
}
 
static inline void gnrc_gomach_set_got_preamble_ack(gnrc_netif_t *netif, bool got)
{
    if (got) {
        netif->mac.prot.gomach.gomach_info |= GNRC_GOMACH_INTERNAL_INFO_GOT_PREAMBLEACK;
    }
    else {
        netif->mac.prot.gomach.gomach_info &= ~GNRC_GOMACH_INTERNAL_INFO_GOT_PREAMBLEACK;
    }
}
 
static inline bool gnrc_gomach_get_got_preamble_ack(gnrc_netif_t *netif)
{
    return (netif->mac.prot.gomach.gomach_info & GNRC_GOMACH_INTERNAL_INFO_GOT_PREAMBLEACK);
}
 
static inline void gnrc_gomach_set_on_pubchan_1(gnrc_netif_t *netif, bool on_pubchan_1)
{
    if (on_pubchan_1) {
        netif->mac.prot.gomach.gomach_info |= GNRC_GOMACH_INTERNAL_INFO_ON_PUBCHAN_1;
    }
    else {
        netif->mac.prot.gomach.gomach_info &= ~GNRC_GOMACH_INTERNAL_INFO_ON_PUBCHAN_1;
    }
}
 
static inline bool gnrc_gomach_get_on_pubchan_1(gnrc_netif_t *netif)
{
    return (netif->mac.prot.gomach.gomach_info & GNRC_GOMACH_INTERNAL_INFO_ON_PUBCHAN_1);
}
 
static inline void gnrc_gomach_set_max_pream_interv(gnrc_netif_t *netif, bool max)
{
    if (max) {
        netif->mac.prot.gomach.gomach_info |= GNRC_GOMACH_INTERNAL_INFO_MAX_PREAM_INTERV;
    }
    else {
        netif->mac.prot.gomach.gomach_info &= ~GNRC_GOMACH_INTERNAL_INFO_MAX_PREAM_INTERV;
    }
}
 
static inline bool gnrc_gomach_get_max_pream_interv(gnrc_netif_t *netif)
{
    return (netif->mac.prot.gomach.gomach_info & GNRC_GOMACH_INTERNAL_INFO_MAX_PREAM_INTERV);
}
 
uint64_t gnrc_gomach_phase_now(gnrc_netif_t *netif);
 
void gnrc_gomach_set_netdev_state(gnrc_netif_t *netif, netopt_state_t devstate);
 
static inline void gnrc_gomach_set_autoack(gnrc_netif_t *netif, netopt_enable_t autoack)
{
    assert(netif != NULL);
 
    netif->dev->driver->set(netif->dev,
                            NETOPT_AUTOACK,
                            &autoack,
                            sizeof(autoack));
}
 
static inline void gnrc_gomach_set_ack_req(gnrc_netif_t *netif, netopt_enable_t ack_req)
{
    assert(netif != NULL);
 
    netif->dev->driver->set(netif->dev,
                            NETOPT_ACK_REQ,
                            &ack_req,
                            sizeof(ack_req));
}
 
static inline netopt_state_t gnrc_gomach_get_netdev_state(gnrc_netif_t *netif)
{
    assert(netif != NULL);
 
    netopt_state_t state;
 
    if (0 < netif->dev->driver->get(netif->dev,
                                    NETOPT_STATE,
                                    &state,
                                    sizeof(state))) {
        return state;
    }
    return -ENOSYS;
}
 
static inline void gnrc_gomach_turn_channel(gnrc_netif_t *netif, uint16_t channel_num)
{
    assert(netif != NULL);
 
    netif->dev->driver->set(netif->dev,
                            NETOPT_CHANNEL,
                            &channel_num,
                            sizeof(channel_num));
}
 
int _gnrc_gomach_transmit(gnrc_netif_t *netif, gnrc_pktsnip_t *pkt);
 
bool gnrc_gomach_check_duplicate(gnrc_netif_t *netif, gnrc_gomach_packet_info_t *pa_info);
 
int gnrc_gomach_send(gnrc_netif_t *netif, gnrc_pktsnip_t *pkt, netopt_enable_t csma_enable);
 
int gnrc_gomach_send_preamble_ack(gnrc_netif_t *netif, gnrc_gomach_packet_info_t *info);
 
int gnrc_gomach_send_beacon(gnrc_netif_t *netif);
 
int gnrc_gomach_dispatch_defer(gnrc_pktsnip_t * buffer[], gnrc_pktsnip_t * pkt);
 
void gnrc_gomach_indicator_update(gnrc_netif_t *netif, gnrc_pktsnip_t *pkt,
                                  gnrc_gomach_packet_info_t *pa_info);
 
void gnrc_gomach_cp_packet_process(gnrc_netif_t *netif);
 
void gnrc_gomach_init_choose_subchannel(gnrc_netif_t *netif);
 
int gnrc_gomach_bcast_subchann_seq(gnrc_netif_t *netif, netopt_enable_t use_csma);
 
int gnrc_gomach_send_preamble(gnrc_netif_t *netif, netopt_enable_t csma_enable);
 
void gnrc_gomach_process_preamble_ack(gnrc_netif_t *netif, gnrc_pktsnip_t *pkt);
 
void gnrc_gomach_process_pkt_in_wait_preamble_ack(gnrc_netif_t *netif);
 
int gnrc_gomach_send_data(gnrc_netif_t *netif, netopt_enable_t csma_enable);
 
bool gnrc_gomach_find_next_tx_neighbor(gnrc_netif_t *netif);
 
void gnrc_gomach_beacon_process(gnrc_netif_t *netif, gnrc_pktsnip_t *pkt);
 
void gnrc_gomach_packet_process_in_wait_beacon(gnrc_netif_t *netif);
 
void gnrc_gomach_packet_process_in_vtdma(gnrc_netif_t *netif);
 
void gnrc_gomach_update_neighbor_phase(gnrc_netif_t *netif);
 
void gnrc_gomach_update_neighbor_pubchan(gnrc_netif_t *netif);
 
#ifdef __cplusplus
}
#endif
 
#endif /* GOMACH_INTERNAL_H */