source: ResearchApps/MAC/Debug_PseudoMACs/OFDM_Reflector/ofdm_reflector.c

#include "xparameters.h"
#include "warpmac.h"
#include "warpphy.h"
#include "ofdm_reflector.h"
#include "stdio.h"
#include "warp_hw_ver.h"

///Macframe struct to represent received wireless packets
Macframe rxFrame;

///Indices of Rx/Tx packet buffers in the PHY
unsigned char pktBufInd_rx;
unsigned char pktBufInd_tx;

unsigned short myID;
unsigned short seqNum;

unsigned char cur_chan;
unsigned char cur_ant;

///@brief Callback for the reception of data frames from the higher network layer
///
///This function is called by the WARPMAC framework when a new payload is available
/// for wireless transmission. New payloads can either arrive via Ethernet (for
/// externally generated traffic) or via dummy packet mode (for internally generated
/// traffic). Before calling this function, WARPMAC has already copied the payload
/// to the PHY packet buffer previously specified by warpmac_setPHYTxBuffer().
///@param length Length, in bytes, of received Ethernet frame
///@param payload Memory address of first byte in the payload
void dataFromNetworkLayer_callback(Xuint32 length, char* payload)
{

//WORKSHOP PSEUDOCODE:
//1) Instantiate a "Macframe" struct to hold a packet header
//2) Setup the wireless packet header by setting fields in the Macframe.header struct:
//     2.1) length (set to length argument passed to this function)
//     2.2) fullRate (set to HDR_FULLRATE_QPSK or HDR_FULLRATE_QAM_16 for QPSK/16QAM payload modulation)
//     2.3) codeRate (set to HDR_CODE_RATE_12 or HDR_CODE_RATE_34 for 1/2 or 3/4 rate payload coding)
//5) Copy the header over the the PHY Tx buffer using the "warpmac_prepPhyForXmit" function.
//6) Initiate the PHY transmission using the "warpmac_startPhyXmit" function.
//7) Wait for the PHY transmitter to finish and re-enable the receiver by using the "warpmac_finishPhyXmit" function.

//Note: You may be wondering why the act of transmitting is broken up into three function calls (5,6,7 of pseudocode above).
//In this simple exercise, it seems a bit unnecessary. However, the reason for this division will become clear in later labs.

/**********************USER CODE STARTS HERE***************************/
    //Buffer for holding a packet-to-xmit
    Macframe txFrame;
    seqNum++;

    //Set the length field in the header
    txFrame.header.length = length;
    txFrame.header.seqNum = seqNum;

    warpmac_leftHex(seqNum);

    //Set the modulation scheme for the packet's full-rate symbols
    txFrame.header.fullRate = HDR_FULLRATE_QPSK;
    //txFrame.header.fullRate = HDR_FULLRATE_QAM_16;

    //Set the payload coding rate
    //txFrame.header.codeRate = HDR_CODE_RATE_NONE;
    //txFrame.header.codeRate = HDR_CODE_RATE_12;
    //txFrame.header.codeRate = HDR_CODE_RATE_23;
    txFrame.header.codeRate = HDR_CODE_RATE_34;

    //Copy the header over to packet buffer 1
    warpmac_prepPhyForXmit(&txFrame, pktBufInd_tx);

    //Send packet buffer pktBuf_tx
    warpmac_startPhyXmit(pktBufInd_tx);

    //Wait for it to finish and enable the receiver
    warpmac_finishPhyXmit();
/**********************USER CODE ENDS HERE***************************/
    return;
}

///@brief Callback for the reception of bad wireless headers
void phyRx_badHeader_callback()
{
    //Blink the bottom user LEDs on reception of a bad header
    warpmac_incrementLEDLow();
    
    return;
}

///@brief Callback for the reception of good wireless headers
///
///The WARPMAC framework calls this function after the PHY receives an error-free wireless header
/// If the packet also has a payload, this function must poll the PHY until the payload status (good/bad)
/// is determined.
///If the payload is error-free, it is transmitted over Ethernet, completing the wired-wireless-wired bridge
///@param packet Pointer to received Macframe
int phyRx_goodHeader_callback(Macframe* packet)
{

    //Initialize the Rx pkt state variable
    unsigned char state = PHYRXSTATUS_INCOMPLETE;

    //Poll the PHY; blocks until the PHY declares the payload good or bad
    state = warpmac_finishPhyRecv();

    if(state & PHYRXSTATUS_GOOD)
    {
        //If the received packet has no errors, send it (minus the wireless header) via Ethernet

        warpmac_rightHex(packet->header.seqNum);

        if(myID == 0) {
            //Re-transmit the received packet with no changes
            warpmac_startPhyXmit(pktBufInd_rx);
        }

        //Toggle the top user LEDs
        warpmac_incrementLEDHigh();
    }

    if(state & PHYRXSTATUS_BAD)
    {
        //If the received packet has errors, drop it (i.e. don't send it via Ethernet)

        //Toggle the bottom user LEDs
        warpmac_incrementLEDLow();
    }

    //Return 0, indicating this function did not clear the PHY status bits; WARPMAC will handle this
    return 0;
}

