rtsctsMac.c

Go to the documentation of this file.

#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>

#include "xparameters.h"
#include "xutil.h"
#include "ofdm_pktdetector_mimo_regMacros.h"
#include "warp_timer_regMacros.h"
#include "ofdm_txrx_mimo_regMacros.h"
#include "warpmac.h"
#include "warpphy.h"
#include "rtsctsMac.h"
#include "rtsctsTest.h"
#include "ascii_characters.h"


struct {
        Macframe rx;
        Macframe rts;
        Macframe cts;
        Macframe dat;
        Macframe ack;
        Macframe bcd;
} pkt;

enum {IDLE,BUSY};

enum {RTS=1,CTS=2,DAT=3,ACK=4,BCD=5,ETH=6};

struct {
        unsigned short slot;
        unsigned short SIFS;
        unsigned short DIFS;
        unsigned short EIFS;
        
        unsigned short header;
        unsigned short transmit[5];
        unsigned short timeout[5];
} delay;

unsigned int pktCtr[4][7];
enum {TX=0, RXGOOD=1, RXUNEXP=2, RXBAD=3, DROP=3};

struct {
        unsigned char antA[8];
        unsigned char antB[8];
        unsigned char half[8];
        unsigned char otherhalf[8];
        unsigned char alternating[8];
        unsigned char * current;
} csi = {
        .antA = {0, 0, 0, 0, 0, 0, 0, 0},
        .antB = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
        .half = {0,0,0,0,0xFF,0xFF,0xFF,0xFF},
        .otherhalf = {0xFF,0xFF,0xFF,0xFF,0,0,0,0},
        .alternating = {0x55,0x55,0x55,0x55,0x55,0x55,0x55,0x55},
};


const unsigned char modMasks[64] = {
        0x0,0xF,0xF,0xF,0xF,0xF,0xF,0x0, 0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF,
        0xF,0xF,0xF,0xF,0xF,0x0,0xF,0xF, 0xF,0xF,0xF,0x0,0x0,0x0,0x0,0x0,
        0x0,0x0,0x0,0x0,0x0,0x0,0xF,0xF, 0xF,0xF,0xF,0x0,0xF,0xF,0xF,0xF,
        0xF,0xF,0xF,0xF,0xF,0xF,0xF,0xF, 0xF,0x0,0xF,0xF,0xF,0xF,0xF,0xF};

const unsigned char modFlags[64] = {
        0,1,1,1,1,1,1,0, 1,1,1,1,1,1,1,1,
        1,1,1,1,1,0,1,1, 1,1,1,0,0,0,0,0,
        0,0,0,0,0,0,1,1, 1,1,1,0,1,1,1,1,
        1,1,1,1,1,1,1,1, 1,0,1,1,1,1,1,1};
        
struct {
        unsigned short rtsThreshold;
        unsigned char feedback_en;
        unsigned char mac;
        unsigned char chan;
        unsigned char currentAnt;
        unsigned char myID;
        unsigned char GPIOval;
        const unsigned char baseRate;
        const unsigned char fullRate;
        const unsigned char csiLength;
        
        struct {
                unsigned short rts;
                unsigned short dat;
        } maxResend;
        
        struct {
                unsigned char my[6];
                const unsigned char bc[6];
                const unsigned char net[4];
        } addr;
        
        struct {
                unsigned char addr[6];
        } routeTable[16];
        
} state = {
        .rtsThreshold = 0,
        .feedback_en = 0,
        .mac = IDLE,
        .chan = 14,
        .currentAnt = 0,
        .GPIOval = 0,
        .baseRate = QPSK,
        .fullRate = QPSK,
        .csiLength = 0,         // set to 8 when using feedback
        .maxResend.rts = 4,
        .maxResend.dat = 2,
        .addr.bc = {0xff,0xff,0xff,0xff,0xff,0xff},
        .addr.net = {10,0,0,0},
};



static inline unsigned int ceil_div_uint(unsigned int a, unsigned int b) {
        return (a+b-1)/b;
}


static inline void setCSMAIdleTime(unsigned int newTime) {
        ofdm_pktDetector_mimo_WriteReg_csma_difsPeriod(PKTDET_BASEADDR, newTime*80);
}


