// Returns true if the msg represents data for this listener; false if
// the address is not recognized (reply is for some other listener)
public bool MessageReplyListenerCallback(DAN_gui_msg msg, DateTime arrivalTime)
{
// Need to offset ACK and NACK by base amounts;
// Scale and translate RSSI and STO
// Find missing values
if (msg.address < baseAddress || msg.address > (baseAddress + ADDRESS_OFFSETS[ADDRESS_OFFSETS.Length - 1]))
{
return false;
}
// debug assert
if (msg.size != 0) {
Console.WriteLine("BUG: unexpected reply length for constellation data msg: {0}", msg.size);
return true;
}
UInt32 addrOffset = msg.address - baseAddress;
int i;
for (i = 0; i < ADDRESS_OFFSETS.Length; i++)
{
if (addrOffset == ADDRESS_OFFSETS[i])
{
break;
}
}
// debug assert
if (i >= ADDRESS_OFFSETS.Length)
{
Console.WriteLine("BUG: unexpected reply addr for constellation data msg: {0}", msg.address);
return true;
}
int dataOffset = i * REQUEST_SIZE_WORDS;
Array.Copy(msg.data, 0, this.data, dataOffset, REQUEST_SIZE_WORDS);
dataCollected++;
// Stop listening if all replies seen
// Wed 9 Nov 2011: wondering if this may be an issue, since we're iterating the
// listeners during this callback?
if (dataCollected >= ADDRESS_OFFSETS.Length)
{
//PcapConnection.pcap.removeListener(this);
// moved to isDataReady, below
}
return true;
}
public bool MessageReplyListenerCallback(DAN_gui_msg msg, DateTime arrivalTime)
{
if ((msg.address >= Temp_Dump_Address) || (msg.address <= (Temp_Dump_Address + (0x400 * Number_of_Req))))
{
if (msg.size == 0)
{
UInt32 addrOffset = msg.address - Temp_Dump_Address;
uint j = addrOffset / 0x400;
// number of req is not 256 multiplayer.
if (j >= Number_of_Req)
{
return true;
}
uint dataOffset = j * REQUEST_SIZE_WORDS;
{ Array.Copy(msg.data, 0, this.data, dataOffset, REQUEST_SIZE_WORDS); }
message_counter++;
return true;// won't bother any other object with parsing it, since it is for this object
}
}
return false;
}
// Returns true if the msg represents data for this listener; false if
// the address is not recognized (reply is for some other listener)
public bool MessageReplyListenerCallback(DAN_gui_msg msg, DateTime arrivalTime)
{
if (msg.address == baseAddress)
{
if (msg.size != REG_COUNT)
{
Console.WriteLine("Bug: AMC unexpected reply, len > REG_COUNT");
// Ret TRUE so other objects aren't called to examine this msg
return true;
}
// AMC Auto mode
autoAMC = msg.data[AMC_MODE_index] == 0 ? true : false;
cinrSimMode = msg.data[CINR_SIM_index] == 1 ? true : false;
mcsManualId0 = msg.data[MAN_MCS_0_index];
mcsManualId1 = msg.data[MAN_MCS_1_index];
cinrManualSetting0 = msg.data[CINR_SIM_0_index];
cinrManualSetting1 = msg.data[CINR_SIM_1_index];
//cinrAmcAveragedCinr0 = msg.data[CINR_AVG_0_index];
//cinrAmcAveragedCinr1 = msg.data[CINR_AVG_1_index];
return true;
}
return false;
}
private void handleMemoryReadReply(DAN_gui_msg msg)
{
UInt32 addr = msg.address;
listViewMemory.Items.Clear();
for (int i = 0; i < msg.size; )
{
string[] rowString = new string[5];
rowString[0] = addr.ToString("x8");
for (int j = 0; j < 4; j++)
{
if (i >= msg.size)
{
rowString[j + 1] = "";
}
else
{
rowString[j + 1] = msg.data[i++].ToString("x8");
}
}
listViewMemory.Items.Add(new ListViewItem(rowString));
addr += 16;
}
outstandingRequestSeq = -1;
}
private void handleSpectralInvAnt1ReadReply(DAN_gui_msg msg)
{
try
{
if (msg.data[0] == 0x00000808)
{
SpectralInvAnt1 = true;
}
else
{
SpectralInvAnt1 = false;
}
}
catch { }
checkBox_BER_COUNTER_ENABLE_if_Spectral_inv_On();
}
private void handlePLLReadReply(DAN_gui_msg msg)
{
//comboBoxPLLWorkingMode
try
{
switch (msg.data[PLL_Working_Mode])
{
case (257): //0x0101
comboBoxPLLWorkingMode.SelectedIndex = 0;
break;
case (17): //0x0011
comboBoxPLLWorkingMode.SelectedIndex = 1;
break;
case (1): //0x0001
comboBoxPLLWorkingMode.SelectedIndex = 2;
break;
}
}
catch { }
//comboBoxPLLLoopBW - PLL_LOOP_BW_B1
try
{
switch (msg.data[PLL_LOOP_BW_B1])
{
case (3648): //0xe40
comboBoxPLLLoopBWB1.SelectedIndex = 0;
break;
case (2736): //0xab0
comboBoxPLLLoopBWB1.SelectedIndex = 1;
break;
case (1824): //0x720
comboBoxPLLLoopBWB1.SelectedIndex = 2;
break;
case (912): //0x390
comboBoxPLLLoopBWB1.SelectedIndex = 3;
break;
default:
comboBoxPLLLoopBWB1.SelectedIndex = 4;
break;
}
}
catch { }
//comboBoxPLLLoopBW - PLL_LOOP_BW_B2
try
{
switch (msg.data[PLL_LOOP_BW_B2])
{
case (156): //0x09c
comboBoxPLLLoopBWB2.SelectedIndex = 0;
break;
case (88): //0x058
comboBoxPLLLoopBWB2.SelectedIndex = 1;
break;
case (39): //0x027
comboBoxPLLLoopBWB2.SelectedIndex = 2;
break;
case (10): //0x00a
comboBoxPLLLoopBWB2.SelectedIndex = 3;
break;
default:
comboBoxPLLLoopBWB2.SelectedIndex = 4;
break;
}
}
catch { }
//comboBoxCINRFactor
try
{
int index = (Convert.ToInt32(msg.data[PLL_CINR_Factor].ToString()) / 1638);
comboBoxCINRFactor.SelectedIndex = (index - 1);
}
catch { }
//comboBoxChannelEstimationFactor
try
{
int index = (Convert.ToInt32(msg.data[PLL_Ch_Est_Factor].ToString()) / 1638);
comboBoxChannelEstimationFactor.SelectedIndex = (index - 1);
}
catch { }
//comboBoxDisablePLLDerotation
try
{
if (msg.data[PLL_Derotation] == 1)
{
comboBoxDisablePLLDerotation.SelectedIndex = 0;
}
else
{
comboBoxDisablePLLDerotation.SelectedIndex = 1;
}
}
catch { }
}
private void handleUnitTypeReadReply(DAN_gui_msg msg)
{
if (msg.data[0] == 0)
{
UnitType = "Master";
}
else
{
UnitType = "Slave";
}
}
// Unmarshal the DAN message fields from within a byte array.
// The array is expected to be a raw ethernet packet, so the offset
// of the DAN message fields include room for an Ethernet header and
// the standard-size IPv4 header that the SOC sends.
public static DAN_gui_msg unmarshal(byte[] bytes)
{
//Console.WriteLine(" Size of DAN_GUI_msg = {0}; bas.Length = {1}, bas.BytesLength={2}",
// Marshal.SizeOf(typeof(DAN_GUI_msg)), bas.Length, bas.BytesLength);
DAN_gui_msg rv = new DAN_gui_msg();
rv.msgType = bytes[DAN_MSG_CMD_OFFSET_WITHIN_RAW_PACKET];
rv.size = bytes[DAN_MSG_SIZ_OFFSET_WITHIN_RAW_PACKET];
//rv.seq = MiscUtil.Conversion.EndianBitConverter.Little.ToUInt16(bytes, DAN_MSG_SEQ_OFFSET_WITHIN_RAW_PACKET);
rv.seq = BitConverter.ToUInt16(bytes, DAN_MSG_SEQ_OFFSET_WITHIN_RAW_PACKET);
rv.address = MiscUtil.Conversion.EndianBitConverter.Little.ToUInt32(bytes, DAN_MSG_ADD_OFFSET_WITHIN_RAW_PACKET);
if (rv.msgType == (byte)MSG_TYPE.RSP_READ || // "OneWord Read" response
rv.msgType == (byte)MSG_TYPE.RSP_READ_ARRAY) // "Block Read" response
{
// Data payload is an array of uint32 (memory words from the SOC at address)
int offsetOfDanData = DAN_MSG_DAT_OFFSET_WITHIN_RAW_PACKET;
// special case - zero length -> 256
int dataWords = rv.size == 0 ? 256 : rv.size;
rv.data = new UInt32[dataWords];
for (int i = 0; i < dataWords; i++)
{
rv.data[i] = BitConverter.ToUInt32(bytes, offsetOfDanData);
offsetOfDanData += 4;
}
}
else
{
// todo: Ignore (by filter) packets coming from me (requests)
Console.WriteLine(" Ignoring DAN message type = " + rv.msgType);
}
return rv;
}
public bool MessageReplyListenerCallback(DAN_gui_msg msg, DateTime arrivalTime)
{
for (int i = 0; i < CM_address.Length; i++)
{
if ((msg.address >= CM_address[i]) || (msg.address <= (CM_address[i] + (0x400*Number_of_Req))))
{
if (msg.size == 0)
{
UInt32 addrOffset = msg.address - CM_address[i];
uint j = addrOffset / 0x400;
// debug assert
if (j >= Number_of_Req)
{
Console.WriteLine("BUG: unexpected reply addr for CDU data msg at CM{0}: {1}", i, msg.address);
return true;
}
uint dataOffset = j * REQUEST_SIZE_WORDS;
if (i == 0)
{ Array.Copy(msg.data, 0, this.data_CM0, dataOffset, REQUEST_SIZE_WORDS); }
else
{ Array.Copy(msg.data, 0, this.data_CM1, dataOffset, REQUEST_SIZE_WORDS); }
message_counter++;
return true;// won't bother any other object with parsing it, since it IS for this object
}
}
}
return false;
}
private void handleGong(DAN_gui_msg msg)
{
gongOn = (msg.data[0] == 1 ? true : false);
}
private void handleTxOn1(DAN_gui_msg msg)
{
txOnAnt1 = (msg.data[0] == 0 ? true : false);
}
private void handlePLLAnt1(DAN_gui_msg msg)
{
pllLockAnt1 = (msg.data[0] == 1 ? true : false);
}
private void handleSyncTimingPll(DAN_gui_msg msg)
{
// syncAchieved = (msg.data[SYNC_ACHIEVED_index] == 0 ? false : true);
timingLoopOK = (((msg.data[0] == 2) || (msg.data[0] == 0))? true : false);
// pllLock = (msg.data[PLL_LOCK_index] == 0 ? false : true);
}
public void sendDanMsg(DAN_gui_msg message)
{
byte[] bytes = message.marshal();
// IP addressing is not needed; just keeping entertained...
IpPacket ipPacket = new IPv4Packet(ipSrcAddr, ipDestAddr);
ipPacket.PayloadData = bytes;
ipPacket.UpdateCalculatedValues();
ipPacket.Version = (PacketDotNet.IpVersion)DAN_GUI_MESSAGE_IP_V;
EthernetPacket ethernetPacket = new EthernetPacket(device.MacAddress, ethDstAddr, EthernetPacketType.IpV4);
ethernetPacket.PayloadPacket = ipPacket;
device.SendPacket(ethernetPacket);
}
private void handleUncodedBERCounter(DAN_gui_msg msg)
{
Uncoded_BER_Error_bits_Ant0 = msg.data[Uncoded_BER_Acc_Error_bits_Ant0];
Uncoded_BER_Error_bits_Ant1 = msg.data[Uncoded_BER_Acc_Error_bits_Ant1];
Uncoded_BER_Good_bits = msg.data[Uncoded_BER_Num_Of_Words_Acc];
}
private void handleLinkStatistics(DAN_gui_msg msg)
{
string RFTypeReg;
string tempRFType;
IsyncPeak = msg.data[Isync_Peak_str];
IsyncFreq = msg.data[Isync_Freq_str];
if ((msg.data[Link_status_str] >= 0) && (msg.data[Link_status_str] <= 11))
{
LinkStatus = msg.data[Link_status_str];
}
else
{
LinkStatus = 0;
}
if ((msg.data[MCS_Set_str] >= 0) && (msg.data[MCS_Set_str] < 5))
{
MCS_Set = msg.data[MCS_Set_str];
}
else
{
MCS_Set = 2;
}
RF_Type = "";
RFTypeReg = (msg.data[rf_Type_str + 3].ToString("X") + msg.data[rf_Type_str + 2].ToString("X") + msg.data[rf_Type_str + 1].ToString("X") + msg.data[rf_Type_str].ToString("X"));
while (RFTypeReg.Length > 0)
{
tempRFType = System.Convert.ToChar(System.Convert.ToUInt32(RFTypeReg.Substring(RFTypeReg.Length-2, 2), 16)).ToString();
RF_Type = RF_Type + tempRFType;
RFTypeReg = RFTypeReg.Substring(0, RFTypeReg.Length - 2);
}
}
public bool MessageReplyListenerCallback(DAN_gui_msg msg, DateTime arrivalTime)
{
//read the register that contine channel gain enable/disable bit
if (msg.address == ChannelGainEnableAddress)
{
UInt32 temp = Convert.ToUInt32(msg.data[0].ToString());
ChannelGainEnableValue = (temp & 0xffff0fff);
ChannelGainReadRegister = true;
}
if (msg.address < baseAddress || msg.address > (baseAddress + CG_ADDRESS_OFFSETS[CG_ADDRESS_OFFSETS.Length - 1]))
{
return false;
}
// debug assert
if (msg.size != 0)
{
Console.WriteLine("BUG: unexpected reply length for constellation data msg: {0}", msg.size);
return true;
}
UInt32 addrOffset = msg.address - baseAddress;
int i;
for (i = 0; i < CG_ADDRESS_OFFSETS.Length; i++)
{
if (addrOffset == CG_ADDRESS_OFFSETS[i])
{
break;
}
}
// debug assert
if (i >= CG_ADDRESS_OFFSETS.Length)
{
Console.WriteLine("BUG: unexpected reply addr for constellation data msg: {0}", msg.address);
return true;
}
int dataOffset = i * REQUEST_SIZE_WORDS;
Array.Copy(msg.data, 0, this.data, dataOffset, REQUEST_SIZE_WORDS);
dataCollected++;
// Stop listening if all replies seen
// Wed 9 Nov 2011: wondering if this may be an issue, since we're iterating the
// listeners during this callback?
if (dataCollected >= CG_ADDRESS_OFFSETS.Length)
{
//PcapConnection.pcap.removeListener(this);
// moved to isDataReady, below
}
return true;
}
// Returns true if the msg represents data for this gmac; false if
// the address is for some other register;
public bool MessageReplyListenerCallback(DAN_gui_msg msg, DateTime arrivalTime)
{
double elapsedMS = 0;
double delta;
if ((GMAC0_BASE == (0xfffff000 & msg.address)) || (0xe045805 == (0xfffffff0 & msg.address)))
{
for (int i = 0; i < REG_COUNT0; i++)
{
if (msg.address == registers0[i])
{
TimeSpan elapsed = DateTime.Now - Time_GMAC0[i];
elapsedMS = elapsed.TotalMilliseconds;
if (elapsedMS < 5)
{
// way off, so ignore this sample
return true;
}
LastCounters_GMAC0[i] = CurrentCounters_GMAC0[i];
CurrentCounters_GMAC0[i] = msg.data[0];
delta = CurrentCounters_GMAC0[i] - LastCounters_GMAC0[i];
if ((elapsedMS != 0) && (delta > 0))
{
RateCounters_GMAC0[i] = (delta / (elapsedMS / 1000));
}
else
{
RateCounters_GMAC0[i] = 0;
}
return true;
}
}
}
else if (GMAC1_BASE == (0xfffff000 & msg.address))
{
for (int i = 0; i < REG_COUNT1; i++)
{
if (msg.address == registers1[i])
{
TimeSpan elapsed = DateTime.Now - Time_GMAC1[i];
elapsedMS = elapsed.TotalMilliseconds;
if (elapsedMS < 5)
{
// way off, so ignore this sample
return true;
}
LastCounters_GMAC1[i] = CurrentCounters_GMAC1[i];
CurrentCounters_GMAC1[i] = msg.data[0];
delta = CurrentCounters_GMAC1[i] - LastCounters_GMAC1[i];
if ((elapsedMS != 0) && (delta > 0))
{
RateCounters_GMAC1[i] = (delta / (elapsedMS / 1000));
}
else
{
RateCounters_GMAC1[i] = 0;
}
return true;
}
}
}
return false; // Did I get other register address? return false so others can use the msg.
}
private void handleControlChannels(DAN_gui_msg msg)
{
controlChannelTx = new PhyControlChannel(msg.data[TXCHANHI_index]);
controlChannelRx = new PhyControlChannel(msg.data[RXCHANHI_index]);
}
private void handleUnitProfileReadReply(DAN_gui_msg msg)
{
RunningProfile = msg.data[0];
}
private void handleAvgCINRsAndTbCounts(DAN_gui_msg msg)
{
// Limit CINR values... which are signed, and sometimes negative
// (SpPerfCharts don't handle negative values):
CINR1avg = Math.Min((double)Math.Max(0, (double) msg.data[CINR1Avg_index]), 42);
CINR2avg = Math.Min((double)Math.Max(0, (double) msg.data[CINR2Avg_index]), 42);
shaperValue = msg.data[SHAPERVAL_index];
txNumTbs = msg.data[TXNUMTBS_index];
txNumFrames = msg.data[TXNUMFRAMES_index];
rxNumTbs = msg.data[RXNUMTBS_index];
rxNumFrames = msg.data[RXNUMFRAMES_index];
rxNumBadTbs0 = msg.data[RXBADTBS0_index];
rxNumBadTbs1 = msg.data[RXBADTBS1_index];
// Calc delta and keep last values
rxNumFrameDelta = msg.data[RXNUMFRAMEINDS_index] - rxNumFrameInds;
rxNumFrameInds = msg.data[RXNUMFRAMEINDS_index];
txNumFrameDelta = msg.data[TXNUMFRAMEINDS_index] - txNumFrameInds;
txNumFrameInds = msg.data[TXNUMFRAMEINDS_index];
}
private void handleUnitAntModeReadReply(DAN_gui_msg msg)
{
if (msg.data[0] == 0)
{
SisoMimoMode = "Single SISO";
}
else if (msg.data[0] == 1)
{
SisoMimoMode = "Double SISO";
}
else if (msg.data[0] == 2)
{
SisoMimoMode = "XPIC(MIMO)";
}
}
private void handlePLLPRIRXAnt0(DAN_gui_msg msg)
{
//if (msg.data[PLL_RX_Ant0_Freq_Offset] == RX_Freq_Offset_for_profile1)
//{ RXPLLAnt0FreqOffset = 0; }
//else
//{ RXPLLAnt0FreqOffset = (msg.data[PLL_RX_Ant0_Freq_Offset] - RX_Freq_Offset_for_profile1) * (0.0279396772); }
}
private void handlehypothesisReadReply(DAN_gui_msg msg)
{
try
{
textBoxRXPRIHypothesis.Text = msg.data[0].ToString();
}
catch { }
}
private void handlePLLPRITXAnt1(DAN_gui_msg msg)
{
//if (msg.data[PLL_TX_Ant1_Freq_Offset] == TX_Freq_Offset_for_profile1)
//{ TXPLLAnt1FreqOffset = 0; }
//else
//{ TXPLLAnt1FreqOffset = (msg.data[PLL_TX_Ant1_Freq_Offset] - TX_Freq_Offset_for_profile1) * (0.0279396772); }
}
public bool MessageReplyListenerCallback(DAN_gui_msg msg, DateTime arrivalTime)
{
for (int i = 0; i < BLOCK_COUNT; i++)
{
if (msg.address == blockAddrs[i])
{
if (msg.size != blockWordCounts[i])
{
Console.WriteLine("BUG: msg reply {0} wrong size = {0}", blockNames[i], msg.size);
return true; // won't bother any other object with parsing it, since it IS for this object
}
handlers[i](msg);
return true;
}
}
return false;
}
private void handleACKetc(DAN_gui_msg msg)
{
// CRC counters:
nackData = msg.data[CRCNACKDATA_index];
ackData = msg.data[CRCACKDATA_index];
nackCtrl = msg.data[CRCNACKCTRL_index];
ackCtrl = msg.data[CRCACKCTRL_index];
//STO Reports
STO1 = (double)((Int16)msg.data[STO1_index]) / 512;
STO2 = (double)((Int16)msg.data[STO2_index]) / 512;
// RSSI - previously, I thought it had 5 bits of fraction, and
// I divided by 32. This new equation effection 27-oct-2011:
RSSI1 = (((double)msg.data[RSSI1_index])/ 32) - 90.5;
if ((((double)msg.data[RSSI1_index]) / (double)32.0) > 256)
{ RSSI1 = 0; }
//Console.WriteLine("Rec'd RSSI1 = {0:X8} ({0}), calculated RSSI1={1}", msg.data[8], RSSI1);
RSSI2 = (((double)msg.data[RSSI2_index]) / 32) - 90.5;
if ((((double)msg.data[RSSI2_index]) / (double)32.0) > 256)
{ RSSI2 = 0; }
// Apparently CINR has 5 bits of fractional data
// CINR1 = ((double)msg.data[CINR1_index]) / (double)32.0;
// CINR2 = ((double)msg.data[CINR2_index]) / (double)32.0;
CINR1 = Math.Min((((double)msg.data[CINR1_index]) / (double)32.0), 42);
if ((((double)msg.data[CINR1_index]) / (double)32.0) > 128)
{ CINR1 = 0; }
CINR2 = Math.Min((((double)msg.data[CINR2_index]) / (double)32.0), 42);
if ((((double)msg.data[CINR2_index]) / (double)32.0) > 128)
{ CINR2 = 0; }
DC1I = (double)((msg.data[DC0_index] & 0xffff0000) >> 16);
DC1Q = (double)((msg.data[DC0_index] & 0x0000ffff));
DC2I = (double)((msg.data[DC1_index] & 0xffff0000) >> 16);
DC2Q = (double)((msg.data[DC1_index] & 0x0000ffff));
XPI1 = ((((double)(msg.data[XPI0_index])) - ((double)msg.data[RSSI1_index])) / 32.0);
XPI2 = ((((double)(msg.data[XPI1_index])) - ((double)msg.data[RSSI2_index])) / 32.0);
// New antenna-specific Ack and Nack (9Nov2011)
nack0 = msg.data[NACK0_index];
ack0 = msg.data[ACK0_index];
nack1 = msg.data[NACK1_index];
ack1 = msg.data[ACK1_index];
}
private void handleUnitDuplexModeReadReply(DAN_gui_msg msg)
{
if (msg.data[0] == 0)
{
Duplex_Mode = "FDD";
}
else if (msg.data[0] == 1)
{
Duplex_Mode = "TDD";
}
else
{
Duplex_Mode = "NA";
}
}
private void handleBERCounter(DAN_gui_msg msg)
{
Enable_BER_Counter = msg.data[Enabling_BER_counting];
BER_Error_bits_Ant0 = msg.data[Error_bits_accumulator_Ant0];
BER_Good_bits_Ant0 = msg.data[Good_bits_counting1_Ant0] + ((ulong)msg.data[Good_bits_counting2_Ant0]<<32);
BER_Error_bits_Ant1 = msg.data[Error_bits_accumulator_Ant1];
BER_Good_bits_Ant1 = msg.data[Good_bits_counting1_Ant1] + ((ulong)msg.data[Good_bits_counting2_Ant1] << 32);
}
