// 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); }