static inline void setTXModMasks(unsigned char * newCSI) {
        unsigned char modIndex, csiByte, csiMask, antAmask, antBmask;
        /*
        for(modIndex=0; modIndex<64; modIndex++) {
                csiByte = newCSI[modIndex/8];
                csiMask = ((csiByte >> (modIndex & 3)) & 1) * 0xF;
                antAmask = modMasks[modIndex] & ~csiMask;
                antBmask = modMasks[modIndex] & csiMask;

                XIo_Out32(XPAR_OFDM_TXRX_MIMO_PLBW_0_MEMMAP_TXMODULATION+(modIndex*sizeof(int)), antAmask);
                XIo_Out32(XPAR_OFDM_TXRX_MIMO_PLBW_0_MEMMAP_TXMODULATION+(modIndex*sizeof(int)+64), antBmask);
                
                //xil_printf("\n%02x\t%02x\t%02x\t%02x", csiByte, csiMask, antAmask, antBmask);
        }
        */
        
        for(modIndex=0; modIndex<64; modIndex++) {
                if(modFlags[modIndex]) {
                        csiByte = newCSI[modIndex/8];
                        if((csiByte >> (modIndex % 8)) & 1) {
                                XIo_Out32(XPAR_OFDM_TXRX_MIMO_PLBW_0_MEMMAP_TXMODULATION+(modIndex*sizeof(int)), 0);
                                XIo_Out32(XPAR_OFDM_TXRX_MIMO_PLBW_0_MEMMAP_TXMODULATION+((modIndex+64)*sizeof(int)), 0xF);
                        } else {
                                XIo_Out32(XPAR_OFDM_TXRX_MIMO_PLBW_0_MEMMAP_TXMODULATION+(modIndex*sizeof(int)), 0xF);
                                XIo_Out32(XPAR_OFDM_TXRX_MIMO_PLBW_0_MEMMAP_TXMODULATION+((modIndex+64)*sizeof(int)), 0);
                        }
                }
        }
        
        /*
        #define modset(i,j) \
        if(modFlags[modIndex]) { \
                if(csiByte & i) { \
                        XIo_Out32(XPAR_OFDM_TXRX_MIMO_PLBW_0_MEMMAP_TXMODULATION+((modIndex+j)*sizeof(int)), 0); \
                        XIo_Out32(XPAR_OFDM_TXRX_MIMO_PLBW_0_MEMMAP_TXMODULATION+((modIndex+j+64)*sizeof(int)), 0xF); \
                } else { \
                        XIo_Out32(XPAR_OFDM_TXRX_MIMO_PLBW_0_MEMMAP_TXMODULATION+((modIndex+j)*sizeof(int)), 0xF); \
                        XIo_Out32(XPAR_OFDM_TXRX_MIMO_PLBW_0_MEMMAP_TXMODULATION+((modIndex+j+64)*sizeof(int)), 0); \
                } \
        }
        for(modIndex=0; modIndex<64; modIndex+=8) {
                csiByte = newCSI[modIndex/8];
                modset(1,0)
                modset(2,1)
                modset(4,2)
                modset(8,3)
                modset(16,4)
                modset(32,5)
                modset(64,6)
                modset(128,7)
        }
        #undef modset
        */
}


void unlockRXantenna() {
        if(state.feedback_en) {
                warpphy_setSISOAntenna(state.currentAnt = 0);
                mimo_ofdmRx_setOptions(mimo_ofdmRx_getOptions() | SWITCHING_DIV_EN,
                        DEFAULT_INTERRUPTS);
        }
}


void lockRXantenna() {
        if(state.feedback_en) {
                mimo_ofdmRx_setOptions(mimo_ofdmRx_getOptions() & ~SWITCHING_DIV_EN,
                        DEFAULT_INTERRUPTS);
                unsigned int g = ofdm_AGC_GetGains();
                // choose ant. B if AGC gave it a lower gain, else choose ant. A
                state.currentAnt = (((g >> 8) & 0x7F) < (g & 0x7F)) ? 1 : 0;
                warpphy_setSISOAntenna(state.currentAnt);
        }
}


void loadCSI(unsigned char * newCSI) {
        extern Maccontrol controlStruct;
        if(state.csiLength > 0) {
                memcpy((unsigned char *)(warpphy_getBuffAddr(3) + NUM_HEADER_BYTES),
                        (unsigned char *)newCSI,
                        state.csiLength);
        }
}