void middleButton() {
    if(cur_chan >= 14) {
        cur_chan = 1;
    } else {
        cur_chan++;
    }
    xil_printf("Set Channel: %d\n", cur_chan);

    userio_write_leds_green(USERIO_BASEADDR, cur_chan & 0xF);
    warpphy_setChannel(GHZ_2, cur_chan);

    return;
}

void upButton() {
    if(cur_ant == 0) {
        cur_ant = 1;
        warpphy_setAntennaMode(TX_ANTMODE_SISO_ANTB, RX_ANTMODE_SISO_ANTB);
    } else {
        cur_ant = 0;
        warpphy_setAntennaMode(TX_ANTMODE_SISO_ANTA, RX_ANTMODE_SISO_ANTA);
    }

    return;
}

///@brief Main function
///
///This function configures & initializes WARPMAC, assigns user-level callbacks then loops forever.
int main()
{
    print("\fReference Design v18 OFDM Reflector FMC Radios\r\n");

    cur_chan = 1;
    cur_ant = 0;

    userio_write_leds_green(USERIO_BASEADDR, cur_chan & 0xF);

    //Assign Tx/Rx to packet buffers in the PHY
    pktBufInd_rx = 1;
    pktBufInd_tx = 2;

    //Initialize the framework
    // This function sets safe defaults for many parameters in the MAC/PHY frameworks
    // Many of these can be changed with other warpmac_ and warpphy_ calls
    //  or by customizing the warpmac.c/warpphy.c source
    warpmac_init();

    //Choose the antnenna mode
    warpphy_setAntennaMode(TX_ANTMODE_SISO_ANTA, RX_ANTMODE_SISO_ANTA);

    //Rx buffer is where the PHY will write received payloads,
    // and the EMAC will read packets for transmission via Ethernet
    warpmac_setRxBuffers(&rxFrame, pktBufInd_rx);

    //EMACRxBuffer is where incoming Ethernet packets will be written
    warpmac_setEMACRxBuffer(pktBufInd_tx);

    //PHYTxBuffer is the buffer from which the PHY will read packets for wireless transmission
    warpmac_setPHYTxBuffer(pktBufInd_tx);

#ifdef WARP_HW_VER_v3
    //Set the OFDM Rx detection thresholds
    warpphy_setCarrierSenseThresh(4000); //Carrier sense thresh (in [0,16368])
    warpphy_setEnergyDetThresh(6500);       //Min RSSI (in [0,16368])
    warpphy_setAutoCorrDetParams(50, 20);   //Min auto-correlation (UFix8_7) and min energy (UFix16_8)
    warpphy_setLongCorrThresh(10000);       //Min cross-correlation (in [0,45e3])

    //Set the default Tx gain (in [0,63])
    warpphy_setTxPower(45);
#else
    //Set the OFDM Rx detection thresholds (copied from OFDM ref des v17 for now)
    warpphy_setCarrierSenseThresh(12000); //Carrier sense thresh (in [0,16368])
    warpphy_setEnergyDetThresh(7000);       //Min RSSI (in [0,16368])
    warpphy_setAutoCorrDetParams(90, 20);   //Min auto-correlation (UFix8_7) and min energy (UFix16_8)
    warpphy_setLongCorrThresh(8000);        //Min cross-correlation (in [0,45e3])

    //Set the default Tx gain (in [0,63])
    warpphy_setTxPower(55);
#endif

    warpphy_setChannel(GHZ_2, cur_chan);

    //Assign the user-level callbacks
    warpmac_setCallback(EVENT_DATAFROMNETWORK, (void *)dataFromNetworkLayer_callback);
    warpmac_setCallback(EVENT_PHYGOODHEADER, (void *)phyRx_goodHeader_callback);
    warpmac_setCallback(EVENT_PHYBADHEADER, (void *)phyRx_badHeader_callback);
    warpmac_setCallback(EVENT_MIDDLEBUTTON, (void *)middleButton);
    warpmac_setCallback(EVENT_UPBUTTON, (void *)upButton);
    

    myID = (unsigned short int)warpmac_getMyId();
    seqNum = 0;

    //Enable calls to our dataFromnetworkLayer callback (to start receiving Ethernet payloads)
    warpmac_enableDataFromNetwork();

    //Enable dummy packet mode (Ethernet will be ignored, packets will be generated/transmitted locally)
    warpmac_setDummyPacketMode(myID);
    warpmac_startPacketGeneration(1400, 750000);

    //Poll the timer, PHY and user I/O forever; actual processing will happen via callbacks above
    while(1)
    {
        warpmac_pollPeripherals();
    }

    return 0;
}