1 | /*! \file afdf_char.c |
---|
2 | \brief Top-level "MAC" for characterizing AF and DF PHY performance |
---|
3 | |
---|
4 | @version 15.22 |
---|
5 | @author Patrick Murphy |
---|
6 | */ |
---|
7 | |
---|
8 | #include "xparameters.h" |
---|
9 | #include "warpnet.h" |
---|
10 | #include "warpmac.h" |
---|
11 | #include "warpphy.h" |
---|
12 | #include "afdf_char.h" |
---|
13 | #include "string.h" |
---|
14 | #include "stdlib.h" |
---|
15 | #include "stdio.h" |
---|
16 | #include "xtime_l.h" |
---|
17 | |
---|
18 | //Lower level includes, for debug/development |
---|
19 | #include "ofdm_txrx_mimo_regMacros.h" |
---|
20 | #include "ofdm_agc_mimo_regMacros.h" |
---|
21 | #include "warp_timer_regMacros.h" |
---|
22 | #include "radio_controller_basic.h" |
---|
23 | #include "radio_controller_ext.h" |
---|
24 | #include "radio_controller_adv.h" |
---|
25 | #include "radio_controller_5ghz.h" |
---|
26 | #include "ascii_characters.h" |
---|
27 | |
---|
28 | #define AF_ONLY 0 |
---|
29 | #define DF_ONLY 0 |
---|
30 | |
---|
31 | //Node IDs |
---|
32 | #define ID_SRC 0 |
---|
33 | #define ID_DST 1 |
---|
34 | #define ID_RLY 2 |
---|
35 | |
---|
36 | //Packet types |
---|
37 | #define PKTTYPE_NCDATA 0x00 |
---|
38 | #define PKTTYPE_DFDATA 0xEE |
---|
39 | #define PKTTYPE_AFDATA 0x55 |
---|
40 | #define PKTTYPE_AFGHDATA 0xC3 |
---|
41 | #define PKTTYPE_DFGHDATA 0x3C |
---|
42 | #define PKTTYPE_NCMHOPDATA 0xA2 |
---|
43 | |
---|
44 | #define PKTTYPE_INVALID 0x88 |
---|
45 | |
---|
46 | unsigned char pktTypesToTx[6]; |
---|
47 | unsigned char numPktTypes; |
---|
48 | |
---|
49 | //Match unit assignments |
---|
50 | //#define REQ_DST_ME PHY_AUTORESPONSE_REQ_MATCH0 |
---|
51 | #define REQ_RLY_ME PHY_AUTORESPONSE_REQ_MATCH0 |
---|
52 | #define REQ_DFDATA PHY_AUTORESPONSE_REQ_MATCH1 |
---|
53 | #define REQ_AFDATA PHY_AUTORESPONSE_REQ_MATCH2 |
---|
54 | #define REQ_AFGHDATA PHY_AUTORESPONSE_REQ_MATCH3 |
---|
55 | #define REQ_DFGHDATA PHY_AUTORESPONSE_REQ_MATCH4 |
---|
56 | #define REQ_NCMHOPDATA PHY_AUTORESPONSE_REQ_MATCH5 |
---|
57 | |
---|
58 | int myID; |
---|
59 | unsigned char chan; |
---|
60 | unsigned int pktFullRate; |
---|
61 | unsigned int pktCodeRate; |
---|
62 | unsigned int pktGen_length, pktGen_period; |
---|
63 | |
---|
64 | unsigned char nonCoopTesting; |
---|
65 | unsigned char coopTesting; |
---|
66 | |
---|
67 | unsigned int autoResp_matchCond; |
---|
68 | unsigned int autoResp_action; |
---|
69 | unsigned int autoResp_action_relayTx; |
---|
70 | |
---|
71 | unsigned char pktBuf_rx; |
---|
72 | unsigned char pktBuf_tx_DATA; |
---|
73 | unsigned char pktBuf_emac_rx; |
---|
74 | unsigned char pktBuf_tx_AF; |
---|
75 | |
---|
76 | unsigned char autoRespDelay_SrcReTx; |
---|
77 | unsigned char autoRespDelay_RlyTx_DF; |
---|
78 | unsigned char autoRespDelay_RlyTx_AF; |
---|
79 | unsigned char pktDetBypass_txStartDly; |
---|
80 | |
---|
81 | unsigned char txPower; |
---|
82 | |
---|
83 | unsigned int preambleScaling; |
---|
84 | unsigned int payloadScaling; |
---|
85 | signed char agcTargetPwr; |
---|
86 | |
---|
87 | unsigned short pktDet_corrThresh; |
---|
88 | //unsigned char pktDet_corrWindowStart; |
---|
89 | //unsigned char pktDet_corrWindowEnd; |
---|
90 | //unsigned short longCorrCounterLoad; |
---|
91 | |
---|
92 | unsigned int afScaling; |
---|
93 | |
---|
94 | unsigned char reportCFOviaWarpnet; |
---|
95 | unsigned char reportBERviaWarpnet; |
---|
96 | unsigned char doRxPHYdump; |
---|
97 | |
---|
98 | unsigned char FFT_offset; |
---|
99 | unsigned int energyThresh; |
---|
100 | unsigned int agcThresholds; |
---|
101 | |
---|
102 | unsigned int agc_iirCoef_g, agc_iirCoef_fb; |
---|
103 | |
---|
104 | warpnetObservePER perStruct_NC; |
---|
105 | warpnetObservePER perStruct_DF; |
---|
106 | warpnetObservePER perStruct_AF; |
---|
107 | warpnetObservePER perStruct_AFGH; |
---|
108 | warpnetObservePER perStruct_DFGH; |
---|
109 | warpnetObservePER perStruct_NCMHOP; |
---|
110 | warpnetObservePER perStruct_Other; |
---|
111 | |
---|
112 | warpnetRxPHYdump rxPHYdumpStruct; |
---|
113 | |
---|
114 | warpnetControllerGroup groupStruct; |
---|
115 | |
---|
116 | Macframe rxFrame; |
---|
117 | Macframe txFrame; |
---|
118 | |
---|
119 | warpnetEthernetPktHeader txEthPktHeader; |
---|
120 | warpnetEthernetPktHeader coprocEthPktHeader; |
---|
121 | warpnetEthernetPktHeader coprocEthPktHeader; |
---|
122 | |
---|
123 | unsigned char curPktType; |
---|
124 | unsigned char curPktTypeInd; |
---|
125 | |
---|
126 | unsigned short int txSequences[3]; |
---|
127 | |
---|
128 | void dataFromNetworkLayer_callback(Xuint32 length, char* payload) |
---|
129 | { |
---|
130 | if(myID != ID_SRC) |
---|
131 | { |
---|
132 | //Shouldn't happen; destination node won't start dummy pkt generation |
---|
133 | warpmac_waitForDMA(); |
---|
134 | return; |
---|
135 | } |
---|
136 | |
---|
137 | void* txPktPtr; |
---|
138 | |
---|
139 | //Add to DF/AF cases to test coop-mhop |
---|
140 | //mimo_ofdmTx_setControlBits(mimo_ofdmTx_getOptions() & ~(TX_AUTO_TWOTX_EN)); |
---|
141 | |
---|
142 | if(coopTesting) { |
---|
143 | curPktTypeInd = (curPktTypeInd+1) % numPktTypes; |
---|
144 | curPktType = pktTypesToTx[curPktTypeInd]; |
---|
145 | |
---|
146 | if(curPktType == PKTTYPE_NCDATA) perStruct_NC.numPkts_tx++; |
---|
147 | else if(curPktType == PKTTYPE_DFDATA) perStruct_DF.numPkts_tx++; |
---|
148 | else if(curPktType == PKTTYPE_AFDATA) perStruct_AF.numPkts_tx++; |
---|
149 | else if(curPktType == PKTTYPE_AFGHDATA) perStruct_AFGH.numPkts_tx++; |
---|
150 | else if(curPktType == PKTTYPE_DFGHDATA) perStruct_DFGH.numPkts_tx++; |
---|
151 | else if(curPktType == PKTTYPE_NCMHOPDATA) { |
---|
152 | perStruct_NCMHOP.numPkts_tx++; |
---|
153 | //Turn off two-Tx mode (gets re-enabled at end of this function) |
---|
154 | mimo_ofdmTx_setControlBits(mimo_ofdmTx_getOptions() & ~(TX_AUTO_TWOTX_EN)); |
---|
155 | } |
---|
156 | } else { |
---|
157 | curPktType = PKTTYPE_NCDATA; |
---|
158 | perStruct_NC.numPkts_tx++; |
---|
159 | } |
---|
160 | |
---|
161 | //Increment the sequence number |
---|
162 | //if(curPktType == PKTTYPE_NCDATA) { |
---|
163 | if(curPktTypeInd == 0) { |
---|
164 | //Only increment on the first packet of a cycle; this way NC/AF/DF all have same seq number, making log-file-parsing easier |
---|
165 | txSequences[ID_DST] = ( (txSequences[ID_DST]+1) & 0xFFFF); |
---|
166 | } |
---|
167 | |
---|
168 | //Set the length field in the header |
---|
169 | txFrame.header.length = length; |
---|
170 | |
---|
171 | //Set the modulation scheme for the packet's full-rate symbols |
---|
172 | txFrame.header.pktType = curPktType; |
---|
173 | txFrame.header.srcAddr = (unsigned short int)(NODEID_TO_ADDR(ID_SRC)); |
---|
174 | txFrame.header.destAddr = (unsigned short int)(NODEID_TO_ADDR(ID_DST)); |
---|
175 | txFrame.header.relAddr = (unsigned short int)(NODEID_TO_ADDR(ID_RLY)); |
---|
176 | txFrame.header.fullRate = pktFullRate; |
---|
177 | txFrame.header.codeRate = pktCodeRate; |
---|
178 | txFrame.header.seqNum = txSequences[ID_DST]; |
---|
179 | |
---|
180 | //Copy the header over to Tx packet buffer |
---|
181 | warpmac_prepPhyForXmit(&txFrame, pktBuf_tx_DATA); |
---|
182 | |
---|
183 | //Transmit the packet |
---|
184 | if(coopTesting) { |
---|
185 | //Configure the antenna mode (normal in slot1, swapped in slot2) |
---|
186 | warpphy_setTxAntennaSwap(TX_ANTMODE_ALAMOUTI_ANTA); |
---|
187 | // warpphy_setTxAntennaSwap(TX_ANTMODE_ALAMOUTI_ANTA_SWAPPED); |
---|
188 | |
---|
189 | //Disable the TxStart output going to the destination |
---|
190 | mimo_ofdmTx_setControlBits(mimo_ofdmTx_getOptions() | (TX_START_D0_OUT_EN)); |
---|
191 | mimo_ofdmTx_setControlBits(mimo_ofdmTx_getOptions() & ~(TX_START_D1_OUT_EN)); |
---|
192 | |
---|
193 | //Set the cyclic shift to 0 |
---|
194 | mimo_ofdmTx_setControlBits(mimo_ofdmTx_getOptions() & ~(0x3F00000)); |
---|
195 | |
---|
196 | //Assert the dst node's pktDetReset for slot 1 |
---|
197 | warpmac_setDebugGPIO(0x4, 0xF); |
---|
198 | } |
---|
199 | |
---|
200 | warpmac_startPhyXmit(pktBuf_tx_DATA); |
---|
201 | |
---|
202 | if(coopTesting) { |
---|
203 | usleep(20); |
---|
204 | |
---|
205 | mimo_ofdmTx_setControlBits(mimo_ofdmTx_getOptions() & ~(TX_START_D0_OUT_EN)); |
---|
206 | mimo_ofdmTx_setControlBits(mimo_ofdmTx_getOptions() | (TX_START_D1_OUT_EN));} |
---|
207 | |
---|
208 | //Wait for it to finish |
---|
209 | warpmac_finishPhyXmit(); |
---|
210 | |
---|
211 | if(coopTesting) { |
---|
212 | usleep(8); //leave enough time for all the energy to get through the emulator, to avoid false pkt det at dest at end of slot 1 |
---|
213 | if(curPktType != PKTTYPE_NCDATA) { |
---|
214 | warpphy_setTxAntennaSwap(TX_ANTMODE_ALAMOUTI_ANTA_SWAPPED); |
---|
215 | // warpphy_setTxAntennaSwap(TX_ANTMODE_ALAMOUTI_ANTA); |
---|
216 | } |
---|
217 | |
---|
218 | warpmac_setDebugGPIO(0x0, 0xF); |
---|
219 | |
---|
220 | //Wait long enough for the relay to finish receiving slot1 |
---|
221 | usleep(autoRespDelay_SrcReTx/10); |
---|
222 | |
---|
223 | //Assert the relay's pktDet reset for slot2; this needs to happen before the relay's long correlation asserts |
---|
224 | warpmac_setDebugGPIO(0x2, 0xF); |
---|
225 | |
---|
226 | //PHY will start transmitting again automatically; wait for it to finish |
---|
227 | usleep(4); |
---|
228 | warpmac_finishPhyXmit(); |
---|
229 | |
---|
230 | //Keep relay pkt det reset long enough to avoid bogus detection at end of slot 2 |
---|
231 | usleep(10); |
---|
232 | warpmac_setDebugGPIO(0x0, 0xF); |
---|
233 | |
---|
234 | //Turn two-Tx mode back on (might have been disabled for NCMHOP) |
---|
235 | mimo_ofdmTx_setControlBits(mimo_ofdmTx_getOptions() | (TX_AUTO_TWOTX_EN)); |
---|
236 | } |
---|
237 | |
---|
238 | |
---|
239 | if(reportBERviaWarpnet) { |
---|
240 | //Send a copy of the just-transmitted packet to the BER calculating app |
---|
241 | //BER packets are built from: |
---|
242 | // Ethernet header [0:15] |
---|
243 | // MAC/PHY header [0:23] generated above |
---|
244 | // Actual transmitted payload (randomly generated and recorded in the PHY) [0:length-1] |
---|
245 | |
---|
246 | coprocEthPktHeader.pktLength = sizeof(warpnetEthernetPktHeader) + sizeof(phyHeader) + length; |
---|
247 | coprocEthPktHeader.ethType = WARPNET_ETHTYPE_NODE2BER; |
---|
248 | |
---|
249 | txPktPtr = (void *)warpphy_getBuffAddr(WARPNET_NODE2COPROC_PKTBUFFINDEX); |
---|
250 | memcpy(txPktPtr, &(coprocEthPktHeader), sizeof(warpnetEthernetPktHeader)); |
---|
251 | txPktPtr += sizeof(warpnetEthernetPktHeader); |
---|
252 | memcpy(txPktPtr, (void*)&(txFrame.header), sizeof(phyHeader)); |
---|
253 | txPktPtr += sizeof(phyHeader); |
---|
254 | |
---|
255 | memcpy(txPktPtr, (void *)(warpphy_getBuffAddr(pktBuf_tx_DATA)+sizeof(phyHeader)), length); |
---|
256 | |
---|
257 | warpmac_prepPktToNetwork((void *)warpphy_getBuffAddr(WARPNET_NODE2COPROC_PKTBUFFINDEX), coprocEthPktHeader.pktLength); |
---|
258 | warpmac_startPktToNetwork(coprocEthPktHeader.pktLength); |
---|
259 | } |
---|
260 | return; |
---|
261 | } |
---|
262 | |
---|
263 | ///@brief Callback for the reception of bad wireless headers |
---|
264 | /// |
---|
265 | ///@param packet Pointer to received Macframe |
---|
266 | void phyRx_badHeader_callback() { |
---|
267 | unsigned char tmp_pktType; |
---|
268 | |
---|
269 | warpmac_incrementLEDLow(); |
---|
270 | tmp_pktType = * ( (unsigned char *)(warpphy_getBuffAddr(pktBuf_rx) + PKTHEADER_INDX_TYPE)); |
---|
271 | |
---|
272 | //Trust the packet type field if it's one of the three valid values; otherwise set it to an invalid value before dumping |
---|
273 | switch(tmp_pktType) { |
---|
274 | case PKTTYPE_AFDATA: |
---|
275 | perStruct_AF.numPkts_rx_badHdr++; |
---|
276 | break; |
---|
277 | case PKTTYPE_AFGHDATA: |
---|
278 | perStruct_AFGH.numPkts_rx_badHdr++; |
---|
279 | break; |
---|
280 | case PKTTYPE_DFGHDATA: |
---|
281 | perStruct_DFGH.numPkts_rx_badHdr++; |
---|
282 | break; |
---|
283 | case PKTTYPE_DFDATA: |
---|
284 | perStruct_DF.numPkts_rx_badHdr++; |
---|
285 | break; |
---|
286 | case PKTTYPE_NCMHOPDATA: |
---|
287 | perStruct_NCMHOP.numPkts_rx_badHdr++; |
---|
288 | break; |
---|
289 | case PKTTYPE_NCDATA: |
---|
290 | perStruct_NC.numPkts_rx_badHdr++; |
---|
291 | break; |
---|
292 | default: |
---|
293 | //Can't trust the type field; set the reported value to a known-invalid value |
---|
294 | perStruct_Other.numPkts_rx_badHdr++; |
---|
295 | tmp_pktType = PKTTYPE_INVALID; |
---|
296 | break; |
---|
297 | } |
---|
298 | |
---|
299 | if(doRxPHYdump) { |
---|
300 | Send_RxPHYdump(1, 1, 1, 1, tmp_pktType, 0); |
---|
301 | } |
---|
302 | |
---|
303 | return; |
---|
304 | } |
---|
305 | |
---|
306 | |
---|
307 | ///@brief Callback for the reception of good wireless headers |
---|
308 | /// |
---|
309 | ///This function then polls the PHY to determine if the entire packet passes checksum |
---|
310 | ///thereby triggering the transmission of the received data over Ethernet. |
---|
311 | ///@param packet Pointer to received Macframe |
---|
312 | int phyRx_goodHeader_callback(Macframe* packet) |
---|
313 | { |
---|
314 | int i; |
---|
315 | unsigned char state = PHYRXSTATUS_INCOMPLETE; |
---|
316 | |
---|
317 | void* txPktPtr; |
---|
318 | |
---|
319 | unsigned char rxPktType; |
---|
320 | |
---|
321 | warpnetCFO cfoStruct; |
---|
322 | |
---|
323 | unsigned char* hdrPtr1; |
---|
324 | unsigned char* hdrPtr2; |
---|
325 | |
---|
326 | hdrPtr1 = (unsigned char*)&(packet->header); |
---|
327 | hdrPtr2 = (unsigned char*)(warpphy_getBuffAddr(pktBuf_rx)); |
---|
328 | |
---|
329 | if( ((packet->header.srcAddr) != ID_SRC) | ((packet->header.destAddr) != ID_DST) | ((packet->header.relAddr) != ID_RLY)) { |
---|
330 | //Fake good header event; call the bad header handler, then return |
---|
331 | phyRx_badHeader_callback(); |
---|
332 | return 0; //let WARPMAC clear the PHY status bits once reception is done |
---|
333 | } |
---|
334 | |
---|
335 | rxPktType = (packet->header.pktType); |
---|
336 | |
---|
337 | if(reportCFOviaWarpnet) { |
---|
338 | cfoStruct.structID = STRUCTID_CFO; |
---|
339 | cfoStruct.nodeID = myID; |
---|
340 | cfoStruct.sequenceNumber = (packet->header.seqNum); |
---|
341 | |
---|
342 | //Read the coarse CFO estimate (ready after the preamble) |
---|
343 | cfoStruct.cfo_c = warpphy_getPreCFO_pkt_coarse(); |
---|
344 | |
---|
345 | //The dst doesn't actually use this CFO, but providing it here makes log parsing much easier |
---|
346 | cfoStruct.txCFO = warpphy_getPreCFO_pktBuf(pktBuf_tx_DATA); |
---|
347 | } |
---|
348 | |
---|
349 | if(reportBERviaWarpnet) { |
---|
350 | //Send a copy of the just-received packet to the BER calculating app |
---|
351 | //BER packets are built from: |
---|
352 | // Ethernet header [0:15] |
---|
353 | // MAC/PHY header [0:23] generated above |
---|
354 | // Actual transmitted payload (randomly generated and recorded in the PHY) [0:length-1] |
---|
355 | coprocEthPktHeader.pktLength = sizeof(warpnetEthernetPktHeader) + sizeof(phyHeader) + (packet->header.length); |
---|
356 | coprocEthPktHeader.ethType = WARPNET_ETHTYPE_NODE2BER; |
---|
357 | |
---|
358 | txPktPtr = (void *)warpphy_getBuffAddr(WARPNET_NODE2COPROC_PKTBUFFINDEX); |
---|
359 | memcpy(txPktPtr, &(coprocEthPktHeader), sizeof(warpnetEthernetPktHeader)); |
---|
360 | txPktPtr += sizeof(warpnetEthernetPktHeader); |
---|
361 | memcpy(txPktPtr, (void*)&(packet->header), sizeof(phyHeader)); |
---|
362 | txPktPtr += sizeof(phyHeader); |
---|
363 | } |
---|
364 | |
---|
365 | //Blocks until the PHY declares the payload good or bad |
---|
366 | state = warpmac_finishPhyRecv(); |
---|
367 | |
---|
368 | if(state & PHYRXSTATUS_GOOD) |
---|
369 | { |
---|
370 | warpmac_incrementLEDHigh(); |
---|
371 | cfoStruct.pktStatus = (unsigned int)ofdm_txrx_mimo_ReadReg_Rx_packet_done(); |
---|
372 | |
---|
373 | if(coopTesting) { |
---|
374 | if(rxPktType == PKTTYPE_AFDATA) { |
---|
375 | if(myID == ID_RLY) { |
---|
376 | perStruct_AF.numPkts_tx++; |
---|
377 | warpphy_AFrecordEnable(0); |
---|
378 | usleep(autoRespDelay_RlyTx_AF/10); |
---|
379 | warpmac_finishPhyXmit(); |
---|
380 | warpphy_AFrecordEnable(1); |
---|
381 | } |
---|
382 | perStruct_AF.numPkts_rx_good++; |
---|
383 | } |
---|
384 | else if(rxPktType == PKTTYPE_AFGHDATA) { |
---|
385 | if(myID == ID_RLY) { |
---|
386 | perStruct_AFGH.numPkts_tx++; |
---|
387 | warpphy_AFrecordEnable(0); |
---|
388 | usleep(autoRespDelay_RlyTx_AF/10); |
---|
389 | warpmac_finishPhyXmit(); |
---|
390 | warpphy_AFrecordEnable(1); |
---|
391 | } |
---|
392 | perStruct_AFGH.numPkts_rx_good++; |
---|
393 | } |
---|
394 | else if(rxPktType == PKTTYPE_DFDATA) { |
---|
395 | if(myID == ID_RLY) perStruct_DF.numPkts_tx++; |
---|
396 | perStruct_DF.numPkts_rx_good++; |
---|
397 | } |
---|
398 | else if(rxPktType == PKTTYPE_DFGHDATA) { |
---|
399 | if(myID == ID_RLY) perStruct_DFGH.numPkts_tx++; |
---|
400 | perStruct_DFGH.numPkts_rx_good++; |
---|
401 | } |
---|
402 | else if(rxPktType == PKTTYPE_NCMHOPDATA) { |
---|
403 | if(myID == ID_RLY) perStruct_NCMHOP.numPkts_tx++; |
---|
404 | perStruct_NCMHOP.numPkts_rx_good++; |
---|
405 | } |
---|
406 | else if(rxPktType == PKTTYPE_NCDATA) { |
---|
407 | perStruct_NC.numPkts_rx_good++; |
---|
408 | } |
---|
409 | } else { |
---|
410 | perStruct_NC.numPkts_rx_good++; |
---|
411 | } |
---|
412 | |
---|
413 | } |
---|
414 | else if(state & PHYRXSTATUS_BAD) |
---|
415 | { |
---|
416 | warpmac_incrementLEDLow(); |
---|
417 | cfoStruct.pktStatus = (unsigned int)ofdm_txrx_mimo_ReadReg_Rx_packet_done(); |
---|
418 | |
---|
419 | if(coopTesting) { |
---|
420 | if(rxPktType == PKTTYPE_AFDATA) |
---|
421 | perStruct_AF.numPkts_rx_goodHdrBadPyld++; |
---|
422 | else if(rxPktType == PKTTYPE_AFGHDATA) { |
---|
423 | if(myID == ID_RLY) { |
---|
424 | perStruct_AFGH.numPkts_tx++; |
---|
425 | warpphy_AFrecordEnable(0); |
---|
426 | usleep(autoRespDelay_RlyTx_AF/10); |
---|
427 | warpmac_finishPhyXmit(); |
---|
428 | warpphy_AFrecordEnable(1); |
---|
429 | } |
---|
430 | perStruct_AFGH.numPkts_rx_goodHdrBadPyld++; |
---|
431 | } |
---|
432 | else if(rxPktType == PKTTYPE_DFDATA) |
---|
433 | perStruct_DF.numPkts_rx_goodHdrBadPyld++; |
---|
434 | else if(rxPktType == PKTTYPE_DFGHDATA) { |
---|
435 | if(myID == ID_RLY) perStruct_DFGH.numPkts_tx++; |
---|
436 | perStruct_DFGH.numPkts_rx_goodHdrBadPyld++; |
---|
437 | } |
---|
438 | else if(rxPktType == PKTTYPE_NCMHOPDATA) |
---|
439 | perStruct_NCMHOP.numPkts_rx_goodHdrBadPyld++; |
---|
440 | else if(rxPktType == PKTTYPE_NCDATA) |
---|
441 | perStruct_NC.numPkts_rx_goodHdrBadPyld++; |
---|
442 | } else { |
---|
443 | perStruct_NC.numPkts_rx_goodHdrBadPyld++; |
---|
444 | } |
---|
445 | } |
---|
446 | |
---|
447 | if(reportCFOviaWarpnet) { |
---|
448 | //Read the final CFO estimate (ready after the payload) |
---|
449 | cfoStruct.cfo_p = warpphy_getPreCFO_pkt_pilots(); |
---|
450 | cfoStruct.cfo_b = warpphy_getPreCFO_pktBuf(pktBuf_rx); |
---|
451 | |
---|
452 | //Construct the CFO struct and send it to the server |
---|
453 | txEthPktHeader.pktLength = sizeof(warpnetEthernetPktHeader) + sizeof(warpnetControllerGroup) + sizeof(warpnetCFO); |
---|
454 | |
---|
455 | txPktPtr = (void *)warpphy_getBuffAddr(WARPNET_NODE2SVR_PKTBUFFINDEX); |
---|
456 | memcpy(txPktPtr, &(txEthPktHeader), sizeof(warpnetEthernetPktHeader)); |
---|
457 | memcpy(txPktPtr+sizeof(warpnetEthernetPktHeader), &(groupStruct), sizeof(warpnetControllerGroup)); |
---|
458 | memcpy(txPktPtr+sizeof(warpnetEthernetPktHeader)+sizeof(warpnetControllerGroup), &(cfoStruct), sizeof(warpnetCFO)); |
---|
459 | |
---|
460 | warpmac_prepPktToNetwork((void *)txPktPtr, txEthPktHeader.pktLength); |
---|
461 | warpmac_startPktToNetwork(txEthPktHeader.pktLength); |
---|
462 | } |
---|
463 | |
---|
464 | if(reportBERviaWarpnet) { |
---|
465 | memcpy(txPktPtr, (void *)(warpphy_getBuffAddr(pktBuf_rx)+sizeof(phyHeader)), packet->header.length); |
---|
466 | |
---|
467 | warpmac_prepPktToNetwork((void *)warpphy_getBuffAddr(WARPNET_NODE2COPROC_PKTBUFFINDEX), coprocEthPktHeader.pktLength); |
---|
468 | warpmac_startPktToNetwork(coprocEthPktHeader.pktLength); |
---|
469 | } |
---|
470 | |
---|
471 | //POM- only send PHYdump on GHBP or BH |
---|
472 | // if(doRxPHYdump && (state & PHYRXSTATUS_BAD) ) { |
---|
473 | if(doRxPHYdump) { |
---|
474 | Send_RxPHYdump(1, 1, 1, 1, packet->header.pktType, packet->header.seqNum); |
---|
475 | } |
---|
476 | |
---|
477 | //Return 1, indicating this function already waited for and cleared the PHY Rx status bits |
---|
478 | warpphy_clearRxPktStatus(); |
---|
479 | |
---|
480 | return 1; |
---|
481 | } |
---|
482 | |
---|
483 | void uartRecv_callback(unsigned char uartByte) |
---|
484 | { |
---|
485 | if(uartByte != 0x0) |
---|
486 | { |
---|
487 | xil_printf("(%c)\t", uartByte); |
---|
488 | |
---|
489 | switch(uartByte) |
---|
490 | { |
---|
491 | case ASCII_1: |
---|
492 | pktFullRate = HDR_FULLRATE_BPSK; |
---|
493 | xil_printf("Tx Full Rate = BPSK\r\n"); |
---|
494 | break; |
---|
495 | case ASCII_2: |
---|
496 | pktFullRate = HDR_FULLRATE_QPSK; |
---|
497 | xil_printf("Tx Full Rate = QPSK\r\n"); |
---|
498 | break; |
---|
499 | case ASCII_4: |
---|
500 | pktFullRate = HDR_FULLRATE_QAM_16; |
---|
501 | xil_printf("Tx Full Rate = 16-QAM\r\n"); |
---|
502 | break; |
---|
503 | case ASCII_6: |
---|
504 | pktFullRate = HDR_FULLRATE_QAM_64; |
---|
505 | xil_printf("Tx Full Rate = 64-QAM\r\n"); |
---|
506 | break; |
---|
507 | case ASCII_F: |
---|
508 | if(chan<14) chan++; |
---|
509 | warpphy_setChannel(GHZ_2, chan); |
---|
510 | xil_printf("Current channel: %d\r\n",chan); |
---|
511 | break; |
---|
512 | case ASCII_f: |
---|
513 | if(chan>1) chan--; |
---|
514 | warpphy_setChannel(GHZ_2, chan); |
---|
515 | xil_printf("Current channel: %d\r\n",chan); |
---|
516 | break; |
---|
517 | case ASCII_S: |
---|
518 | warpphy_setAntennaMode(TX_ANTMODE_SISO_ANTB, RX_ANTMODE_SISO_ANTB); |
---|
519 | xil_printf("SISO Mode - Radio 3 Selected\r\n"); |
---|
520 | break; |
---|
521 | case ASCII_s: |
---|
522 | warpphy_setAntennaMode(TX_ANTMODE_SISO_ANTA, RX_ANTMODE_SISO_ANTA); |
---|
523 | xil_printf("SISO Mode - Radio 2 Selected\r\n"); |
---|
524 | break; |
---|
525 | case ASCII_a: |
---|
526 | afScaling -= 128; |
---|
527 | mimo_ofdmRx_setAFTxScaling(afScaling); |
---|
528 | xil_printf("AF Scaling: %d\r\n", afScaling); |
---|
529 | break; |
---|
530 | case ASCII_A: |
---|
531 | afScaling += 128; |
---|
532 | mimo_ofdmRx_setAFTxScaling(afScaling); |
---|
533 | xil_printf("AF Scaling: %d\r\n", afScaling); |
---|
534 | break; |
---|
535 | case ASCII_G: |
---|
536 | agcTargetPwr++; |
---|
537 | ofdm_AGC_SetTarget(agcTargetPwr); |
---|
538 | xil_printf("AGC target: %d\r\n", agcTargetPwr); |
---|
539 | break; |
---|
540 | case ASCII_g: |
---|
541 | agcTargetPwr--; |
---|
542 | ofdm_AGC_SetTarget(agcTargetPwr); |
---|
543 | xil_printf("AGC target: %d\r\n", agcTargetPwr); |
---|
544 | break; |
---|
545 | case ASCII_X: |
---|
546 | warpphy_incrementTxScaling(10, 0); |
---|
547 | break; |
---|
548 | case ASCII_x: |
---|
549 | warpphy_incrementTxScaling(-10, 0); |
---|
550 | break; |
---|
551 | case ASCII_Y: |
---|
552 | warpphy_incrementTxScaling(0, 10); |
---|
553 | break; |
---|
554 | case ASCII_y: |
---|
555 | warpphy_incrementTxScaling(0, -10); |
---|
556 | break; |
---|
557 | case ASCII_W: |
---|
558 | FFT_offset = FFT_offset + 1; |
---|
559 | xil_printf("FFT_offset: %d\r\n", FFT_offset); |
---|
560 | mimo_ofdmRx_setFFTWindowOffset(FFT_offset); |
---|
561 | break; |
---|
562 | case ASCII_w: |
---|
563 | FFT_offset = (FFT_offset == 0) ? 0 : (FFT_offset - 1); |
---|
564 | xil_printf("FFT_offset: %d\r\n", FFT_offset); |
---|
565 | mimo_ofdmRx_setFFTWindowOffset(FFT_offset); |
---|
566 | break; |
---|
567 | case ASCII_D: |
---|
568 | energyThresh += 100; |
---|
569 | xil_printf("PktDet Thresh: %d\r\n", energyThresh); |
---|
570 | ofdm_txrx_mimo_WriteReg_Rx_PktDet_setThresh(energyThresh); |
---|
571 | break; |
---|
572 | |
---|
573 | case ASCII_d: |
---|
574 | energyThresh -= 100; |
---|
575 | xil_printf("PktDet Thresh: %d\r\n", energyThresh); |
---|
576 | ofdm_txrx_mimo_WriteReg_Rx_PktDet_setThresh(energyThresh); |
---|
577 | break; |
---|
578 | |
---|
579 | case ASCII_C: |
---|
580 | pktDet_corrThresh += 50; |
---|
581 | xil_printf("LongCorr: %d\r\n", pktDet_corrThresh); |
---|
582 | warpphy_setLongCorrThresh(pktDet_corrThresh); |
---|
583 | break; |
---|
584 | case ASCII_c: |
---|
585 | pktDet_corrThresh -= 50; |
---|
586 | xil_printf("LongCorr: %d\r\n", pktDet_corrThresh); |
---|
587 | warpphy_setLongCorrThresh(pktDet_corrThresh); |
---|
588 | break; |
---|
589 | |
---|
590 | case ASCII_T: |
---|
591 | txPower++; |
---|
592 | xil_printf("Tx Pwr: %d\r\n", txPower); |
---|
593 | warpphy_setTxPower(txPower); |
---|
594 | break; |
---|
595 | case ASCII_t: |
---|
596 | txPower--; |
---|
597 | xil_printf("Tx Pwr: %d\r\n", txPower); |
---|
598 | warpphy_setTxPower(txPower); |
---|
599 | break; |
---|
600 | |
---|
601 | default: |
---|
602 | xil_printf("Undefined command\r\n"); |
---|
603 | break; |
---|
604 | } |
---|
605 | } |
---|
606 | |
---|
607 | return; |
---|
608 | } |
---|
609 | |
---|
610 | void mgmtFromNetworkLayer_callback(Xuint32 length, char* payload) { |
---|
611 | |
---|
612 | void* rxPktPtr; |
---|
613 | void* txPktPtr; |
---|
614 | |
---|
615 | int i, numRxStructs; |
---|
616 | unsigned char rxSeqNum, theStructID; |
---|
617 | |
---|
618 | //Typed pointers for interpreting received structs |
---|
619 | warpnetEthernetPktHeader* pktHeader; |
---|
620 | warpnetControllerGroup* groupStructCopy; |
---|
621 | warpnetCommand* commandStruct; |
---|
622 | warpnetControl* controlStruct; |
---|
623 | warpnetPHYctrl* phyCtrlStruct; |
---|
624 | warpnetRequest* reqStruct; |
---|
625 | |
---|
626 | warpnetObservePER* perStructPtr; |
---|
627 | warpnetPERreq* perReqPtr; |
---|
628 | unsigned char tmpReqType; |
---|
629 | |
---|
630 | //Local ACK struct, used to send responses to the server |
---|
631 | warpnetAck ackStruct; |
---|
632 | |
---|
633 | //Interpret the received bytes as an Ethernet packet |
---|
634 | pktHeader = (warpnetEthernetPktHeader*)payload; |
---|
635 | |
---|
636 | if((pktHeader->ethType) != WARPNET_ETHTYPE_SVR2NODE) { |
---|
637 | //Should never happen; all management packets are type WARPNET_ETHTYPE_SVR2NODE |
---|
638 | return; |
---|
639 | } |
---|
640 | |
---|
641 | numRxStructs = pktHeader->numStructs; |
---|
642 | rxSeqNum = pktHeader->seqNum; |
---|
643 | |
---|
644 | //Initialize the rx pointer to the first byte past the Ethernet header |
---|
645 | rxPktPtr = (void*)(payload + sizeof(warpnetEthernetPktHeader)); |
---|
646 | |
---|
647 | //Iterate over each pair of warpnetControllerGroup / otherStruct in the server message |
---|
648 | for(i=0; i<numRxStructs; i++) { |
---|
649 | |
---|
650 | if( ( ((int)rxPktPtr) - ((int)payload) ) >= length) { |
---|
651 | xil_printf("Error! Mgmt pktLength too short for numStructs\r\n"); |
---|
652 | return; |
---|
653 | } |
---|
654 | |
---|
655 | //Alternate structs (starting with the first) are always warpnetControllerGroup |
---|
656 | groupStructCopy = (warpnetControllerGroup*)rxPktPtr; |
---|
657 | rxPktPtr += sizeof(warpnetControllerGroup); |
---|
658 | |
---|
659 | //Extract the first byte of the actual struct and interpret as the structID |
---|
660 | theStructID = *( (unsigned char *)rxPktPtr ); |
---|
661 | //xil_printf("Mgmt Pkt: StructID=0x%x\r\n", theStructID); |
---|
662 | |
---|
663 | switch(theStructID) |
---|
664 | { |
---|
665 | case STRUCTID_COMMAND: |
---|
666 | commandStruct = (warpnetCommand*)rxPktPtr; |
---|
667 | rxPktPtr += sizeof(warpnetCommand); |
---|
668 | |
---|
669 | if((commandStruct->nodeID) == myID) { |
---|
670 | |
---|
671 | //Send an ACK struct back to the server |
---|
672 | ackStruct.structID = STRUCTID_COMMAND_ACK; |
---|
673 | ackStruct.nodeID = myID; |
---|
674 | ackStruct.cmdID = commandStruct->cmdID; |
---|
675 | |
---|
676 | txEthPktHeader.pktLength = sizeof(warpnetEthernetPktHeader) + sizeof(warpnetControllerGroup) + sizeof(warpnetAck); |
---|
677 | txEthPktHeader.numStructs = 1; |
---|
678 | |
---|
679 | txPktPtr = (void *)warpphy_getBuffAddr(WARPNET_NODE2SVR_PKTBUFFINDEX); |
---|
680 | memcpy(txPktPtr, (void *)&(txEthPktHeader), sizeof(warpnetEthernetPktHeader)); |
---|
681 | memcpy(txPktPtr+sizeof(warpnetEthernetPktHeader), (void *)groupStructCopy, sizeof(warpnetControllerGroup)); |
---|
682 | memcpy(txPktPtr+sizeof(warpnetEthernetPktHeader)+sizeof(warpnetControllerGroup), (void *)&(ackStruct), sizeof(warpnetAck)); |
---|
683 | |
---|
684 | warpmac_prepPktToNetwork(txPktPtr, txEthPktHeader.pktLength); |
---|
685 | warpmac_startPktToNetwork(txEthPktHeader.pktLength); |
---|
686 | |
---|
687 | //Process the received struct |
---|
688 | processCommand(commandStruct); |
---|
689 | } |
---|
690 | break; |
---|
691 | |
---|
692 | case STRUCTID_CONTROL: |
---|
693 | controlStruct = (warpnetControl*)rxPktPtr; |
---|
694 | rxPktPtr += sizeof(warpnetControl); |
---|
695 | |
---|
696 | if((controlStruct->nodeID) == myID) { |
---|
697 | |
---|
698 | //Send an ACK struct back to the server |
---|
699 | ackStruct.structID = STRUCTID_CONTROL_ACK; |
---|
700 | ackStruct.nodeID = myID; |
---|
701 | |
---|
702 | txEthPktHeader.pktLength = sizeof(warpnetEthernetPktHeader) + sizeof(warpnetControllerGroup) + sizeof(warpnetAck); |
---|
703 | txEthPktHeader.numStructs = 1; |
---|
704 | |
---|
705 | txPktPtr = (void *)warpphy_getBuffAddr(WARPNET_NODE2SVR_PKTBUFFINDEX); |
---|
706 | memcpy(txPktPtr, (void *)&(txEthPktHeader), sizeof(warpnetEthernetPktHeader)); |
---|
707 | memcpy(txPktPtr+sizeof(warpnetEthernetPktHeader), (void *)groupStructCopy, sizeof(warpnetControllerGroup)); |
---|
708 | memcpy(txPktPtr+sizeof(warpnetEthernetPktHeader)+sizeof(warpnetControllerGroup), (void *)&(ackStruct), sizeof(warpnetAck)); |
---|
709 | |
---|
710 | warpmac_prepPktToNetwork(txPktPtr, txEthPktHeader.pktLength); |
---|
711 | warpmac_startPktToNetwork(txEthPktHeader.pktLength); |
---|
712 | |
---|
713 | //Process the received struct |
---|
714 | processControl(controlStruct); |
---|
715 | } |
---|
716 | break; |
---|
717 | case STRUCTID_PHYCTRL: |
---|
718 | phyCtrlStruct = (warpnetPHYctrl*)rxPktPtr; |
---|
719 | rxPktPtr += sizeof(warpnetPHYctrl); |
---|
720 | |
---|
721 | if((phyCtrlStruct->nodeID) == myID) { |
---|
722 | //Send an ACK struct back to the server |
---|
723 | ackStruct.structID = STRUCTID_PHYCTRL_ACK; |
---|
724 | ackStruct.nodeID = myID; |
---|
725 | |
---|
726 | txEthPktHeader.pktLength = sizeof(warpnetEthernetPktHeader) + sizeof(warpnetControllerGroup) + sizeof(warpnetAck); |
---|
727 | txEthPktHeader.numStructs = 1; |
---|
728 | |
---|
729 | txPktPtr = (void *)warpphy_getBuffAddr(WARPNET_NODE2SVR_PKTBUFFINDEX); |
---|
730 | memcpy(txPktPtr, (void *)&(txEthPktHeader), sizeof(warpnetEthernetPktHeader)); |
---|
731 | memcpy(txPktPtr+sizeof(warpnetEthernetPktHeader), (void *)groupStructCopy, sizeof(warpnetControllerGroup)); |
---|
732 | memcpy(txPktPtr+sizeof(warpnetEthernetPktHeader)+sizeof(warpnetControllerGroup), (void *)&(ackStruct), sizeof(warpnetAck)); |
---|
733 | |
---|
734 | warpmac_prepPktToNetwork(txPktPtr, txEthPktHeader.pktLength); |
---|
735 | warpmac_startPktToNetwork(txEthPktHeader.pktLength); |
---|
736 | |
---|
737 | //Process the received struct |
---|
738 | processPHYControl(phyCtrlStruct); |
---|
739 | } |
---|
740 | break; |
---|
741 | case STRUCTID_OBSERVE_PER_REQ: |
---|
742 | perReqPtr = (warpnetPERreq*)rxPktPtr; |
---|
743 | rxPktPtr += sizeof(warpnetPERreq); |
---|
744 | |
---|
745 | if((perReqPtr->nodeID) == myID) { |
---|
746 | |
---|
747 | if(coopTesting) { |
---|
748 | tmpReqType = (unsigned char)perReqPtr->reqType; |
---|
749 | |
---|
750 | if(tmpReqType == PKTTYPE_DFDATA) |
---|
751 | perStructPtr = &perStruct_DF; |
---|
752 | else if(tmpReqType == PKTTYPE_AFDATA) |
---|
753 | perStructPtr = &perStruct_AF; |
---|
754 | else if(tmpReqType == PKTTYPE_AFGHDATA) |
---|
755 | perStructPtr = &perStruct_AFGH; |
---|
756 | else if(tmpReqType == PKTTYPE_DFGHDATA) |
---|
757 | perStructPtr = &perStruct_DFGH; |
---|
758 | else if(tmpReqType == PKTTYPE_NCMHOPDATA) |
---|
759 | perStructPtr = &perStruct_NCMHOP; |
---|
760 | else if(tmpReqType == PKTTYPE_INVALID) |
---|
761 | perStructPtr = &perStruct_Other; |
---|
762 | else //if(tmpReqType == PKTTYPE_NCDATA) |
---|
763 | perStructPtr = &perStruct_NC; |
---|
764 | |
---|
765 | perStructPtr->reqType = tmpReqType; |
---|
766 | } else { |
---|
767 | perStructPtr = &perStruct_NC; |
---|
768 | } |
---|
769 | |
---|
770 | perStructPtr->reqNum = (unsigned char)perReqPtr->reqNum; |
---|
771 | |
---|
772 | txEthPktHeader.pktLength = sizeof(warpnetEthernetPktHeader) + sizeof(warpnetControllerGroup) + sizeof(warpnetObservePER); |
---|
773 | txEthPktHeader.numStructs = 1; |
---|
774 | |
---|
775 | txPktPtr = (void *)warpphy_getBuffAddr(WARPNET_NODE2SVR_PKTBUFFINDEX); |
---|
776 | memcpy(txPktPtr, (void *)&(txEthPktHeader), sizeof(warpnetEthernetPktHeader)); |
---|
777 | memcpy(txPktPtr+sizeof(warpnetEthernetPktHeader), (void *)groupStructCopy, sizeof(warpnetControllerGroup)); |
---|
778 | memcpy(txPktPtr+sizeof(warpnetEthernetPktHeader)+sizeof(warpnetControllerGroup), (void *)perStructPtr, sizeof(warpnetObservePER)); |
---|
779 | |
---|
780 | warpmac_prepPktToNetwork(txPktPtr, txEthPktHeader.pktLength); |
---|
781 | warpmac_startPktToNetwork(txEthPktHeader.pktLength); |
---|
782 | } |
---|
783 | break; |
---|
784 | |
---|
785 | default: |
---|
786 | //Unrecognized structID; do nothing |
---|
787 | //xil_printf("Unknown structID: 0x%x\r\n", theStructID); |
---|
788 | break; |
---|
789 | }//END switch(theStructID) |
---|
790 | |
---|
791 | |
---|
792 | }//END for(0...numStructs-1) |
---|
793 | |
---|
794 | return; |
---|
795 | } |
---|
796 | |
---|
797 | void processPHYControl(warpnetPHYctrl* phyCtrlStruct) { |
---|
798 | //Interpret the PHY control parameters |
---|
799 | //PHYCtrol params: |
---|
800 | //param0: txStartOut delay |
---|
801 | //param1: artificial txCFO |
---|
802 | //param2: minPilotChanMag |
---|
803 | //param3: |
---|
804 | // [0-0x01]: PHYCTRL_BER_EN: enable BER reporting |
---|
805 | // [1-0x02]: PHYCTRL_CFO_EN: enable CFO reporting |
---|
806 | // [2-0x04]: PHYCTRL_PHYDUMP_EN: enable Rx PHY dumping |
---|
807 | // [3-0x08]: PHYTRCL_EXTPKTDET_EN: use only ext pkt det |
---|
808 | // [4-0x10]: PHYCTRL_COOP_EN: 0=nonCoop, 1=coopMode |
---|
809 | // [5-0x20]: PHYCTRL_CFO_CORR_EN: 0=bypass CFO correction, 1=enable CFO correction |
---|
810 | // [6-0x40]: PHYCTRL_SWAP_ANT: 0=AntA, 1=AntA_Swapped |
---|
811 | //param4: |
---|
812 | // [ 7:0]: src re-Tx delay |
---|
813 | // [ 7:0]: relay AF Tx delay (only used when in COOP_TESTING) |
---|
814 | // [15:8]: relay DF Tx delay (only used when in COOP_TESTING) |
---|
815 | //param5: |
---|
816 | // [17: 0]: AGC IIR coef FB |
---|
817 | //param6: (0 ignores) |
---|
818 | // [31:16]: H_BA minEstMag (UFix16_15) |
---|
819 | // [15: 0]: H_AA minEstMag (UFix16_15) |
---|
820 | //param7: (0 ignores) |
---|
821 | // [27:16]: AF blank stop |
---|
822 | // [11: 0]: AF blank start |
---|
823 | //param8: |
---|
824 | // [17: 0]: AGC IIR coef g |
---|
825 | //param9: (Tx pkt types) |
---|
826 | // [31: 0]: OR'd combination of PHYCTRL_TX_* |
---|
827 | |
---|
828 | int i; |
---|
829 | unsigned int txCFO; |
---|
830 | unsigned int minChanMag; |
---|
831 | unsigned int configBits; |
---|
832 | |
---|
833 | //param0 |
---|
834 | pktDetBypass_txStartDly = (phyCtrlStruct->param0) & 0xFF; |
---|
835 | mimo_ofdmTx_setDelays(autoRespDelay_SrcReTx, 0, pktDetBypass_txStartDly); |
---|
836 | |
---|
837 | //param1 |
---|
838 | txCFO = phyCtrlStruct->param1; |
---|
839 | if(txCFO != 0) { |
---|
840 | warpphy_setPreCFO_pktBuf(pktBuf_tx_DATA, txCFO); |
---|
841 | mimo_ofdmTx_setControlBits(mimo_ofdmTx_getOptions() | (TX_ALWAYS_USE_PRECFO)); |
---|
842 | } else { |
---|
843 | warpphy_setPreCFO_pktBuf(pktBuf_tx_DATA, 0); |
---|
844 | mimo_ofdmTx_setControlBits(mimo_ofdmTx_getOptions() & (~TX_ALWAYS_USE_PRECFO)); |
---|
845 | } |
---|
846 | |
---|
847 | //param2 |
---|
848 | minChanMag = (phyCtrlStruct->param2) & 0xFFF; |
---|
849 | mimo_ofdmRx_setPilotCalcParams(minChanMag); |
---|
850 | |
---|
851 | //param3 |
---|
852 | configBits = (phyCtrlStruct->param3) & 0xFFFF; |
---|
853 | |
---|
854 | reportCFOviaWarpnet = 0; |
---|
855 | reportBERviaWarpnet = 0; |
---|
856 | doRxPHYdump = 0; |
---|
857 | coopTesting = 0; |
---|
858 | nonCoopTesting = 0; |
---|
859 | |
---|
860 | if( configBits & 0x1 ) { |
---|
861 | reportBERviaWarpnet = 1; |
---|
862 | } else { |
---|
863 | reportBERviaWarpnet = 0; |
---|
864 | } |
---|
865 | |
---|
866 | if( configBits & 0x2 ) { |
---|
867 | reportCFOviaWarpnet = 1; |
---|
868 | } else { |
---|
869 | reportCFOviaWarpnet = 0; |
---|
870 | } |
---|
871 | |
---|
872 | if( configBits & 0x4 ) { |
---|
873 | doRxPHYdump = 1; |
---|
874 | } else { |
---|
875 | doRxPHYdump = 0; |
---|
876 | } |
---|
877 | |
---|
878 | if( configBits & 0x8 ) { |
---|
879 | //Bypass long correlation checking |
---|
880 | ofdm_txrx_mimo_WriteReg_Rx_ControlBits(0, ofdm_txrx_mimo_ReadReg_Rx_ControlBits(0) & ~(REQ_LONG_CORR)); |
---|
881 | |
---|
882 | //Set the correlation and energy thresholds to max values (effectively disabling them) |
---|
883 | warpphy_setLongCorrThresh(0xFFFF); |
---|
884 | ofdm_txrx_mimo_WriteReg_Rx_PktDet_setThresh(0xFFFF); |
---|
885 | |
---|
886 | //Enable external pktDet input and bypass coarse CFO (it uses the long correlator too) |
---|
887 | ofdm_txrx_mimo_WriteReg_Rx_PktDet_extDetEn(1); |
---|
888 | ofdm_txrx_mimo_WriteReg_Rx_ControlBits(0, ofdm_txrx_mimo_ReadReg_Rx_ControlBits(0) | (BYPASS_CARR_REC)); |
---|
889 | warpphy_setPreCFOoptions( (PRECFO_USEPILOTS) ); |
---|
890 | |
---|
891 | //Set the pktDet->payload delay |
---|
892 | mimo_ofdmRx_setPktDetDly(48); //works together with phyCtrl0.param0 = 51 to line up coop tx/rx with fake pkt det |
---|
893 | } else { |
---|
894 | //Reset the various pktDetection-dependent parameters to their defaults |
---|
895 | ofdm_txrx_mimo_WriteReg_Rx_PktDet_extDetEn(0); |
---|
896 | ofdm_txrx_mimo_WriteReg_Rx_ControlBits(0, ofdm_txrx_mimo_ReadReg_Rx_ControlBits(0) | (REQ_LONG_CORR)); |
---|
897 | ofdm_txrx_mimo_WriteReg_Rx_ControlBits(0, ofdm_txrx_mimo_ReadReg_Rx_ControlBits(0) & ~(BYPASS_CARR_REC)); |
---|
898 | warpphy_setPreCFOoptions( (PRECFO_USECOARSE | PRECFO_USEPILOTS) ); |
---|
899 | warpphy_setLongCorrThresh(pktDet_corrThresh); |
---|
900 | ofdm_txrx_mimo_WriteReg_Rx_PktDet_setThresh(energyThresh); |
---|
901 | mimo_ofdmRx_setPktDetDly(124); |
---|
902 | } |
---|
903 | |
---|
904 | if( configBits & 0x10 ) { |
---|
905 | //Enable cooperative testing |
---|
906 | coopTesting = 1; |
---|
907 | nonCoopTesting = 0; |
---|
908 | warpphy_setTxAntennaSwap(TX_ANTMODE_ALAMOUTI_ANTA); |
---|
909 | ofdm_txrx_mimo_WriteReg_Rx_ControlBits(0, ofdm_txrx_mimo_ReadReg_Rx_ControlBits(0) | (EXT_PKTDETRESET_EN)); |
---|
910 | } else { |
---|
911 | //Disable cooperative testing |
---|
912 | coopTesting = 0; |
---|
913 | nonCoopTesting = 1; |
---|
914 | warpphy_setTxAntennaSwap(TX_ANTMODE_ALAMOUTI_ANTA); |
---|
915 | ofdm_txrx_mimo_WriteReg_Rx_ControlBits(0, ofdm_txrx_mimo_ReadReg_Rx_ControlBits(0) & ~(EXT_PKTDETRESET_EN)); |
---|
916 | } |
---|
917 | |
---|
918 | if( configBits & 0x20 ) { |
---|
919 | ofdm_txrx_mimo_WriteReg_Rx_ControlBits(0, ofdm_txrx_mimo_ReadReg_Rx_ControlBits(0) & ~(BYPASS_CARR_REC)); |
---|
920 | warpphy_setPreCFOoptions( (PRECFO_USECOARSE | PRECFO_USEPILOTS) ); |
---|
921 | // warpphy_setPreCFOoptions( (PRECFO_USECOARSE) ); //POM- disabling pilot estimator for now! |
---|
922 | } else { |
---|
923 | ofdm_txrx_mimo_WriteReg_Rx_ControlBits(0, ofdm_txrx_mimo_ReadReg_Rx_ControlBits(0) | BYPASS_CARR_REC); |
---|
924 | warpphy_setPreCFOoptions( (PRECFO_USEPILOTS) ); |
---|
925 | } |
---|
926 | |
---|
927 | if( configBits & 0x40 ) { |
---|
928 | warpphy_setTxAntennaSwap(TX_ANTMODE_ALAMOUTI_ANTA_SWAPPED); |
---|
929 | } else { |
---|
930 | warpphy_setTxAntennaSwap(TX_ANTMODE_ALAMOUTI_ANTA); |
---|
931 | } |
---|
932 | |
---|
933 | //param4 |
---|
934 | //Update role-specific parameters |
---|
935 | if(myID == ID_SRC) { |
---|
936 | autoRespDelay_SrcReTx = (phyCtrlStruct->param4) & 0xFF; |
---|
937 | mimo_ofdmTx_setDelays(autoRespDelay_SrcReTx, 0, pktDetBypass_txStartDly); |
---|
938 | } |
---|
939 | else if(myID == ID_RLY) { |
---|
940 | autoRespDelay_RlyTx_AF = ((phyCtrlStruct->param4) & 0xFF); |
---|
941 | autoRespDelay_RlyTx_DF = (((phyCtrlStruct->param4) & 0xFF00)>>8); |
---|
942 | } |
---|
943 | |
---|
944 | //param5: IIR coef FB //Fix18_17 |
---|
945 | if((phyCtrlStruct->param5) > 0) { |
---|
946 | agc_iirCoef_fb = ((phyCtrlStruct->param5) & 0x3FFFF); |
---|
947 | XIo_Out32(XPAR_OFDM_AGC_MIMO_PLBW_0_MEMMAP_DCO_IIR_COEF_FB, agc_iirCoef_fb); |
---|
948 | } |
---|
949 | |
---|
950 | //param6: chan est mag masking |
---|
951 | if((phyCtrlStruct->param6) > 0) { |
---|
952 | ofdm_txrx_mimo_WriteReg_Rx_ControlBits(0, ofdm_txrx_mimo_ReadReg_Rx_ControlBits(0) | CHANMAG_MASKING_EN); |
---|
953 | warpphy_setChanEstMinMags( (phyCtrlStruct->param6) );//((phyCtrlStruct->param6) & 0xFFFF), ( ((phyCtrlStruct->param6) & 0xFFFF0000)>>16) ); |
---|
954 | } else { |
---|
955 | ofdm_txrx_mimo_WriteReg_Rx_ControlBits(0, ofdm_txrx_mimo_ReadReg_Rx_ControlBits(0) & ~(CHANMAG_MASKING_EN)); |
---|
956 | warpphy_setChanEstMinMags(0);//, 0); |
---|
957 | } |
---|
958 | |
---|
959 | //param7: AF interval masking |
---|
960 | if((phyCtrlStruct->param7) > 0) { |
---|
961 | //Set AF blanking interval (set to zeros to disable) |
---|
962 | warpphy_setAFblanking((phyCtrlStruct->param7) & 0x0FFF, ( ((phyCtrlStruct->param7) & 0x0FFF0000)>>16)); |
---|
963 | } else { |
---|
964 | //Set AF blanking interval (set to zeros to disable) |
---|
965 | warpphy_setAFblanking(0, 0); |
---|
966 | } |
---|
967 | |
---|
968 | //param8: IIR coef G //UFix18_17 |
---|
969 | if((phyCtrlStruct->param8) > 0) { |
---|
970 | agc_iirCoef_g = ((phyCtrlStruct->param8) & 0x3FFFF); |
---|
971 | XIo_Out32(XPAR_OFDM_AGC_MIMO_PLBW_0_MEMMAP_DCO_IIR_COEF_GAIN, agc_iirCoef_g); |
---|
972 | } |
---|
973 | |
---|
974 | //param9: Scheme en/disable |
---|
975 | if((phyCtrlStruct->param9) > 0x0) { |
---|
976 | numPktTypes = 0; |
---|
977 | |
---|
978 | if((phyCtrlStruct->param9) & 0x01) {pktTypesToTx[numPktTypes] = PKTTYPE_NCDATA; numPktTypes++;} |
---|
979 | if((phyCtrlStruct->param9) & 0x02) {pktTypesToTx[numPktTypes] = PKTTYPE_DFDATA; numPktTypes++;} |
---|
980 | if((phyCtrlStruct->param9) & 0x04) {pktTypesToTx[numPktTypes] = PKTTYPE_AFDATA; numPktTypes++;} |
---|
981 | if((phyCtrlStruct->param9) & 0x08) {pktTypesToTx[numPktTypes] = PKTTYPE_AFGHDATA; numPktTypes++;} |
---|
982 | if((phyCtrlStruct->param9) & 0x10) {pktTypesToTx[numPktTypes] = PKTTYPE_DFGHDATA; numPktTypes++;} |
---|
983 | if((phyCtrlStruct->param9) & 0x20) {pktTypesToTx[numPktTypes] = PKTTYPE_NCMHOPDATA; numPktTypes++;} |
---|
984 | |
---|
985 | //Safety check- if no type was enabled, revert to NC only |
---|
986 | if(numPktTypes == 0) {pktTypesToTx[numPktTypes] = PKTTYPE_NCDATA; numPktTypes = 1;} |
---|
987 | } |
---|
988 | |
---|
989 | setupNodeBehaviors(); |
---|
990 | return; |
---|
991 | } |
---|
992 | |
---|
993 | void processControl(warpnetControl* controlStruct) { |
---|
994 | unsigned char newMod, newCode; |
---|
995 | |
---|
996 | pktGen_length = controlStruct->pktGen_length; |
---|
997 | pktGen_period = controlStruct->pktGen_period; |
---|
998 | |
---|
999 | txPower = ((controlStruct->txPower) & 0x3F); |
---|
1000 | warpphy_setTxPower(txPower); |
---|
1001 | |
---|
1002 | newMod = ((controlStruct->modOrderPayload) & 0xF); |
---|
1003 | newCode = (((controlStruct->modOrderPayload) & 0xF0)>>4); |
---|
1004 | |
---|
1005 | switch(newMod) { |
---|
1006 | case 1: |
---|
1007 | pktFullRate = HDR_FULLRATE_BPSK; |
---|
1008 | break; |
---|
1009 | case 2: |
---|
1010 | pktFullRate = HDR_FULLRATE_QPSK; |
---|
1011 | break; |
---|
1012 | case 4: |
---|
1013 | pktFullRate = HDR_FULLRATE_QAM_16; |
---|
1014 | break; |
---|
1015 | case 6: |
---|
1016 | pktFullRate = HDR_FULLRATE_QAM_64; |
---|
1017 | break; |
---|
1018 | default: |
---|
1019 | pktFullRate = HDR_FULLRATE_QPSK; |
---|
1020 | break; |
---|
1021 | } |
---|
1022 | |
---|
1023 | switch(newCode) { |
---|
1024 | case HDR_CODE_RATE_12: |
---|
1025 | pktCodeRate = HDR_CODE_RATE_12; |
---|
1026 | break; |
---|
1027 | case HDR_CODE_RATE_23: |
---|
1028 | pktCodeRate = HDR_CODE_RATE_23; |
---|
1029 | break; |
---|
1030 | case HDR_CODE_RATE_34: |
---|
1031 | pktCodeRate = HDR_CODE_RATE_34; |
---|
1032 | break; |
---|
1033 | case HDR_CODE_RATE_NONE: |
---|
1034 | pktCodeRate = HDR_CODE_RATE_NONE; |
---|
1035 | break; |
---|
1036 | default: |
---|
1037 | pktCodeRate = HDR_CODE_RATE_NONE; |
---|
1038 | break; |
---|
1039 | } |
---|
1040 | |
---|
1041 | switch(controlStruct->modOrderHeader) { |
---|
1042 | case 1: |
---|
1043 | warpmac_setBaseRate(BPSK); |
---|
1044 | break; |
---|
1045 | case 2: |
---|
1046 | warpmac_setBaseRate(QPSK); |
---|
1047 | break; |
---|
1048 | default: |
---|
1049 | warpmac_setBaseRate(QPSK); |
---|
1050 | break; |
---|
1051 | } |
---|
1052 | |
---|
1053 | chan = controlStruct->channel; |
---|
1054 | warpphy_setChannel(GHZ_2, chan); |
---|
1055 | } |
---|
1056 | |
---|
1057 | void processCommand(warpnetCommand* commandStruct) { |
---|
1058 | switch(commandStruct->cmdID){ |
---|
1059 | case COMMANDID_STARTTRIAL: |
---|
1060 | warpmac_startPacketGeneration(pktGen_length, pktGen_period); |
---|
1061 | break; |
---|
1062 | case COMMANDID_STOPTRIAL: |
---|
1063 | warpmac_stopPacketGeneration(); |
---|
1064 | break; |
---|
1065 | case COMMANDID_RESET_PER: |
---|
1066 | curPktType = PKTTYPE_NCDATA; |
---|
1067 | |
---|
1068 | perStruct_NC.numPkts_tx = 0; |
---|
1069 | perStruct_NC.numPkts_rx_good = 0; |
---|
1070 | perStruct_NC.numPkts_rx_goodHdrBadPyld = 0; |
---|
1071 | perStruct_NC.numPkts_rx_badHdr = 0; |
---|
1072 | |
---|
1073 | if(coopTesting) { |
---|
1074 | perStruct_DF.numPkts_tx = 0; |
---|
1075 | perStruct_DF.numPkts_rx_good = 0; |
---|
1076 | perStruct_DF.numPkts_rx_goodHdrBadPyld = 0; |
---|
1077 | perStruct_DF.numPkts_rx_badHdr = 0; |
---|
1078 | |
---|
1079 | perStruct_AF.numPkts_tx = 0; |
---|
1080 | perStruct_AF.numPkts_rx_good = 0; |
---|
1081 | perStruct_AF.numPkts_rx_goodHdrBadPyld = 0; |
---|
1082 | perStruct_AF.numPkts_rx_badHdr = 0; |
---|
1083 | |
---|
1084 | perStruct_AFGH.numPkts_tx = 0; |
---|
1085 | perStruct_AFGH.numPkts_rx_good = 0; |
---|
1086 | perStruct_AFGH.numPkts_rx_goodHdrBadPyld = 0; |
---|
1087 | perStruct_AFGH.numPkts_rx_badHdr = 0; |
---|
1088 | |
---|
1089 | perStruct_DFGH.numPkts_tx = 0; |
---|
1090 | perStruct_DFGH.numPkts_rx_good = 0; |
---|
1091 | perStruct_DFGH.numPkts_rx_goodHdrBadPyld = 0; |
---|
1092 | perStruct_DFGH.numPkts_rx_badHdr = 0; |
---|
1093 | |
---|
1094 | perStruct_NCMHOP.numPkts_tx = 0; |
---|
1095 | perStruct_NCMHOP.numPkts_rx_good = 0; |
---|
1096 | perStruct_NCMHOP.numPkts_rx_goodHdrBadPyld = 0; |
---|
1097 | perStruct_NCMHOP.numPkts_rx_badHdr = 0; |
---|
1098 | |
---|
1099 | perStruct_Other.numPkts_tx = 0; |
---|
1100 | perStruct_Other.numPkts_rx_good = 0; |
---|
1101 | perStruct_Other.numPkts_rx_goodHdrBadPyld = 0; |
---|
1102 | perStruct_Other.numPkts_rx_badHdr = 0; |
---|
1103 | } |
---|
1104 | break; |
---|
1105 | default: |
---|
1106 | //Unknown command; do nothing |
---|
1107 | xil_printf("processCommand: unknown command: 0x%x\r\n", commandStruct->cmdID); |
---|
1108 | break; |
---|
1109 | } |
---|
1110 | |
---|
1111 | return; |
---|
1112 | } |
---|
1113 | |
---|
1114 | //This function should only be called after the packet payload status is known! |
---|
1115 | void Send_RxPHYdump(int sendEVMperSC, int sendEVMperSym, int sendChanEstAA, int sendChanEstBA, unsigned char pktType, unsigned short seqNum) { |
---|
1116 | void* txPktPtr; |
---|
1117 | void* txPktPtr_d; |
---|
1118 | int i; |
---|
1119 | |
---|
1120 | txPktPtr = (void *)warpphy_getBuffAddr(WARPNET_NODE2COPROC_PKTBUFFINDEX); |
---|
1121 | |
---|
1122 | coprocEthPktHeader.ethType = WARPNET_ETHTYPE_NODE2COPROC; |
---|
1123 | coprocEthPktHeader.pktLength = sizeof(warpnetEthernetPktHeader) + sizeof(warpnetRxPHYdump); |
---|
1124 | rxPHYdumpStruct.includedData = 0; |
---|
1125 | rxPHYdumpStruct.rxStatus = mimo_ofdmRx_getPktStatus(); |
---|
1126 | rxPHYdumpStruct.rssi = (ofdm_txrx_mimo_ReadReg_Rx_PktDet_midPktRSSI_antA()); |
---|
1127 | rxPHYdumpStruct.rxGains = (ofdm_txrx_mimo_ReadReg_Rx_Gains(0)); |
---|
1128 | rxPHYdumpStruct.pktType = pktType; |
---|
1129 | rxPHYdumpStruct.seqNum = seqNum; |
---|
1130 | rxPHYdumpStruct.cfoEst_coarse = warpphy_getPreCFO_pkt_coarse(); |
---|
1131 | rxPHYdumpStruct.cfoEst_pilots = warpphy_getPreCFO_pkt_pilots(); |
---|
1132 | |
---|
1133 | memcpy(txPktPtr, &(coprocEthPktHeader), sizeof(warpnetEthernetPktHeader)); |
---|
1134 | txPktPtr_d = txPktPtr + sizeof(warpnetEthernetPktHeader); |
---|
1135 | txPktPtr += sizeof(warpnetEthernetPktHeader) + sizeof(warpnetRxPHYdump); |
---|
1136 | |
---|
1137 | if(sendEVMperSC) { |
---|
1138 | coprocEthPktHeader.pktLength += RXPHYDUMP_SIZE_EVMPERSC; |
---|
1139 | rxPHYdumpStruct.includedData |= RXPHYDUMP_INCLUDE_EVMPERSC; |
---|
1140 | |
---|
1141 | memcpy(txPktPtr, (void *)XPAR_OFDM_TXRX_MIMO_PLBW_0_MEMMAP_EVM_PERSC, RXPHYDUMP_SIZE_EVMPERSC); |
---|
1142 | txPktPtr += RXPHYDUMP_SIZE_EVMPERSC; |
---|
1143 | } |
---|
1144 | if(sendEVMperSym) { |
---|
1145 | coprocEthPktHeader.pktLength += RXPHYDUMP_SIZE_EVMPERSYM; |
---|
1146 | rxPHYdumpStruct.includedData |= RXPHYDUMP_INCLUDE_EVMPERSYM; |
---|
1147 | |
---|
1148 | memcpy(txPktPtr, (void *)XPAR_OFDM_TXRX_MIMO_PLBW_0_MEMMAP_EVM_PERSYM, RXPHYDUMP_SIZE_EVMPERSYM); |
---|
1149 | txPktPtr += RXPHYDUMP_SIZE_EVMPERSYM; |
---|
1150 | } |
---|
1151 | if(sendChanEstAA) { |
---|
1152 | coprocEthPktHeader.pktLength += RXPHYDUMP_SIZE_CHANEST; |
---|
1153 | rxPHYdumpStruct.includedData |= RXPHYDUMP_INCLUDE_CHANESTAA; |
---|
1154 | |
---|
1155 | //A-A estimates are the first set in the buffer |
---|
1156 | memcpy(txPktPtr, (void *)XPAR_OFDM_TXRX_MIMO_PLBW_0_MEMMAP_CHANNELESTIMATES, RXPHYDUMP_SIZE_CHANEST); |
---|
1157 | txPktPtr += RXPHYDUMP_SIZE_CHANEST; |
---|
1158 | } |
---|
1159 | if(sendChanEstBA) { |
---|
1160 | coprocEthPktHeader.pktLength += RXPHYDUMP_SIZE_CHANEST; |
---|
1161 | rxPHYdumpStruct.includedData |= RXPHYDUMP_INCLUDE_CHANESTBA; |
---|
1162 | |
---|
1163 | //B-A estimates are the third set in the buffer (after AA and AB) |
---|
1164 | memcpy(txPktPtr, (void *)(XPAR_OFDM_TXRX_MIMO_PLBW_0_MEMMAP_CHANNELESTIMATES+2*RXPHYDUMP_SIZE_CHANEST), RXPHYDUMP_SIZE_CHANEST); |
---|
1165 | txPktPtr += RXPHYDUMP_SIZE_CHANEST; |
---|
1166 | } |
---|
1167 | |
---|
1168 | memcpy(txPktPtr_d, &(rxPHYdumpStruct), sizeof(warpnetRxPHYdump)); |
---|
1169 | |
---|
1170 | warpmac_prepPktToNetwork((void *)warpphy_getBuffAddr(WARPNET_NODE2COPROC_PKTBUFFINDEX), coprocEthPktHeader.pktLength); |
---|
1171 | warpmac_startPktToNetwork(coprocEthPktHeader.pktLength); |
---|
1172 | } |
---|
1173 | |
---|
1174 | ///@brief Main function |
---|
1175 | /// |
---|
1176 | ///This function configures MAC parameters, enables the underlying frameworks, and then loops forever. |
---|
1177 | int main(){ |
---|
1178 | xil_printf("AFDF_CHAR v15.22\r\n"); |
---|
1179 | |
---|
1180 | int i; |
---|
1181 | |
---|
1182 | curPktType = PKTTYPE_NCDATA; |
---|
1183 | |
---|
1184 | chan = 9; |
---|
1185 | |
---|
1186 | pktBuf_rx = 1; |
---|
1187 | pktBuf_tx_DATA = 0; |
---|
1188 | pktBuf_emac_rx = 3; |
---|
1189 | pktBuf_tx_AF = 31; |
---|
1190 | |
---|
1191 | txSequences[ID_SRC] = 0; |
---|
1192 | txSequences[ID_DST] = 0; |
---|
1193 | txSequences[ID_RLY] = 0; |
---|
1194 | |
---|
1195 | reportCFOviaWarpnet = 0; |
---|
1196 | reportBERviaWarpnet = 0; |
---|
1197 | doRxPHYdump = 0; |
---|
1198 | nonCoopTesting = 1; |
---|
1199 | coopTesting = 0; |
---|
1200 | |
---|
1201 | pktGen_length = 1412; |
---|
1202 | pktGen_period = 10000; |
---|
1203 | |
---|
1204 | //Over the air delays (S->R delay = 0): |
---|
1205 | autoRespDelay_SrcReTx = 251; |
---|
1206 | autoRespDelay_RlyTx_DF = 104; //was 52 - doubled precision in v15.14 |
---|
1207 | autoRespDelay_RlyTx_AF = 104; //was 52 - doubled precision in v15.14 |
---|
1208 | |
---|
1209 | //Emulator delays (S->R delay = 1µs) |
---|
1210 | autoRespDelay_SrcReTx = 251; |
---|
1211 | autoRespDelay_RlyTx_DF = 94;//was 47 - doubled precision in v15.14 |
---|
1212 | autoRespDelay_RlyTx_AF = 94;//was 47 - doubled precision in v15.14 |
---|
1213 | pktDetBypass_txStartDly = 80; |
---|
1214 | |
---|
1215 | //Set the full-rate modulation to QPSK by default |
---|
1216 | pktFullRate = HDR_FULLRATE_QPSK; |
---|
1217 | pktCodeRate = CODE_RATE_12; |
---|
1218 | |
---|
1219 | txPower = 0x3f; |
---|
1220 | warpphy_setTxPower(txPower); |
---|
1221 | |
---|
1222 | //Initialize the MAC/PHY frameworks |
---|
1223 | warpmac_init(); |
---|
1224 | |
---|
1225 | //Read Dip Switch value from FPGA board. |
---|
1226 | //This value will be used as an index into the routing table for other nodes |
---|
1227 | myID = warpmac_getMyId(); |
---|
1228 | warpmac_rightHex(myID); |
---|
1229 | |
---|
1230 | //Configure the PHY and radio antenna modes |
---|
1231 | warpphy_setAntennaMode(TX_ANTMODE_ALAMOUTI_ANTA, RX_ANTMODE_ALAMOUTI_ANTA); |
---|
1232 | // warpphy_setAntennaMode(TX_ANTMODE_SISO_ANTA, RX_ANTMODE_SISO_ANTA); |
---|
1233 | |
---|
1234 | //Set the modulation scheme use for base rate (header) symbols |
---|
1235 | warpmac_setBaseRate(QPSK); |
---|
1236 | |
---|
1237 | //Connect the various user-level callbacks |
---|
1238 | warpmac_setCallback(EVENT_PHYGOODHEADER, (void *)phyRx_goodHeader_callback); |
---|
1239 | warpmac_setCallback(EVENT_PHYBADHEADER, (void *)phyRx_badHeader_callback); |
---|
1240 | warpmac_setCallback(EVENT_MGMTPKT, (void *)mgmtFromNetworkLayer_callback); |
---|
1241 | warpmac_setCallback(EVENT_DATAFROMNETWORK, (void *)dataFromNetworkLayer_callback); |
---|
1242 | warpmac_setCallback(EVENT_UARTRX, (void *)uartRecv_callback); |
---|
1243 | |
---|
1244 | //Set the default center frequency |
---|
1245 | warpphy_setChannel(GHZ_2, chan); |
---|
1246 | |
---|
1247 | //Set some PHY parameters |
---|
1248 | //v22 default: dec2hex(round(1.00115 * 2^31)) |
---|
1249 | // warpphy_setPilotCFOCorrection(0x8025AEE6); |
---|
1250 | //From experiments of fixed CFO=305Hz, using only pilot estimator |
---|
1251 | //warpphy_setPilotCFOCorrection(0x821D7F92); |
---|
1252 | |
---|
1253 | //round(2^32*(2.9e-5 + 5e-6)) |
---|
1254 | //warpphy_setCoarseCFOCorrection(146029); |
---|
1255 | //round( mean(( cfo - (m(3:end-3)-cff))')*2^32 ) (from experiments) |
---|
1256 | // warpphy_setCoarseCFOCorrection(30533); |
---|
1257 | |
---|
1258 | //Preamble/payload scaling (UFix16_13) |
---|
1259 | // 2480 = 0.302 |
---|
1260 | // 9792 = 1.195 |
---|
1261 | // preambleScaling = 3072;//2480; |
---|
1262 | // payloadScaling = 12288;//9792; |
---|
1263 | // mimo_ofdmTx_setTxScaling(preambleScaling, payloadScaling); |
---|
1264 | |
---|
1265 | pktDet_corrThresh = 7000; |
---|
1266 | warpphy_setLongCorrThresh(pktDet_corrThresh); |
---|
1267 | |
---|
1268 | //pktDet_corrWindowStart = 90-32; |
---|
1269 | //pktDet_corrWindowEnd = 180+32; |
---|
1270 | //longCorrCounterLoad = 245+6; //after comparing to v18 |
---|
1271 | //mimo_ofdmRx_setLongCorrParams( (longCorrCounterLoad&0xFF) | ((pktDet_corrWindowStart&0xFF)<<16) | ((pktDet_corrWindowEnd&0xFF)<<24)); |
---|
1272 | //mimo_ofdmRx_setPktDetDly(124); |
---|
1273 | // ofdm_txrx_mimo_WriteReg_Rx_ControlBits(0, ofdm_txrx_mimo_ReadReg_Rx_ControlBits(0) | (LOWPREC_LONGCORR)); |
---|
1274 | |
---|
1275 | |
---|
1276 | energyThresh = 4000; |
---|
1277 | ofdm_txrx_mimo_WriteReg_Rx_PktDet_setThresh(energyThresh); |
---|
1278 | |
---|
1279 | //MinMag as UFix12_12 |
---|
1280 | //mimo_ofdmRx_setPilotCalcParams(0xFFF); |
---|
1281 | |
---|
1282 | // FFT_offset = 10; |
---|
1283 | // mimo_ofdmRx_setFFTWindowOffset(FFT_offset); |
---|
1284 | |
---|
1285 | //Interpreted as Fix4_0 (1=1, 2=2, 15=-1, 14=-2, 13=-3, 12=-4) |
---|
1286 | // warpphy_setAntBPreambleShift(13); |
---|
1287 | |
---|
1288 | //AF Tx scaling (UFix18_12) |
---|
1289 | // 4096 = 1 |
---|
1290 | // 6656 = 1.625 |
---|
1291 | // 8192 = 2 |
---|
1292 | // 10240 = 2.5 |
---|
1293 | // 12288 = 3 |
---|
1294 | // afScaling = 2944; |
---|
1295 | // mimo_ofdmRx_setAFTxScaling(afScaling); |
---|
1296 | |
---|
1297 | |
---|
1298 | mimo_ofdmTx_setControlBits(mimo_ofdmTx_getOptions() | (TX_RANDOM_PAYLOAD | TX_CAPTURE_RANDOM_PAYLOAD | TX_START_D0_OUT_EN | TX_START_D1_OUT_EN)); |
---|
1299 | |
---|
1300 | //POM: Testing non-random payloads |
---|
1301 | //mimo_ofdmTx_setControlBits(mimo_ofdmTx_getOptions() | (TX_START_D0_OUT_EN | TX_START_D1_OUT_EN)); |
---|
1302 | //mimo_ofdmTx_setControlBits(mimo_ofdmTx_getOptions() & ~(TX_RANDOM_PAYLOAD | TX_CAPTURE_RANDOM_PAYLOAD)); |
---|
1303 | //bzero((void *)warpphy_getBuffAddr(pktBuf_tx_DATA), (size_t)1500); |
---|
1304 | |
---|
1305 | agcTargetPwr = -13; //was -13 throgh v21 |
---|
1306 | ofdm_AGC_SetTarget(agcTargetPwr); |
---|
1307 | |
---|
1308 | //Set min chanest magnitudes (UFix16_15 values) |
---|
1309 | warpphy_setChanEstMinMags(0);//0x8000, 0x8000); |
---|
1310 | |
---|
1311 | //Set AF blanking interval (set to zeros to disable) |
---|
1312 | warpphy_setAFblanking(0, 0); |
---|
1313 | |
---|
1314 | //firpm filt |
---|
1315 | mimo_ofdmTx_setControlBits(mimo_ofdmTx_getOptions() | TX_ALT_INTERPFILT); |
---|
1316 | |
---|
1317 | //Set MAX2829 Rx bandwidth to its minimum (helps supress out-of-band noise) |
---|
1318 | WarpRadio_v1_RxLpfCornFreqCoarseAdj(0x0, RADIO2_ADDR); |
---|
1319 | WarpRadio_v1_RxLpfCornFreqFineAdj(0x0, RADIO2_ADDR); |
---|
1320 | |
---|
1321 | numPktTypes = 1; |
---|
1322 | pktTypesToTx[0] = PKTTYPE_NCDATA; |
---|
1323 | curPktTypeInd = 0; |
---|
1324 | |
---|
1325 | /*** WARPnet Measurement/Control Setup ***/ |
---|
1326 | groupStruct.controllerID = 0; |
---|
1327 | groupStruct.controllerGrp = 0; |
---|
1328 | groupStruct.access = 1; |
---|
1329 | groupStruct.reserved0 = 0; |
---|
1330 | |
---|
1331 | //WARPnet configuration |
---|
1332 | txEthPktHeader.ethType = WARPNET_ETHTYPE_NODE2SVR; |
---|
1333 | txEthPktHeader.srcAddr[0]=0x00; |
---|
1334 | txEthPktHeader.srcAddr[1]=0x50; |
---|
1335 | txEthPktHeader.srcAddr[2]=0xC2; |
---|
1336 | txEthPktHeader.srcAddr[3]=0x63; |
---|
1337 | txEthPktHeader.srcAddr[4]=0x3F; |
---|
1338 | txEthPktHeader.srcAddr[5]=0x80+myID; |
---|
1339 | |
---|
1340 | coprocEthPktHeader.ethType = WARPNET_ETHTYPE_NODE2COPROC; |
---|
1341 | coprocEthPktHeader.srcAddr[0]=0x00; |
---|
1342 | coprocEthPktHeader.srcAddr[1]=0x50; |
---|
1343 | coprocEthPktHeader.srcAddr[2]=0xC2; |
---|
1344 | coprocEthPktHeader.srcAddr[3]=0x63; |
---|
1345 | coprocEthPktHeader.srcAddr[4]=0x3F; |
---|
1346 | coprocEthPktHeader.srcAddr[5]=0x80+myID; |
---|
1347 | |
---|
1348 | coprocEthPktHeader.numStructs = 1; |
---|
1349 | |
---|
1350 | |
---|
1351 | //Linux eth1: 00:50:C2:63:3F:FC |
---|
1352 | txEthPktHeader.dstAddr[0]=0x00; |
---|
1353 | txEthPktHeader.dstAddr[1]=0x50; |
---|
1354 | txEthPktHeader.dstAddr[2]=0xC2; |
---|
1355 | txEthPktHeader.dstAddr[3]=0x63; |
---|
1356 | txEthPktHeader.dstAddr[4]=0x3F; |
---|
1357 | txEthPktHeader.dstAddr[5]=0xFC; |
---|
1358 | |
---|
1359 | //Linux eth1: 00:50:C2:63:3F:FC |
---|
1360 | coprocEthPktHeader.dstAddr[0]=0x00; |
---|
1361 | coprocEthPktHeader.dstAddr[1]=0x50; |
---|
1362 | coprocEthPktHeader.dstAddr[2]=0xC2; |
---|
1363 | coprocEthPktHeader.dstAddr[3]=0x63; |
---|
1364 | coprocEthPktHeader.dstAddr[4]=0x3F; |
---|
1365 | coprocEthPktHeader.dstAddr[5]=0xFC; |
---|
1366 | |
---|
1367 | /* |
---|
1368 | //Macbook #1 |
---|
1369 | txEthPktHeader.dstAddr[0]=0x00; |
---|
1370 | txEthPktHeader.dstAddr[1]=0x17; |
---|
1371 | txEthPktHeader.dstAddr[2]=0xf2; |
---|
1372 | txEthPktHeader.dstAddr[3]=0xdb; |
---|
1373 | txEthPktHeader.dstAddr[4]=0x05; |
---|
1374 | txEthPktHeader.dstAddr[5]=0x07; |
---|
1375 | |
---|
1376 | //Macbook #1 |
---|
1377 | coprocEthPktHeader.dstAddr[0]=0x00; |
---|
1378 | coprocEthPktHeader.dstAddr[1]=0x17; |
---|
1379 | coprocEthPktHeader.dstAddr[2]=0xf2; |
---|
1380 | coprocEthPktHeader.dstAddr[3]=0xdb; |
---|
1381 | coprocEthPktHeader.dstAddr[4]=0x05; |
---|
1382 | coprocEthPktHeader.dstAddr[5]=0x07; |
---|
1383 | */ |
---|
1384 | |
---|
1385 | |
---|
1386 | |
---|
1387 | perStruct_DF.structID = STRUCTID_OBSERVE_PER; |
---|
1388 | perStruct_DF.nodeID = myID; |
---|
1389 | perStruct_DF.reqNum = 0; |
---|
1390 | perStruct_DF.reqType = PKTTYPE_DFDATA; |
---|
1391 | perStruct_DF.numPkts_tx = 0; |
---|
1392 | perStruct_DF.numPkts_rx_good = 0; |
---|
1393 | perStruct_DF.numPkts_rx_goodHdrBadPyld = 0; |
---|
1394 | perStruct_DF.numPkts_rx_badHdr = 0; |
---|
1395 | |
---|
1396 | perStruct_AF.structID = STRUCTID_OBSERVE_PER; |
---|
1397 | perStruct_AF.nodeID = myID; |
---|
1398 | perStruct_AF.reqNum = 0; |
---|
1399 | perStruct_AF.reqType = PKTTYPE_AFDATA; |
---|
1400 | perStruct_AF.numPkts_tx = 0; |
---|
1401 | perStruct_AF.numPkts_rx_good = 0; |
---|
1402 | perStruct_AF.numPkts_rx_goodHdrBadPyld = 0; |
---|
1403 | perStruct_AF.numPkts_rx_badHdr = 0; |
---|
1404 | |
---|
1405 | perStruct_AFGH.structID = STRUCTID_OBSERVE_PER; |
---|
1406 | perStruct_AFGH.nodeID = myID; |
---|
1407 | perStruct_AFGH.reqNum = 0; |
---|
1408 | perStruct_AFGH.reqType = PKTTYPE_AFGHDATA; |
---|
1409 | perStruct_AFGH.numPkts_tx = 0; |
---|
1410 | perStruct_AFGH.numPkts_rx_good = 0; |
---|
1411 | perStruct_AFGH.numPkts_rx_goodHdrBadPyld = 0; |
---|
1412 | perStruct_AFGH.numPkts_rx_badHdr = 0; |
---|
1413 | |
---|
1414 | perStruct_DFGH.structID = STRUCTID_OBSERVE_PER; |
---|
1415 | perStruct_DFGH.nodeID = myID; |
---|
1416 | perStruct_DFGH.reqNum = 0; |
---|
1417 | perStruct_DFGH.reqType = PKTTYPE_DFGHDATA; |
---|
1418 | perStruct_DFGH.numPkts_tx = 0; |
---|
1419 | perStruct_DFGH.numPkts_rx_good = 0; |
---|
1420 | perStruct_DFGH.numPkts_rx_goodHdrBadPyld = 0; |
---|
1421 | perStruct_DFGH.numPkts_rx_badHdr = 0; |
---|
1422 | |
---|
1423 | perStruct_NCMHOP.structID = STRUCTID_OBSERVE_PER; |
---|
1424 | perStruct_NCMHOP.nodeID = myID; |
---|
1425 | perStruct_NCMHOP.reqNum = 0; |
---|
1426 | perStruct_NCMHOP.reqType = PKTTYPE_NCMHOPDATA; |
---|
1427 | perStruct_NCMHOP.numPkts_tx = 0; |
---|
1428 | perStruct_NCMHOP.numPkts_rx_good = 0; |
---|
1429 | perStruct_NCMHOP.numPkts_rx_goodHdrBadPyld = 0; |
---|
1430 | perStruct_NCMHOP.numPkts_rx_badHdr = 0; |
---|
1431 | |
---|
1432 | perStruct_NC.structID = STRUCTID_OBSERVE_PER; |
---|
1433 | perStruct_NC.nodeID = myID; |
---|
1434 | perStruct_NC.reqNum = 0; |
---|
1435 | perStruct_NC.reqType = PKTTYPE_NCDATA; |
---|
1436 | perStruct_NC.numPkts_tx = 0; |
---|
1437 | perStruct_NC.numPkts_rx_good = 0; |
---|
1438 | perStruct_NC.numPkts_rx_goodHdrBadPyld = 0; |
---|
1439 | perStruct_NC.numPkts_rx_badHdr = 0; |
---|
1440 | |
---|
1441 | perStruct_Other.structID = STRUCTID_OBSERVE_PER; |
---|
1442 | perStruct_Other.nodeID = myID; |
---|
1443 | perStruct_Other.reqNum = 0; |
---|
1444 | perStruct_Other.reqType = PKTTYPE_INVALID; |
---|
1445 | perStruct_Other.numPkts_tx = 0; |
---|
1446 | perStruct_Other.numPkts_rx_good = 0; |
---|
1447 | perStruct_Other.numPkts_rx_goodHdrBadPyld = 0; |
---|
1448 | perStruct_Other.numPkts_rx_badHdr = 0; |
---|
1449 | |
---|
1450 | rxPHYdumpStruct.structID = STRUCTID_RXPHYDUMP; |
---|
1451 | rxPHYdumpStruct.nodeID = myID; |
---|
1452 | rxPHYdumpStruct.pktType = PKTTYPE_NCDATA; |
---|
1453 | rxPHYdumpStruct.seqNum = 0; |
---|
1454 | |
---|
1455 | /* |
---|
1456 | sleep(8); |
---|
1457 | unsigned char ethernetAddr[] = {0x00,0x50,0xC2,0x63,0x3F,0x80+myID}; |
---|
1458 | warpnet_setMacAddr((void*)ðernetAddr); |
---|
1459 | warpnet_sendGratuitousArp(myID); |
---|
1460 | */ |
---|
1461 | |
---|
1462 | setupNodeBehaviors(); |
---|
1463 | |
---|
1464 | //Rx Buffer where the wireless PHY will write packets |
---|
1465 | warpmac_setRxBuffers(&rxFrame, pktBuf_rx); |
---|
1466 | |
---|
1467 | //Tx buffer is where the EMAC will DMA payloads to |
---|
1468 | warpmac_setEMACRxBuffer(pktBuf_emac_rx); |
---|
1469 | warpmac_setPHYTxBuffer(pktBuf_tx_DATA); |
---|
1470 | |
---|
1471 | //Listen for new packets to send (either from Ethernet or local dummy packets) |
---|
1472 | warpmac_enableDataFromNetwork(); |
---|
1473 | warpmac_setDummyPacketMode(1); |
---|
1474 | |
---|
1475 | while(1){ |
---|
1476 | warpmac_pollPeripherals(); |
---|
1477 | } |
---|
1478 | |
---|
1479 | return; |
---|
1480 | } |
---|
1481 | |
---|
1482 | |
---|
1483 | void setupNodeBehaviors() |
---|
1484 | { |
---|
1485 | //Disable all actors by default |
---|
1486 | mimo_ofdmTxRx_setAction0(0); |
---|
1487 | mimo_ofdmTxRx_setAction1(0); |
---|
1488 | mimo_ofdmTxRx_setAction2(0); |
---|
1489 | mimo_ofdmTxRx_setAction3(0); |
---|
1490 | mimo_ofdmTxRx_setAction4(0); |
---|
1491 | mimo_ofdmTxRx_setAction5(0); |
---|
1492 | |
---|
1493 | //Match conditions |
---|
1494 | //Match condition 0: received header's destination address is me |
---|
1495 | //autoResp_matchCond = PHY_AUTORESPONSE_MATCH_CONFIG(PKTHEADER_INDX_DSTADDR, 2, htons(NODEID_TO_ADDR(myID))); |
---|
1496 | //mimo_ofdmTxRx_setMatch0(autoResp_matchCond); |
---|
1497 | |
---|
1498 | //Match condition 0: received header's relay address is me |
---|
1499 | autoResp_matchCond = PHY_AUTORESPONSE_MATCH_CONFIG(PKTHEADER_INDX_RLYADDR, 2, htons(NODEID_TO_ADDR(myID))); |
---|
1500 | mimo_ofdmTxRx_setMatch0(autoResp_matchCond); |
---|
1501 | |
---|
1502 | //Match condition 1: packet type is PKTTYPE_DFDATA |
---|
1503 | autoResp_matchCond = PHY_AUTORESPONSE_MATCH_CONFIG(PKTHEADER_INDX_TYPE, 1, PKTTYPE_DFDATA); |
---|
1504 | mimo_ofdmTxRx_setMatch1(autoResp_matchCond); |
---|
1505 | |
---|
1506 | //Match condition 2: packet type is PKTTYPE_AFDATA |
---|
1507 | autoResp_matchCond = PHY_AUTORESPONSE_MATCH_CONFIG(PKTHEADER_INDX_TYPE, 1, PKTTYPE_AFDATA); |
---|
1508 | mimo_ofdmTxRx_setMatch2(autoResp_matchCond); |
---|
1509 | |
---|
1510 | //Match condition 3: packet type is PKTTYPE_AFGHDATA |
---|
1511 | autoResp_matchCond = PHY_AUTORESPONSE_MATCH_CONFIG(PKTHEADER_INDX_TYPE, 1, PKTTYPE_AFGHDATA); |
---|
1512 | mimo_ofdmTxRx_setMatch3(autoResp_matchCond); |
---|
1513 | |
---|
1514 | //Match condition 4: packet type is PKTTYPE_DFGHDATA |
---|
1515 | autoResp_matchCond = PHY_AUTORESPONSE_MATCH_CONFIG(PKTHEADER_INDX_TYPE, 1, PKTTYPE_DFGHDATA); |
---|
1516 | mimo_ofdmTxRx_setMatch4(autoResp_matchCond); |
---|
1517 | |
---|
1518 | //Match condition 5: packet type is REQ_NCMHOPDATA |
---|
1519 | autoResp_matchCond = PHY_AUTORESPONSE_MATCH_CONFIG(PKTHEADER_INDX_TYPE, 1, PKTTYPE_NCMHOPDATA); |
---|
1520 | mimo_ofdmTxRx_setMatch5(autoResp_matchCond); |
---|
1521 | |
---|
1522 | //Set Tx delays (src-reTx, autoRespExtra, txStart outputs) |
---|
1523 | mimo_ofdmTx_setDelays(autoRespDelay_SrcReTx, 0, pktDetBypass_txStartDly); |
---|
1524 | |
---|
1525 | if(coopTesting) { |
---|
1526 | if(myID == ID_SRC) { |
---|
1527 | //Enable auto-TwoTx mode, so the source transmits every packet twice back-to-back |
---|
1528 | mimo_ofdmTx_setControlBits(mimo_ofdmTx_getOptions() | (TX_AUTO_TWOTX_EN)); |
---|
1529 | |
---|
1530 | //Disable packet detection at the src; it never receives packets |
---|
1531 | ofdm_txrx_mimo_WriteReg_Rx_PktDet_ignoreDet(1); |
---|
1532 | } |
---|
1533 | else if(myID == ID_RLY) { |
---|
1534 | //Relay transmits after receiving DATA packet from src |
---|
1535 | //autoResp_action_relayTx = PHY_AUTORESPONSE_TXACTION_CONFIG(pktBuf_rx, (PHY_AUTORESPONSE_ACT_SWAP_ANT | PHY_AUTORESPONSE_ACT_USE_PRECFO), autoRespDelay_RlyTx_DF, (REQ_RLY_ME | REQ_DFDATA | PHY_AUTORESPONSE_REQ_GOODHDR | PHY_AUTORESPONSE_REQ_GOODPKT)); |
---|
1536 | //autoResp_action_relayTx = PHY_AUTORESPONSE_TXACTION_CONFIG(pktBuf_rx, (0), autoRespDelay_RlyTx_DF, (REQ_RLY_ME | REQ_DFDATA | PHY_AUTORESPONSE_REQ_GOODHDR | PHY_AUTORESPONSE_REQ_GOODPKT)); |
---|
1537 | autoResp_action_relayTx = PHY_AUTORESPONSE_TXACTION_CONFIG(pktBuf_rx, (PHY_AUTORESPONSE_ACT_USE_PRECFO), autoRespDelay_RlyTx_DF, (REQ_RLY_ME | REQ_DFDATA | PHY_AUTORESPONSE_REQ_GOODHDR | PHY_AUTORESPONSE_REQ_GOODPKT)); |
---|
1538 | mimo_ofdmTxRx_setAction0(autoResp_action_relayTx); |
---|
1539 | |
---|
1540 | autoResp_action_relayTx = PHY_AUTORESPONSE_TXACTION_CONFIG(pktBuf_tx_AF, (0), autoRespDelay_RlyTx_AF, (REQ_RLY_ME | REQ_AFDATA | PHY_AUTORESPONSE_REQ_GOODHDR | PHY_AUTORESPONSE_REQ_GOODPKT)); |
---|
1541 | mimo_ofdmTxRx_setAction1(autoResp_action_relayTx); |
---|
1542 | |
---|
1543 | autoResp_action_relayTx = PHY_AUTORESPONSE_TXACTION_CONFIG(pktBuf_tx_AF, (0), autoRespDelay_RlyTx_AF, (REQ_RLY_ME | REQ_AFGHDATA | PHY_AUTORESPONSE_REQ_GOODHDR)); |
---|
1544 | mimo_ofdmTxRx_setAction2(autoResp_action_relayTx); |
---|
1545 | |
---|
1546 | autoResp_action_relayTx = PHY_AUTORESPONSE_TXACTION_CONFIG(pktBuf_rx, (PHY_AUTORESPONSE_ACT_USE_PRECFO | PHY_AUTORESPONSE_ACT_RETX_CRC), autoRespDelay_RlyTx_DF, (REQ_RLY_ME | REQ_DFGHDATA | PHY_AUTORESPONSE_REQ_GOODHDR)); |
---|
1547 | //POM: temporarily refdefining DFGH to be DF w/out prespin! |
---|
1548 | // autoResp_action_relayTx = PHY_AUTORESPONSE_TXACTION_CONFIG(pktBuf_rx, (0), autoRespDelay_RlyTx_DF, (REQ_RLY_ME | REQ_DFGHDATA | PHY_AUTORESPONSE_REQ_GOODHDR | PHY_AUTORESPONSE_REQ_GOODPKT)); |
---|
1549 | mimo_ofdmTxRx_setAction3(autoResp_action_relayTx); |
---|
1550 | |
---|
1551 | autoResp_action_relayTx = PHY_AUTORESPONSE_TXACTION_CONFIG(pktBuf_rx, (0), autoRespDelay_RlyTx_DF, (REQ_RLY_ME | REQ_NCMHOPDATA | PHY_AUTORESPONSE_REQ_GOODHDR | PHY_AUTORESPONSE_REQ_GOODPKT)); |
---|
1552 | mimo_ofdmTxRx_setAction4(autoResp_action_relayTx); |
---|
1553 | |
---|
1554 | warpphy_AFrecordEnable(1); |
---|
1555 | } |
---|
1556 | else if(myID == ID_DST) |
---|
1557 | { |
---|
1558 | } |
---|
1559 | } //END if(coopTesting) |
---|
1560 | |
---|
1561 | if(nonCoopTesting) { |
---|
1562 | if(myID == ID_SRC) |
---|
1563 | { |
---|
1564 | mimo_ofdmTx_setControlBits(mimo_ofdmTx_getOptions() & ~(TX_AUTO_TWOTX_EN)); |
---|
1565 | |
---|
1566 | //Disable packet detection at the src; it never receives packets |
---|
1567 | ofdm_txrx_mimo_WriteReg_Rx_PktDet_ignoreDet(1); |
---|
1568 | } |
---|
1569 | else if(myID == ID_RLY) |
---|
1570 | { |
---|
1571 | mimo_ofdmTxRx_setAction0(0); |
---|
1572 | mimo_ofdmTxRx_setAction1(0); |
---|
1573 | mimo_ofdmTxRx_setAction2(0); |
---|
1574 | } |
---|
1575 | else if(myID == ID_DST) |
---|
1576 | { |
---|
1577 | } |
---|
1578 | } //END if(nonCoopTesting) |
---|
1579 | return; |
---|
1580 | } |
---|
1581 | |
---|
1582 | void setDACinterp(unsigned int mode, unsigned int radios) { |
---|
1583 | unsigned int divreg; |
---|
1584 | |
---|
1585 | |
---|
1586 | divreg = RADIO_CONTROLLER_mReadSlaveReg6(XPAR_RADIO_CONTROLLER_0_BASEADDR); |
---|
1587 | RADIO_CONTROLLER_mWriteSlaveReg5((volatile)XPAR_RADIO_CONTROLLER_0_BASEADDR, 0x3410); // Set the value of the Control Register to 0x00003410 for DACs |
---|
1588 | RADIO_CONTROLLER_mWriteSlaveReg6((volatile)XPAR_RADIO_CONTROLLER_0_BASEADDR, 0x00000001); // Set the value for the Divider Register to 0x00000001 |
---|
1589 | |
---|
1590 | RADIO_CONTROLLER_mWriteSlaveReg7((volatile)XPAR_RADIO_CONTROLLER_0_BASEADDR, (SLAVEMASKDAC & radios)); // Select the dacs that need to be affected |
---|
1591 | |
---|
1592 | transmitdac( (0x0104 | ( (mode & 0x3)<<6) ) ); |
---|
1593 | |
---|
1594 | transmitdac( (0x0300 | ( (mode & 0x30)>>4)) ); |
---|
1595 | |
---|
1596 | if((mode&0x33) > 0) { |
---|
1597 | //Enable the AD9777 PLL |
---|
1598 | transmitdac(0x0480); |
---|
1599 | } else { |
---|
1600 | //Disable the AD9777 PLL |
---|
1601 | transmitdac(0x0400); |
---|
1602 | } |
---|
1603 | |
---|
1604 | transmitdac(0x060F); |
---|
1605 | transmitdac(0x0A0F); |
---|
1606 | |
---|
1607 | RADIO_CONTROLLER_mWriteSlaveReg5((volatile)XPAR_RADIO_CONTROLLER_0_BASEADDR, 0x3412); // Set the value of the Control Register to 0x00003412 for Radio |
---|
1608 | RADIO_CONTROLLER_mWriteSlaveReg6((volatile)XPAR_RADIO_CONTROLLER_0_BASEADDR, divreg); // Set the value for the Divider Register to 0x00000000 |
---|
1609 | |
---|
1610 | return; |
---|
1611 | } |
---|