void updateTimer(unsigned char type, unsigned int newTime) {
        extern Maccontrol controlStruct;        // used for tracking the backoff
        switch(type) {
        case TIMEOUT:
                if(!warp_timer_isActive(NAV)) {
                        // convert microseconds to timer clock cycles
                        newTime = (newTime + delay.slot) * 80;  // margin added for processing time
                        if(warp_timer_isActive(BACKOFF))
                                warp_timer_pause(BACKOFF);
                        warp_timer_setVal(TIMEOUT, newTime);
                        warp_timer_start(TIMEOUT);
                }
                break;
        case BACKOFF:
                state.mac = IDLE;
                newTime = randNum(controlStruct.currBackoff) * delay.slot * 80;
                if(!warp_timer_isActive(TIMEOUT) && !warp_timer_isActive(NAV)) {
                        if(warp_timer_isPaused(BACKOFF)) {
                                warp_timer_resume(BACKOFF);
                        } else {
                                warp_timer_setVal(BACKOFF, newTime);
                                warp_timer_start(BACKOFF);
                                if(controlStruct.currBackoff < controlStruct.maxBackoff)
                                        controlStruct.currBackoff++;
                        }
                } else {
                        warp_timer_stop(BACKOFF);
                        warp_timer_setVal(BACKOFF, newTime);
                        warp_timer_start(BACKOFF);
                        warp_timer_pause(BACKOFF);
                        if(controlStruct.currBackoff < controlStruct.maxBackoff)
                                controlStruct.currBackoff++;
                }
                break;
        case NAV:
                // convert microseconds to timer clock cycles
                newTime = newTime * 80;
                if(warp_timer_isActive(TIMEOUT))
                        warp_timer_stop(TIMEOUT);
                if(warp_timer_isActive(BACKOFF))
                        warp_timer_pause(BACKOFF);
                if(warp_timer_isActive(NAV)) {
                        warp_timer_pause(NAV);
                        if(warp_timer_timeLeft(NAV) < newTime) {
                                warp_timer_setVal(NAV, newTime);
                                warp_timer_start(NAV);
                        } else {
                                warp_timer_resume(NAV);
                        }
                } else {
                        warp_timer_setVal(NAV, newTime);
                        warp_timer_start(NAV);
                }
                
                break;
        }
}


int rtsmac_timer_callback(unsigned char unused) {
        extern unsigned char timerIntStatus;
        if(timerIntStatus & 2) {
                // backoff expired
                if(pkt.bcd.isNew)
                        sendBCD();
                else if(pkt.dat.isNew)
                        initTX();
        } else {
                // timeout or NAV expired
                //tvar[state.mac]++;
                updateTimer(BACKOFF, 0);
        }
        unlockRXantenna();
        return 0;
}


void dropPacket() {
        pkt.dat.isNew = 0;
        pkt.bcd.isNew = 0;
        state.mac = IDLE;
        pktCtr[DROP][ETH]++;
        warpmac_enableEthernet();
}


int rtsmac_emacRx_callback(Xuint32 length, char* payload) {
        UTime time;
        warpmac_disableEthernet();
        pktCtr[RXGOOD][ETH]++;
        
        if(*(unsigned char *)(payload+33)<16
                && *(unsigned char *)(payload+32)==state.addr.net[2]
                && *(unsigned char *)(payload+31)==state.addr.net[1]
                && *(unsigned char *)(payload+30)==state.addr.net[0]) {
                // complete the data packet header
                // enable RTS/CTS if length of packet > RTS threshold
                pkt.dat.header.reserved4 = (length > state.rtsThreshold) ? 0 : 1;
                pkt.dat.header.length = length;
                memcpy(pkt.dat.header.destAddr,
                        state.routeTable[*(unsigned char *)(payload+33)].addr,
                        6);
                pkt.dat.header.currReSend = 0;
                pkt.dat.isNew = 1;
                
                // calculate transmission time for data packet
                delay.transmit[DAT] = delay.header + 8*ceil_div_uint((length+4), (state.fullRate & 0xF)*6);
                delay.timeout[DAT] = delay.transmit[DAT] + 44;          //44us turnaround between CTS and DAT
                // complete the RTS packet header
                memcpy(pkt.rts.header.destAddr, pkt.dat.header.destAddr, 6);
                pkt.rts.header.currReSend = 0;
                time.uint16 = delay.timeout[CTS] + delay.timeout[DAT] + delay.timeout[ACK];
                pkt.rts.header.reserved1 = time.uint8[0];
                pkt.rts.header.reserved2 = time.uint8[1];
                
                initTX();
        } else {
                // set up and load BCD packet once so that subsequent calls to sendBCD can skip this step
                pkt.bcd.header.length = length;
                pkt.bcd.isNew = 1;
                warpmac_prepPhyForXmit(&pkt.bcd,1);
                sendBCD();
        }
        
        return 0;
}


