A Discrete-Event Network Simulator
API
ht-capabilities.cc
Go to the documentation of this file.
1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2013
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation;
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Authors: Ghada Badawy <gbadawy@rim.com>
19  * S├ębastien Deronne <sebastien.deronne@gmail.com>
20  */
21 
22 #include "ht-capabilities.h"
23 #include "ns3/assert.h"
24 #include "ns3/log.h"
25 
26 namespace ns3 {
27 
28 NS_LOG_COMPONENT_DEFINE ("HtCapabilities");
29 
31  : m_ldpc (0),
32  m_supportedChannelWidth (0),
33  m_smPowerSave (0),
34  m_greenField (0),
35  m_shortGuardInterval20 (0),
36  m_shortGuardInterval40 (0),
37  m_txStbc (0),
38  m_rxStbc (0),
39  m_htDelayedBlockAck (0),
40  m_maxAmsduLength (0),
41  m_dssMode40 (0),
42  m_psmpSupport (0),
43  m_fortyMhzIntolerant (0),
44  m_lsigProtectionSupport (0),
45  m_maxAmpduLength (0),
46  m_minMpduStartSpace (0),
47  m_ampduReserved (0),
48  m_reservedMcsSet1 (0),
49  m_rxHighestSupportedDataRate (0),
50  m_reservedMcsSet2 (0),
51  m_txMcsSetDefined (0),
52  m_txRxMcsSetUnequal (0),
53  m_txMaxNSpatialStreams (0),
54  m_txUnequalModulation (0),
55  m_reservedMcsSet3 (0),
56  m_pco (0),
57  m_pcoTransitionTime (0),
58  m_reservedExtendedCapabilities (0),
59  m_mcsFeedback (0),
60  m_htcSupport (0),
61  m_reverzeDirectionResponder (0),
62  m_reservedExtendedCapabilities2 (0),
63  m_implicitRxBfCapable (0),
64  m_rxStaggeredSoundingCapable (0),
65  m_txStaggeredSoundingCapable (0),
66  m_rxNdpCapable (0),
67  m_txNdpCapable (0),
68  m_implicitTxBfCapable (0),
69  m_calibration (0),
70  m_explicitCsiTxBfCapable (0),
71  m_explicitNoncompressedSteeringCapable (0),
72  m_explicitCompressedSteeringCapable (0),
73  m_explicitTxBfCsiFeedback (0),
74  m_explicitNoncompressedBfFeedbackCapable (0),
75  m_explicitCompressedBfFeedbackCapable (0),
76  m_minimalGrouping (0),
77  m_csiNBfAntennasSupported (0),
78  m_noncompressedSteeringNBfAntennasSupported (0),
79  m_compressedSteeringNBfAntennasSupported (0),
80  m_csiMaxNRowsBfSupported (0),
81  m_channelEstimationCapability (0),
82  m_reservedTxBf (0),
83  m_antennaSelectionCapability (0),
84  m_explicitCsiFeedbackBasedTxASelCapable (0),
85  m_antennaIndicesFeedbackBasedTxASelCapable (0),
86  m_explicitCsiFeedbackCapable (0),
87  m_antennaIndicesFeedbackCapable (0),
88  m_rxASelCapable (0),
89  m_txSoundingPpdusCapable (0),
90  m_reservedASel (0),
91  m_htSupported (0)
92 {
93  for (uint32_t k = 0; k < MAX_SUPPORTED_MCS; k++)
94  {
95  m_rxMcsBitmask[k] = 0;
96  }
97 }
98 
101 {
102  return IE_HT_CAPABILITIES;
103 }
104 
105 void
106 HtCapabilities::SetHtSupported (uint8_t htsupported)
107 {
108  m_htSupported = htsupported;
109 }
110 
111 void
113 {
114  m_ldpc = ldpc;
115 }
116 
117 void
118 HtCapabilities::SetSupportedChannelWidth (uint8_t supportedchannelwidth)
119 {
120  m_supportedChannelWidth = supportedchannelwidth;
121 }
122 
123 void
124 HtCapabilities::SetGreenfield (uint8_t greenfield)
125 {
126  m_greenField = greenfield;
127 }
128 
129 void
130 HtCapabilities::SetShortGuardInterval20 (uint8_t shortguardinterval)
131 {
132  m_shortGuardInterval20 = shortguardinterval;
133 }
134 
135 void
136 HtCapabilities::SetShortGuardInterval40 (uint8_t shortguardinterval)
137 {
138  m_shortGuardInterval40 = shortguardinterval;
139 }
140 
141 void
142 HtCapabilities::SetMaxAmsduLength (uint8_t maxamsdulength)
143 {
144  m_maxAmsduLength = maxamsdulength;
145 }
146 
147 void
149 {
150  m_lsigProtectionSupport = lsigprotection;
151 }
152 
153 void
154 HtCapabilities::SetMaxAmpduLength (uint8_t maxampdulength)
155 {
156  m_maxAmpduLength = maxampdulength;
157 }
158 
159 void
161 {
162  m_rxMcsBitmask[index] = 1;
163 }
164 
165 void
167 {
168  m_rxHighestSupportedDataRate = maxsupportedrate;
169 }
170 
171 void
172 HtCapabilities::SetTxMcsSetDefined (uint8_t txmcssetdefined)
173 {
174  m_txMcsSetDefined = txmcssetdefined;
175 }
176 
177 void
178 HtCapabilities::SetTxRxMcsSetUnequal (uint8_t txrxmcssetunequal)
179 {
180  m_txRxMcsSetUnequal = txrxmcssetunequal;
181 }
182 
183 void
184 HtCapabilities::SetTxMaxNSpatialStreams (uint8_t maxtxspatialstreams)
185 {
186  m_txMaxNSpatialStreams = maxtxspatialstreams;
187 }
188 
189 void
190 HtCapabilities::SetTxUnequalModulation (uint8_t txunequalmodulation)
191 {
192  m_txUnequalModulation = txunequalmodulation;
193 }
194 
195 uint8_t
197 {
198  return m_ldpc;
199 }
200 
201 uint8_t
203 {
205 }
206 
207 uint8_t
209 {
210  return m_greenField;
211 }
212 
213 uint8_t
215 {
216  return m_shortGuardInterval20;
217 }
218 
219 uint8_t
221 {
222  return m_shortGuardInterval40;
223 }
224 
225 uint8_t
227 {
228  return m_maxAmsduLength;
229 }
230 
231 uint8_t
233 {
235 }
236 
237 uint8_t
239 {
240  return m_maxAmpduLength;
241 }
242 
243 uint8_t*
245 {
246  uint8_t* p;
247  p = m_rxMcsBitmask;
248  return p;
249 }
250 
251 bool
253 {
254  if (m_rxMcsBitmask[mcs] == 1)
255  {
256  return true;
257  }
258  return false;
259 }
260 
261 uint8_t
263 {
264  for (uint8_t nRx = 2; nRx <= 4; nRx++)
265  {
266  for (uint8_t mcs = (nRx - 1) * 8; mcs <= ((7 * nRx) + (nRx - 1)); mcs++)
267  {
268  if (IsSupportedMcs (mcs) == false)
269  {
270  return (nRx - 1);
271  }
272  }
273  }
274  return 4;
275 }
276 
277 uint16_t
279 {
281 }
282 
283 uint8_t
285 {
286  return m_txMcsSetDefined;
287 }
288 
289 uint8_t
291 {
292  return m_txRxMcsSetUnequal;
293 }
294 
295 
296 uint8_t
298 {
299  return m_txMaxNSpatialStreams;
300 }
301 
302 uint8_t
304 {
305  return m_txUnequalModulation;
306 }
307 
308 uint8_t
310 {
311  //we should not be here if ht is not supported
312  NS_ASSERT (m_htSupported > 0);
313  return 26;
314 }
315 
318 {
319  if (m_htSupported < 1)
320  {
321  return i;
322  }
324 }
325 
326 uint16_t
328 {
329  if (m_htSupported < 1)
330  {
331  return 0;
332  }
334 }
335 
336 uint16_t
338 {
339  uint16_t val = 0;
340  val |= m_ldpc & 0x01;
341  val |= (m_supportedChannelWidth & 0x01) << 1;
342  val |= (m_smPowerSave & 0x03) << 2;
343  val |= (m_greenField & 0x01) << 4;
344  val |= (m_shortGuardInterval20 & 0x01) << 5;
345  val |= (m_shortGuardInterval40 & 0x01) << 6;
346  val |= (m_txStbc & 0x01) << 7;
347  val |= (m_rxStbc & 0x03) << 8;
348  val |= (m_htDelayedBlockAck & 0x01) << 10;
349  val |= (m_maxAmsduLength & 0x01) << 11;
350  val |= (m_dssMode40 & 0x01) << 12;
351  val |= (m_psmpSupport & 0x01) << 13;
352  val |= (m_fortyMhzIntolerant & 0x01) << 14;
353  val |= (m_lsigProtectionSupport & 0x01) << 15;
354  return val;
355 }
356 
357 void
359 {
360  m_ldpc = ctrl & 0x01;
361  m_supportedChannelWidth = (ctrl >> 1) & 0x01;
362  m_smPowerSave = (ctrl >> 2) & 0x03;
363  m_greenField = (ctrl >> 4) & 0x01;
364  m_shortGuardInterval20 = (ctrl >> 5) & 0x01;
365  m_shortGuardInterval40 = (ctrl >> 6) & 0x01;
366  m_txStbc = (ctrl >> 7) & 0x01;
367  m_rxStbc = (ctrl >> 8) & 0x03;
368  m_htDelayedBlockAck = (ctrl >> 10) & 0x01;
369  m_maxAmsduLength = (ctrl >> 11) & 0x01;
370  m_dssMode40 = (ctrl >> 12) & 0x01;
371  m_psmpSupport = (ctrl >> 13) & 0x01;
372  m_fortyMhzIntolerant = (ctrl >> 14) & 0x01;
373  m_lsigProtectionSupport = (ctrl >> 15) & 0x01;
374 }
375 
376 void
378 {
379  m_maxAmpduLength = ctrl & 0x03;
380  m_minMpduStartSpace = (ctrl >> 2) & 0x1b;
381  m_ampduReserved = (ctrl >> 5) & 0xe0;
382 }
383 
384 uint8_t
386 {
387  uint8_t val = 0;
388  val |= m_maxAmpduLength & 0x03;
389  val |= (m_minMpduStartSpace & 0x1b) << 2;
390  val |= (m_ampduReserved & 0xe0) << 5;
391  return val;
392 }
393 
394 void
395 HtCapabilities::SetSupportedMcsSet (uint64_t ctrl1, uint64_t ctrl2)
396 {
397  for (uint64_t i = 0; i < 77; i++)
398  {
399  if (i < 64)
400  {
401  m_rxMcsBitmask[i] = (ctrl1 >> i) & 0x01;
402  }
403  else
404  {
405  m_rxMcsBitmask[i] = (ctrl2 >> (i - 64)) & 0x01;
406  }
407  }
408  m_reservedMcsSet1 = (ctrl2 >> 13) & 0x07;
409  m_rxHighestSupportedDataRate = (ctrl2 >> 16) & 0x03ff;
410  m_reservedMcsSet2 = (ctrl2 >> 26) & 0x3f;
411  m_txMcsSetDefined = (ctrl2 >> 32) & 0x01;
412  m_txRxMcsSetUnequal = (ctrl2 >> 33) & 0x01;
413  m_txMaxNSpatialStreams = (ctrl2 >> 34) & 0x03;
414  m_txUnequalModulation = (ctrl2 >> 36) & 0x01;
415  m_reservedMcsSet3 = (ctrl2 >> 37) & 0x07ffffff;
416 }
417 
418 uint64_t
420 {
421  uint64_t val = 0;
422  for (uint64_t i = 63; i > 0; i--)
423  {
424  val = (val << 1) | (m_rxMcsBitmask[i] & 0x01);
425  }
426  val = (val << 1) | (m_rxMcsBitmask[0] & 0x01);
427  return val;
428 }
429 
430 uint64_t
432 {
433  uint64_t val = 0;
434  val = val | (m_reservedMcsSet3 & 0x07ffffff);
435  val = (val << 1) | (m_txUnequalModulation & 0x01);
436  val = (val << 2) | (m_txMaxNSpatialStreams & 0x03);
437  val = (val << 1) | (m_txRxMcsSetUnequal & 0x01);
438  val = (val << 1) | (m_txMcsSetDefined & 0x01);
439  val = (val << 6) | (m_reservedMcsSet2 & 0x3f);
440  val = (val << 10) | (m_rxHighestSupportedDataRate & 0x3ff);
441  val = (val << 3) | (m_reservedMcsSet1 & 0x07);
442 
443  for (uint64_t i = 13; i > 0; i--)
444  {
445  val = (val << 1) | ( m_rxMcsBitmask[i + 63] & 0x01);
446  }
447  return val;
448 }
449 
450 uint16_t
452 {
453  uint16_t val = 0;
454  val |= m_pco & 0x01;
455  val |= (m_pcoTransitionTime & 0x03) << 1;
456  val |= (m_reservedExtendedCapabilities & 0x1f) << 3;
457  val |= (m_mcsFeedback & 0x03) << 8;
458  val |= (m_htcSupport & 0x01) << 10;
459  val |= (m_reverzeDirectionResponder & 0x01) << 11;
460  val |= (m_reservedExtendedCapabilities2 & 0x0f) << 12;
461  return val;
462 }
463 
464 void
466 {
467  m_pco = ctrl & 0x01;
468  m_pcoTransitionTime = (ctrl >> 1) & 0x03;
469  m_reservedExtendedCapabilities = (ctrl >> 3) & 0x1f;
470  m_mcsFeedback = (ctrl >> 8) & 0x03;
471  m_htcSupport = (ctrl >> 10) & 0x01;
472  m_reverzeDirectionResponder = (ctrl >> 11) & 0x01;
473  m_reservedExtendedCapabilities2 = (ctrl >> 12) & 0x0f;
474 }
475 
476 uint32_t
478 {
479  uint32_t val = 0;
480  val |= m_implicitRxBfCapable & 0x01;
481  val |= (m_rxStaggeredSoundingCapable & 0x01) << 1;
482  val |= (m_txStaggeredSoundingCapable & 0x01) << 2;
483  val |= (m_rxNdpCapable & 0x01) << 3;
484  val |= (m_txNdpCapable & 0x01) << 4;
485  val |= (m_implicitTxBfCapable & 0x01) << 5;
486  val |= (m_calibration & 0x03) << 6;
487  val |= (m_explicitCsiTxBfCapable & 0x01) << 8;
488  val |= (m_explicitNoncompressedSteeringCapable & 0x01) << 9;
489  val |= (m_explicitCompressedSteeringCapable & 0x01) << 10;
490  val |= (m_explicitTxBfCsiFeedback & 0x03) << 11;
491  val |= (m_explicitNoncompressedBfFeedbackCapable & 0x03) << 13;
492  val |= (m_explicitCompressedBfFeedbackCapable & 0x03) << 15;
493  val |= (m_minimalGrouping & 0x03) << 17;
494  val |= (m_csiNBfAntennasSupported & 0x03) << 19;
495  val |= (m_noncompressedSteeringNBfAntennasSupported & 0x03) << 21;
496  val |= (m_compressedSteeringNBfAntennasSupported & 0x03) << 23;
497  val |= (m_csiMaxNRowsBfSupported & 0x03) << 25;
498  val |= (m_channelEstimationCapability & 0x03) << 27;
499  val |= (m_reservedTxBf & 0x07) << 29;
500  return val;
501 }
502 
503 void
505 {
506  m_implicitRxBfCapable = ctrl & 0x01;
507  m_rxStaggeredSoundingCapable = (ctrl >> 1) & 0x01;
508  m_txStaggeredSoundingCapable = (ctrl >> 2) & 0x01;
509  m_rxNdpCapable = (ctrl >> 3) & 0x01;
510  m_txNdpCapable = (ctrl >> 4) & 0x01;
511  m_implicitTxBfCapable = (ctrl >> 5) & 0x01;
512  m_calibration = (ctrl >> 6) & 0x03;
513  m_explicitCsiTxBfCapable = (ctrl >> 8) & 0x01;
514  m_explicitNoncompressedSteeringCapable = (ctrl >> 9) & 0x01;
515  m_explicitCompressedSteeringCapable = (ctrl >> 10) & 0x01;
516  m_explicitTxBfCsiFeedback = (ctrl >> 11) & 0x03;
517  m_explicitNoncompressedBfFeedbackCapable = (ctrl >> 13) & 0x03;
518  m_explicitCompressedBfFeedbackCapable = (ctrl >> 15) & 0x03;
519  m_minimalGrouping = (ctrl >> 17) & 0x03;
520  m_csiNBfAntennasSupported = (ctrl >> 19) & 0x03;
521  m_noncompressedSteeringNBfAntennasSupported = (ctrl >> 21) & 0x03;
522  m_compressedSteeringNBfAntennasSupported = (ctrl >> 23) & 0x03;
523  m_csiMaxNRowsBfSupported = (ctrl >> 25) & 0x03;
524  m_channelEstimationCapability = (ctrl >> 27) & 0x03;
525  m_reservedTxBf = (ctrl >> 29) & 0x07;
526 }
527 
528 uint8_t
530 {
531  uint8_t val = 0;
532  val |= m_antennaSelectionCapability & 0x01;
533  val |= (m_explicitCsiFeedbackBasedTxASelCapable & 0x01) << 1;
534  val |= (m_antennaIndicesFeedbackBasedTxASelCapable & 0x01) << 2;
535  val |= (m_explicitCsiFeedbackCapable & 0x01) << 3;
536  val |= (m_antennaIndicesFeedbackCapable & 0x01) << 4;
537  val |= (m_rxASelCapable & 0x01) << 5;
538  val |= (m_txSoundingPpdusCapable & 0x01) << 6;
539  val |= (m_reservedASel & 0x01) << 7;
540  return val;
541 }
542 
543 void
545 {
546  m_antennaSelectionCapability = ctrl & 0x01;
547  m_explicitCsiFeedbackBasedTxASelCapable = (ctrl >> 1) & 0x01;
548  m_antennaIndicesFeedbackBasedTxASelCapable = (ctrl >> 2) & 0x01;
549  m_explicitCsiFeedbackCapable = (ctrl >> 3) & 0x01;
550  m_antennaIndicesFeedbackCapable = (ctrl >> 4) & 0x01;
551  m_rxASelCapable = (ctrl >> 5) & 0x01;
552  m_txSoundingPpdusCapable = (ctrl >> 6) & 0x01;
553  m_reservedASel = (ctrl >> 7) & 0x01;
554 }
555 
556 void
558 {
559  if (m_htSupported == 1)
560  {
561  //write the corresponding value for each bit
563  start.WriteU8 (GetAmpduParameters ());
567  start.WriteU32 (GetTxBfCapabilities ());
569  }
570 }
571 
572 uint8_t
574  uint8_t length)
575 {
577  uint16_t htinfo = i.ReadLsbtohU16 ();
578  uint8_t ampduparam = i.ReadU8 ();
579  uint64_t mcsset1 = i.ReadLsbtohU64 ();
580  uint64_t mcsset2 = i.ReadLsbtohU64 ();
581  uint16_t extendedcapabilities = i.ReadU16 ();
582  uint32_t txbfcapabilities = i.ReadU32 ();
583  uint8_t aselcapabilities = i.ReadU8 ();
584  SetHtCapabilitiesInfo (htinfo);
585  SetAmpduParameters (ampduparam);
586  SetSupportedMcsSet (mcsset1, mcsset2);
587  SetExtendedHtCapabilities (extendedcapabilities);
588  SetTxBfCapabilities (txbfcapabilities);
589  SetAntennaSelectionCapabilities (aselcapabilities);
590  return length;
591 }
592 
594 
595 std::ostream &
596 operator << (std::ostream &os, const HtCapabilities &htcapabilities)
597 {
598  os << bool (htcapabilities.GetLdpc ())
599  << "|" << bool (htcapabilities.GetSupportedChannelWidth ())
600  << "|" << bool (htcapabilities.GetGreenfield ())
601  << "|" << bool (htcapabilities.GetShortGuardInterval20 ());
602 
603  return os;
604 }
605 
606 std::istream &operator >> (std::istream &is, HtCapabilities &htcapabilities)
607 {
608  bool c1, c2, c3, c4;
609  is >> c1 >> c2 >> c3 >> c4;
610  htcapabilities.SetLdpc (c1);
611  htcapabilities.SetSupportedChannelWidth (c2);
612  htcapabilities.SetGreenfield (c3);
613  htcapabilities.SetShortGuardInterval20 (c4);
614 
615  return is;
616 }
617 
618 } //namespace ns3
uint16_t ReadU16(void)
Definition: buffer.h:1028
uint8_t GetMaxAmsduLength(void) const
uint8_t m_rxMcsBitmask[MAX_SUPPORTED_MCS]
std::istream & operator>>(std::istream &is, Angles &a)
initialize a struct Angles from input
Definition: angles.cc:48
void SetTxMcsSetDefined(uint8_t txmcssetdefined)
uint32_t ReadU32(void)
Definition: buffer.cc:972
uint8_t GetTxRxMcsSetUnequal(void) const
uint8_t m_rxStaggeredSoundingCapable
uint8_t GetLSigProtectionSupport(void) const
void SetGreenfield(uint8_t greenfield)
void SetTxBfCapabilities(uint32_t ctrl)
Set the Transmit Beamforming (TxBF) Capabilties field in the HT Capabilities information element...
uint8_t m_explicitNoncompressedSteeringCapable
#define MAX_SUPPORTED_MCS
This defines the maximum number of supported MCSs that a STA is allowed to have.
uint8_t m_antennaIndicesFeedbackCapable
void SetHtSupported(uint8_t htsupported)
#define ATTRIBUTE_HELPER_CPP(type)
Define the attribute value, accessor and checkers for class type.
uint8_t m_reservedExtendedCapabilities2
uint64_t GetSupportedMcsSet2(void) const
void SetRxMcsBitmask(uint8_t index)
def start()
Definition: core.py:1482
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file...
Definition: assert.h:67
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:201
The HT Capabilities Information ElementThis class knows how to serialise and deserialise the HT Capab...
uint8_t GetSupportedChannelWidth(void) const
void SetAmpduParameters(uint8_t ctrl)
Set the A-MPDU Parameters field in the HT Capabilities information element.
uint8_t GetShortGuardInterval40(void) const
uint8_t m_txSoundingPpdusCapable
uint16_t GetSerializedSize() const
Get the size of the serialized IE including Element ID and length fields.
iterator in a Buffer instance
Definition: buffer.h:98
uint8_t GetTxUnequalModulation(void) const
void SetLSigProtectionSupport(uint8_t lsigprotection)
#define IE_HT_CAPABILITIES
uint8_t m_txStaggeredSoundingCapable
void SetShortGuardInterval20(uint8_t shortguardinterval)
uint8_t GetGreenfield(void) const
uint8_t m_csiNBfAntennasSupported
uint64_t GetSupportedMcsSet1(void) const
uint16_t m_rxHighestSupportedDataRate
void WriteU16(uint16_t data)
Definition: buffer.cc:870
void SetMaxAmsduLength(uint8_t maxamsdulength)
uint8_t m_antennaSelectionCapability
uint32_t GetTxBfCapabilities(void) const
uint8_t GetShortGuardInterval20(void) const
void SetMaxAmpduLength(uint8_t maxampdulength)
uint16_t GetRxHighestSupportedDataRate(void) const
uint8_t m_channelEstimationCapability
uint8_t GetTxMaxNSpatialStreams(void) const
WifiInformationElementId ElementId() const
Own unique Element ID.
uint8_t GetTxMcsSetDefined(void) const
std::ostream & operator<<(std::ostream &os, const Angles &a)
print a struct Angles to output
Definition: angles.cc:42
void SetRxHighestSupportedDataRate(uint16_t maxsupportedrate)
Every class exported by the ns3 library is enclosed in the ns3 namespace.
uint8_t m_explicitCompressedBfFeedbackCapable
bool IsSupportedMcs(uint8_t mcs) const
uint8_t GetAmpduParameters(void) const
void SerializeInformationField(Buffer::Iterator start) const
Serialize information (i.e., the body of the IE, not including the Element ID and length octets) ...
void SetTxUnequalModulation(uint8_t txunequalmodulation)
void SetSupportedMcsSet(uint64_t ctrl1, uint64_t ctrl2)
Set the Supported MCS Set field in the HT Capabilities information element.
void SetExtendedHtCapabilities(uint16_t ctrl)
Set the Extended HT Capabilties field in the HT Capabilities information element. ...
uint8_t GetInformationFieldSize() const
Length of serialized information (i.e., the length of the body of the IE, not including the Element I...
void SetAntennaSelectionCapabilities(uint8_t ctrl)
Set the the Antenna Selection (ASEL) Capabilties field in the HT Capabilities information element...
void WriteHtolsbU16(uint16_t data)
Definition: buffer.cc:910
uint8_t GetLdpc(void) const
void SetHtCapabilitiesInfo(uint16_t ctrl)
Set the HT Capabilties Info field in the HT Capabilities information element.
uint16_t GetHtCapabilitiesInfo(void) const
void WriteU8(uint8_t data)
Definition: buffer.h:868
uint8_t m_noncompressedSteeringNBfAntennasSupported
uint8_t m_explicitCsiTxBfCapable
void WriteHtolsbU64(uint64_t data)
Definition: buffer.cc:926
uint8_t m_compressedSteeringNBfAntennasSupported
uint8_t m_explicitCsiFeedbackBasedTxASelCapable
uint8_t m_explicitCsiFeedbackCapable
void SetLdpc(uint8_t ldpc)
uint8_t ReadU8(void)
Definition: buffer.h:1020
void SetTxRxMcsSetUnequal(uint8_t txrxmcssetunequal)
uint8_t m_csiMaxNRowsBfSupported
uint8_t * GetRxMcsBitmask()
uint16_t ReadLsbtohU16(void)
Definition: buffer.cc:1065
uint8_t GetRxHighestSupportedAntennas(void) const
uint8_t m_explicitTxBfCsiFeedback
uint8_t WifiInformationElementId
This type is used to represent an Information Element ID.
void SetTxMaxNSpatialStreams(uint8_t maxtxspatialstreams)
uint8_t DeserializeInformationField(Buffer::Iterator start, uint8_t length)
Deserialize information (i.e., the body of the IE, not including the Element ID and length octets) ...
uint64_t ReadLsbtohU64(void)
Definition: buffer.cc:1093
uint16_t GetSerializedSize() const
Return the serialized size of this HT capability information element.
void WriteU32(uint32_t data)
Definition: buffer.cc:878
uint8_t m_reservedExtendedCapabilities
Buffer::Iterator Serialize(Buffer::Iterator start) const
This information element is a bit special in that it is only included if the STA is an HT STA...
void SetShortGuardInterval40(uint8_t shortguardinterval)
uint8_t GetAntennaSelectionCapabilities(void) const
Buffer::Iterator Serialize(Buffer::Iterator i) const
Serialize entire IE including Element ID and length fields.
void SetSupportedChannelWidth(uint8_t supportedchannelwidth)
uint8_t m_reverzeDirectionResponder
uint8_t GetMaxAmpduLength(void) const
uint8_t m_explicitNoncompressedBfFeedbackCapable
uint8_t m_explicitCompressedSteeringCapable
uint8_t m_antennaIndicesFeedbackBasedTxASelCapable
uint16_t GetExtendedHtCapabilities(void) const