void initTX() {
        if(pkt.dat.isNew) {
                if((pkt.rts.header.currReSend <= state.maxResend.rts) && (pkt.dat.header.currReSend <= state.maxResend.dat)) {
                        if(!warp_timer_isActive(NAV) && !warp_timer_isActive(TIMEOUT)) {
                                if(warpmac_carrierSense()) {
                                        if(pkt.dat.header.reserved4 == 1) {
                                                // begin with data packet (send without RTS/CTS exchange)
                                                warpmac_prepPhyForXmit(&pkt.dat, 1);
                                                sendDAT();
                                        } else {
                                                // begin with RTS
                                                warpmac_prepPhyForXmit(&pkt.rts, 2);
                                                warpmac_startPhyXmit(2);
                                                state.mac = CTS;
                                                pktCtr[TX][RTS]++;
                                                pkt.rts.header.currReSend++;
                                                warpmac_finishPhyXmit();
                                                updateTimer(TIMEOUT, delay.timeout[CTS]);
                                                // set fullRate for MISO if feedback is enabled, SISO otherwise
                                                pkt.dat.header.fullRate = (state.feedback_en) ? (state.fullRate | (state.fullRate<<4)) : state.fullRate;
                                                // copy data packet header into PHY while waiting for CTS
                                                warpmac_prepPhyForXmit(&pkt.dat, 1);
                                        }
                                        setCSMAIdleTime(delay.DIFS);    // reset to DIFS (in case EIFS was previously set)
                                } else {
                                        updateTimer(BACKOFF, 0);
                                }
                        }
                } else {
                        // resend limit has been reached
                        dropPacket();
                }
        }
}


void sendCTS(Macframe* packet) {
        UTime time;
        
        if(state.feedback_en) {
                lockRXantenna();        // we send only CSI corresponding to the locked antenna
                loadCSI(csi.current);
        }
        
        memcpy(pkt.cts.header.destAddr,packet->header.srcAddr,6);
        // set the NAV of other nodes to reserve the channel
        time.uint8[0] = packet->header.reserved1;
        time.uint8[1] = packet->header.reserved2;
        // calculate new NAV time using RTS's NAV time
        time.uint16 = time.uint16 - delay.timeout[CTS];
        pkt.cts.header.reserved1 = time.uint8[0];
        pkt.cts.header.reserved2 = time.uint8[1];
        
        delay.timeout[DAT] = time.uint16 - delay.timeout[ACK];
        
        warpmac_prepPhyForXmit(&pkt.cts, 3);
        
        // send CTS packet if NAV indicates channel is idle, else do not respond
        if(!warp_timer_isActive(NAV)) {
                warpmac_startPhyXmit(3);                        // CSI must be in buffer 3
                pktCtr[TX][CTS]++;
                state.mac = DAT;
                warpmac_finishPhyXmit();
                updateTimer(TIMEOUT, delay.timeout[DAT]);
        }
}


void sendDAT() {
        extern Maccontrol controlStruct;
        if(state.feedback_en) {
                //load modulation masks from received CTS packet
                setTXModMasks(csi.current);
                //setTXModMasks((unsigned char *)(warpphy_getBuffAddr(controlStruct.rxBuffIndex) + NUM_HEADER_BYTES));
                warpmac_enableMisoMode();
                warpmac_startPhyXmit(1);
                warpmac_finishPhyXmit();
                warpmac_disableMisoMode();
        } else {
                warpmac_startPhyXmit(1);
                warpmac_finishPhyXmit();
        }
        pktCtr[TX][DAT]++;
        pkt.dat.header.currReSend++;
        state.mac = ACK;
        updateTimer(TIMEOUT, delay.timeout[ACK]);
}


void sendBCD() {
        if(!warp_timer_isActive(NAV) && !warp_timer_isActive(TIMEOUT)) {
                if(warpmac_carrierSense()) {
                        warpmac_startPhyXmit(1);
                        pkt.bcd.isNew = 0;
                        pktCtr[TX][BCD]++;
                        setCSMAIdleTime(delay.DIFS);
                        warpmac_finishPhyXmit();
                        warpmac_enableEthernet();
                }
                updateTimer(BACKOFF, 0);
        }
}


int rtsmac_phyRx_badHeader_callback() {
        updateTimer(BACKOFF, 0);
        setCSMAIdleTime(delay.EIFS);
        unlockRXantenna();
        warpmac_incrementLEDLow();
        return 0;
}


int rtsmac_phyRx_goodHeader_callback(Macframe* packet) {
        extern Maccontrol controlStruct;
        unsigned char rxStatus = INCOMPLETE;
        if(warpmac_addressedToMe(packet) && !warp_timer_isActive(NAV)) {
                warp_timer_stop(TIMEOUT);
                //warpmac_setDebugGPIO(state.GPIOval |= 1);
                if(packet->header.pktType == RTS && (state.mac == IDLE || state.mac == DAT)) {
                        while(rxStatus == INCOMPLETE) {
                                rxStatus = warpphy_pollRxStatus();
                        }
                        if(rxStatus == GOODPACKET) {
                                sendCTS(packet);
                        }
                } else if(packet->header.pktType == CTS && state.mac == CTS) {
                        while(rxStatus == INCOMPLETE) {
                                rxStatus = warpphy_pollRxStatus();
                        }
                        if(rxStatus == GOODPACKET) {
                                sendDAT();
                        }
                } else if(packet->header.pktType == DAT
                        && (state.mac == DAT  && packet->header.reserved4 == 0
                         || state.mac == IDLE && packet->header.reserved4 == 1)) {
                        memcpy(pkt.ack.header.destAddr,packet->header.srcAddr,6);
                        warpmac_prepPhyForXmit(&pkt.ack,2);
                        while(rxStatus == INCOMPLETE) {
                                rxStatus = warpphy_pollRxStatus();
                        }
                        if(rxStatus == GOODPACKET) {
                                //Send packet buffer 2 containing the ACK
                                warpmac_startPhyXmit(2);
                                //Starts the DMA transfer of the payload into the EMAC
                                warpmac_prepEmacForXmit(packet);
                                pktCtr[TX][ACK]++;
                                pktCtr[TX][ETH]++;
                                //Blocks until the PHY is finished sending and enables the receiver
                                warpmac_finishPhyXmit();
                                //Waits until the DMA transfer is complete, then starts the EMAC
                                warpmac_startEmacXmit(packet);
                                updateTimer(BACKOFF, 0);
                                unlockRXantenna();
                        }
                } else if(packet->header.pktType == ACK && state.mac == ACK) {
                        // respond to ACK only if expecting ACK
                        while(rxStatus == INCOMPLETE) {
                                rxStatus = warpphy_pollRxStatus();
                        }
                        if(rxStatus == GOODPACKET) {
                                pkt.dat.isNew = 0;
                                controlStruct.currBackoff = 0;
                                updateTimer(BACKOFF, 0);
                                warpmac_enableEthernet();
                        }
                } else {
                        // packet was not expected, invoke backoff procedure
                        while(rxStatus == INCOMPLETE) {
                                rxStatus = warpphy_pollRxStatus();
                        }
                        if(rxStatus == GOODPACKET) {
                                pktCtr[RXGOOD][packet->header.pktType]--;
                                pktCtr[RXUNEXP][packet->header.pktType]++;
                                updateTimer(BACKOFF, 0);
                        }
                }
         } else if(packet->header.pktType == BCD) {
                // packet was broadcast, simply forward over ethernet and backoff
                while(rxStatus == 0) {
                        rxStatus = warpphy_pollRxStatus();
                }
                if(rxStatus == GOODPACKET) {
                        //Starts the DMA transfer of the payload into the EMAC
                        warpmac_prepEmacForXmit(packet);
                        //Waits until the DMA transfer is complete, then starts the EMAC
                        warpmac_startEmacXmit(packet);
                        updateTimer(BACKOFF, 0);
                }
        } else {
                // packet addressed to someone else, set/update NAV timer to reserve channel
                UTime time;
                time.uint8[0] = packet->header.reserved1;
                time.uint8[1] = packet->header.reserved2;
                if(time.uint16 > 0) {
                        updateTimer(NAV,time.uint16);
                }
        }
        
        if(rxStatus == GOODPACKET) {
                pktCtr[RXGOOD][packet->header.pktType]++;
                warpmac_incrementLEDHigh();
        } else if(rxStatus == BADPACKET) {
                pktCtr[RXBAD][packet->header.pktType]++;
                rtsmac_phyRx_badHeader_callback();
        }
        //warpmac_setDebugGPIO(state.GPIOval &= ~1);
        return 0;
}




int main() {
        xil_printf("\r\nInitializing RTS/CTS MAC...\r\n");
        
        //Initialize the framework
        warpmac_init();
        
        initDelays();
        initAddresses();
        initHeaders();
        
        state.mac = IDLE;
        clearPktCtr();
        
        // setup timer modes
        warp_timer_setMode(TIMEOUT, DISABLECSMA);
        warp_timer_setMode(BACKOFF, ENABLECSMA);
        warp_timer_setMode(NAV, DISABLECSMA);
        
        //Rx buffer is where the EMAC will DMA Wireless payloads from
        warpmac_setRxBuffer(&pkt.rx,0);
        //Tx buffer is where the EMAC will DMA Ethernet payloads to
        warpmac_setTxBuffer(1);
        
        warpmac_setBadHeaderCallback((void *)rtsmac_phyRx_badHeader_callback);
        warpmac_setGoodHeaderCallback((void *)rtsmac_phyRx_goodHeader_callback);
        warpmac_setTimerCallback((void *)rtsmac_timer_callback);
        warpmac_setEmacCallback((void *)rtsmac_emacRx_callback);
        warpmac_setUpButtonCallback((void *)rtsmac_up);
        warpmac_setMiddleButtonCallback((void *)rtsmac_middle);
        warpmac_setLeftButtonCallback((void *)rtsmac_left);
        warpmac_setRightButtonCallback((void *)rtsmac_right);
        
        //Set the default center frequency
        warpphy_setChannel(GHZ_2, state.chan);
        
        warpmac_enableCSMA();
        warpmac_enableEthernet();
        
        //Set the modulation scheme use for base rate (header) symbols
        warpmac_setBaseRate(state.baseRate);
        
        //display 1 if RTS/CTS is forced on, 0 if not
        warpmac_leftHex((state.rtsThreshold) == 0 ? 1 : 0);
        
        csi.current = csi.antA;
        //initFeedback();
        
        //wtic;
        //setTXModMasks(csi.antA);
        //wtoc;
        //printTvars();
        
        xil_printf(" finished.");
        while(1)
        {
                volatile unsigned char uartByte = 0;
                
                warpmac_pollEthernet();

/*              //does not work with ethernet polling
                if(uartByte = XUartLite_RecvByte(STDIN_BASEADDRESS));
                        if(uartByte==ASCII_j) { xil_printf("\b \nSetting antenna A modulation masks"); csi.current = csi.antA; }
                        if(uartByte==ASCII_h) { xil_printf("\b \nSetting antenna B modulation masks"); csi.current = csi.antB; }
                        if(uartByte==ASCII_g) { xil_printf("\b \nSetting half A half B modulation masks"); csi.current = csi.half; }
                        if(uartByte==ASCII_k) { xil_printf("\b \nSetting half B half A modulation masks"); csi.current = csi.otherhalf; }
                        if(uartByte==ASCII_l) { xil_printf("\b \nSetting alternating modulation masks"); csi.current = csi.alternating; }
                        
                        if(uartByte==ASCII_f) { printRXGains(); }
                        if(uartByte==ASCII_i) { xil_printf("\b \nTurning CSI %s", ((state.feedback_en ^= 1) ? "on" : "off")); }
                        if(uartByte==ASCII_u) { xil_printf("\b \nEnabling MIMO mode"); warpphy_enableMimoMode(); }
                        if(uartByte==ASCII_y) { xil_printf("\b \nEnabling SISO mode"); warpphy_enableSisoMode(); }
                        if(uartByte==ASCII_b) { warpphy_setSISOAntenna(state.currentAnt ^= 1); xil_printf("\b \nSwitching SISO to antenna %c", ((state.currentAnt == 1) ? 'B' : 'A')); }
                        if(uartByte==ASCII_v) { xil_printf("\b "); printState(); printTvars(); }
                        if(uartByte==ASCII_t) { xil_printf("\b "); printStatistics(); }
                        if(uartByte==ASCII_c) { xil_printf("\b \nClearing packet count"); clearPktCtr(); }
                        if(uartByte==ASCII_r) { dropPacket(); warpphy_clearRxInterrupts(); }
                        
                        if(uartByte==ASCII_3) warpphy_setGainPlus(1);
                        if(uartByte==ASCII_e) warpphy_setGainMinus(1);
*/
        }

        return 0;
}










/***************** Initialization functions ************************/
void initFeedback() {
        //toggle second radio on to activate it, but switch back to first
        warpphy_setSISOAntenna(state.currentAnt ^= 1);
        warpphy_setSISOAntenna(state.currentAnt ^= 1);
        //state.feedback_en = 1;
        unlockRXantenna();
        
        if(0 && state.myID == 2) {
                state.feedback_en = 1;
        }
        //set TX masks 
        setTXModMasks(csi.antA);
}


void initDelays() {
        // times for sending various packets
        delay.header = 64;              // header only packet requires 64us
        delay.transmit[CTS] = delay.header
                + ( (state.csiLength > 0) ? ceil_div_uint(state.csiLength + 4, 6*(state.fullRate & 0xF))*8 : 0 );
        delay.transmit[ACK] = delay.header;
        
        // delay times (in microseconds)
        delay.slot = 9;
        delay.SIFS = 46;
        delay.DIFS = delay.SIFS + 2*delay.slot;
        delay.EIFS = delay.SIFS + delay.DIFS + delay.transmit[ACK];
        
        // timeouts for receiving response packets
        delay.timeout[CTS] = delay.slot + delay.transmit[CTS] + 46;             // 46us turnaround between RTS and CTS
        delay.timeout[ACK] = delay.slot + delay.transmit[ACK] + 24;             // 24us turnaround between data and ACK
        
        // set DIFS time in PHY
        setCSMAIdleTime(delay.DIFS);
        
        warpmac_setMaxCW(5);
}


void initAddresses() {
        unsigned char i;
        
        //Read Dip Switch value from FPGA board.
        //This value will be used as an index into the routing table for other nodes
        state.myID = warpmac_getMyId();
        
        //Create an arbitrary address for this node (16-24-63-53-e2-(c2+state.myID))
        state.addr.my[0] = 0x16; state.addr.my[1] = 0x24; state.addr.my[2] = 0x63;
        state.addr.my[3] = 0x53; state.addr.my[4] = 0xe2; state.addr.my[5] = 0xc2+state.myID;
        
        //Fill an arbitrary routing table so that nodes know each others' addresses
        for(i=0;i<16;i++) {
                state.routeTable[i].addr[0] = state.addr.my[0];
                state.routeTable[i].addr[1] = state.addr.my[1];
                state.routeTable[i].addr[2] = state.addr.my[2];
                state.routeTable[i].addr[3] = state.addr.my[3];
                state.routeTable[i].addr[4] = state.addr.my[4];
                state.routeTable[i].addr[5] = state.addr.my[5]+i-state.myID;
        }
        
        warpmac_setMacAddr((unsigned char *)(&state.addr.my));
}


void initHeaders() {
        UTime time;
        
        // set up RTS packet
        pkt.rts.header.fullRate = state.fullRate;
        pkt.rts.header.reserved4 = 0;
        pkt.rts.header.length = 0;
        pkt.rts.header.pktType = RTS;
        memcpy(pkt.rts.header.srcAddr,(unsigned char *)state.addr.my,6);
        pkt.rts.header.currReSend = 0;
        
        // set up CTS packet
        pkt.cts.header.fullRate = state.fullRate;
        pkt.cts.header.reserved4 = 0;
        pkt.cts.header.length = state.csiLength;        // 8 bytes for CSI on each of the 64 OFDM subchannels
        pkt.cts.header.pktType = CTS;
        memcpy(pkt.cts.header.srcAddr,(unsigned char *)state.addr.my,6);
        pkt.cts.header.currReSend = 0;
        
        // set up data packet
        pkt.dat.header.fullRate = state.fullRate;
        pkt.dat.header.pktType = DAT;
        memcpy(pkt.dat.header.srcAddr,(unsigned char *)state.addr.my,6);
        time.uint16 = delay.timeout[ACK];       // set NAV of other nodes
        pkt.dat.header.currReSend = 0;
        pkt.dat.header.reserved1 = time.uint8[0];
        pkt.dat.header.reserved2 = time.uint8[1];
        
        // set up ACK packet
        pkt.ack.header.fullRate = state.fullRate;
        pkt.ack.header.reserved4 = 0;
        pkt.ack.header.length = 0;
        pkt.ack.header.pktType = ACK;
        pkt.ack.header.currReSend = 0;
        pkt.ack.header.reserved1 = 0;   // set NAV to 0 for ACK (do not reserve channel)
        pkt.ack.header.reserved2 = 0;
        
        // set up broadcast data packet
        pkt.bcd.header.fullRate = state.fullRate;
        pkt.bcd.header.reserved4 = 0;
        pkt.bcd.header.pktType = BCD;
        memcpy(pkt.bcd.header.destAddr,(unsigned char *)state.addr.bc,6);
        memcpy(pkt.bcd.header.srcAddr,(unsigned char *)state.addr.my,6);
        pkt.bcd.header.currReSend = 0;
        pkt.bcd.header.reserved1 = 0;   // set NAV to 0 (don't expect any reply)
        pkt.bcd.header.reserved2 = 0;
}




/***************** Button Handlers *********************************/
void rtsmac_left() {
        extern unsigned char txGain;
        warpphy_setGainMinus(ceil_div_uint(txGain,8));
        // static unsigned char i = 0;
        // i++;
        // i %= 6;
        // switch(i) {
        // case 0:
                // state.feedback_en = 0;
                // csi.current = csi.antA;
                // xil_printf("\nfeedback disabled");
                // break;
        // case 1:
                // state.feedback_en = 1;
                // csi.current = csi.antA;
                // xil_printf("\nantA");
                // break;
        // case 2:
                // state.feedback_en = 1;
                // csi.current = csi.antB;
                // xil_printf("\nantB");
                // break;
        // case 3:
                // state.feedback_en = 1;
                // csi.current = csi.half;
                // xil_printf("\nhalf");
                // break;
        // case 4:
                // state.feedback_en = 1;
                // csi.current = csi.otherhalf;
                // xil_printf("\notherhalf");
                // break;
        // case 5:
                // state.feedback_en = 1;
                // csi.current = csi.alternating;
                // xil_printf("\nalternating");
                // break;
        // }
}


void rtsmac_middle() {
        printState();
        printTvars();
        printStatistics();
}


void rtsmac_right() {
        extern unsigned char txGain;
        warpphy_setGainPlus(ceil_div_uint(txGain,8));
}


void rtsmac_up() {
        state.rtsThreshold = (state.rtsThreshold == 0) ? 65535 : 0;
        warpmac_leftHex((state.rtsThreshold) == 0 ? 1 : 0);
}




/***************** Status Display Functions ************************/
void printState() {
        extern Maccontrol controlStruct;
        xil_printf("\nMAC=%d,NAV=%d,dat.isNew=%d,bcd.isNew=%d,currentAnt=%d,"
                "timeLeft_0=%d,timeLeft_1=%d,timeLeft_2=%d,timeLeft_3=%d,tstatus=%x",
                state.mac,
                warp_timer_isActive(NAV),
                pkt.dat.isNew,
                pkt.bcd.isNew,
                state.currentAnt,
                warp_timer_timeLeft(0),
                warp_timer_timeLeft(1),
                warp_timer_timeLeft(2),
                warp_timer_timeLeft(3),
                warp_timer_getStatuses());
}


void clearPktCtr() {
        unsigned char i, j;
        for(i = 0; i < 4; i++){
                for(j = 0; j < 7; j++){
                        pktCtr[i][j] = 0;
                }
        }
}


void printStatistics() {
        unsigned char i = 0;
        char pktType[7][8] = {"TOTAL","RTS","CTS","DAT","ACK","BCD","ETH"};
        xil_printf("\n        |   TX    | RX_good |RX_unexp | RX_bad  |\n");
        pktCtr[TX][0] = 0;
        pktCtr[RXGOOD][0] = 0;
        pktCtr[RXUNEXP][0] = 0;
        pktCtr[RXBAD][0] = 0;
        for(i = 1; i < 5; i++) {
                pktCtr[TX][0] += pktCtr[TX][i];
                pktCtr[RXGOOD][0] += pktCtr[RXGOOD][i];
                pktCtr[RXUNEXP][0] += pktCtr[RXUNEXP][i];
                pktCtr[RXBAD][0] += pktCtr[RXBAD][i];
                xil_printf("%8s|%9d|%9d|%9d|%9d|\n",
                        (unsigned char *)pktType[i],
                        pktCtr[TX][i],
                        pktCtr[RXGOOD][i],
                        pktCtr[RXUNEXP][i],
                        pktCtr[RXBAD][i]);
        }
        xil_printf("%8s|%9d|%9d|%9d|%9d|\n",
                (unsigned char *)pktType[0],
                pktCtr[TX][0],
                pktCtr[RXGOOD][0],
                pktCtr[RXUNEXP][0],
                pktCtr[RXBAD][0]);
        xil_printf("-------------------------------------------------\n");
        xil_printf("        |   TX    |   RX    |\n");
        xil_printf("%8s|%9d|%9d|\n",
                (unsigned char *)pktType[BCD],
                pktCtr[TX][BCD],
                pktCtr[RXGOOD][BCD]);
        xil_printf("-------------------------------------------------\n");
        xil_printf("        |   TX    |   RX    |  DROP   |\n");
        xil_printf("%8s|%9d|%9d|%9d|\n",
                (unsigned char *)pktType[ETH],
                pktCtr[TX][ETH],
                pktCtr[RXGOOD][ETH],
                pktCtr[DROP][ETH]);
}

---