C#

using System;
using System.Collections.Generic;
using System.Text;

namespace LMS {
	public class LMSResponseParser {
		private byte[] responseBytes;
		private Dictionary<string, string> dict;

		public LMSResponseParser(byte[] responseBytes) {
			this.responseBytes=responseBytes;
		}

		public string HostName {
			get {
				return getValue("ENAME");
			}
		}

		public string UUID {
			get {
				return getValue("UUID");
			}
		}
		public string Version {
			get {
				return getValue("VERS");
			}
		}

		public int PortNumber {
			get {
				return Convert.ToInt32(getValue("PORT"));
			}
		}

		private string getValue(string key) {
			try {
				if (dict==null) parse();	// lazy execution, only parse when actually needed!
				return dict[key];
			} catch (Exception exc) {
				throw new ApplicationException(
					"Error parsing LMS response '"+responseBytes+"'", exc);
			}
		}

		private void parse() {
			dict=new Dictionary<string, string>();
			for (int i = 0; i<responseBytes.Length;) {
				string key = "";
				byte b = responseBytes[i++];
				while (b>='A'&&b<='Z') {
					key+=(char)b;
					b=responseBytes[i++];
				}
				int len = b; // At the end of the keyname is the data length
				string value = Encoding.ASCII.GetString(responseBytes, i, len);
				i+=len;
				dict[key]=value;
			}
		}
	}
}

using System.Runtime.InteropServices;

		[StructLayout(LayoutKind.Explicit)]
		struct ShortsOverlayFloat {
			[FieldOffset(0)]
			public short I1;
			[FieldOffset(2)]
			public short I2;
			[FieldOffset(0)]
			public float F;
		}

		public float shortsToFloat(short i1, short i2) {
			ShortsOverlayFloat S;
			S.F=0;	// avoids warning
			S.I1=i1;
			S.I2=i2;
			return S.F;
		}

float f = shortsToFloat(9147, 17352);

int val1 = 17352;
            int val2 = 9147;
                     

            byte[] buffer = { (byte)val1, (byte)val2 };
            for (int n = 0; n < buffer.Length; n += 2)
            {
                short sample = (short)BitConverter.ToSingle(buffer, n);
                MessageBox.Show(sample.ToString());
            }

Quote:

System.ArgumentException
HResult=0x80070057
Message=Destination array is not long enough to copy all the items in the collection. Check array index and length.
Source=mscorlib
StackTrace:
at System.ThrowHelper.ThrowArgumentException(ExceptionResource resource)
at System.BitConverter.ToSingle(Byte[] value, Int32 startIndex)
at WindowsFormsApp2.Form1.tmr_Modbus_Conn_Tick(Object sender, EventArgs e) in C:\Users\Justin Fehl\Documents\Visual Studio 2019\Projects\ModBus Development\ModbusTest2.cs:line 94
at System.Windows.Forms.Timer.OnTick(EventArgs e)
at System.Windows.Forms.Timer.TimerNativeWindow.WndProc(Message& m)
at System.Windows.Forms.NativeWindow.DebuggableCallback(IntPtr hWnd, Int32 msg, IntPtr wparam, IntPtr lparam)
at System.Windows.Forms.UnsafeNativeMethods.DispatchMessageW(MSG& msg)
at System.Windows.Forms.Application.ComponentManager.System.Windows.Forms.UnsafeNativeMethods.IMsoComponentManager.FPushMessageLoop(IntPtr dwComponentID, Int32 reason, Int32 pvLoopData)
at System.Windows.Forms.Application.ThreadContext.RunMessageLoopInner(Int32 reason, ApplicationContext context)
at System.Windows.Forms.Application.ThreadContext.RunMessageLoop(Int32 reason, ApplicationContext context)
at System.Windows.Forms.Application.Run(Form mainForm)
at WindowsFormsApp2.Program.Main() in C:\Users\Justin Fehl\Documents\Visual Studio 2019\Projects\ModBus Development\Modbus Development 6-26-2020\WindowsFormsApp2\Program.cs:line 19

Destination array is not long enough 

byte[] buffer = { (byte)val1, (byte)val2 };

var byteval1 = BitConverter.GetBytes(val1);
            var byteval2 = BitConverter.GetBytes(val2);

            byte[] temp2 = new byte[4];
            temp2[0] = byteval1[0];
            temp2[1] = byteval1[1];
            temp2[2] = byteval2[0];
            temp2[3] = byteval2[1];

            float myFloat = System.BitConverter.ToSingle(temp2, 0);
            Console.WriteLine(myFloat);
            Console.ReadLine();

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Text;

namespace LP_Core {
	public class LP_SerialPortInfo {
		private static List<ComInfo> serialPorts=new List<ComInfo>();

		private const UInt32 DIGCF_PRESENT=0x00000002;
		private const UInt32 DIGCF_DEVICEINTERFACE=0x00000010;
		private const UInt32 DICS_FLAG_GLOBAL=0x00000001;
		private const UInt32 DIREG_DEV=0x00000001;
		private const UInt32 KEY_QUERY_VALUE=0x0001;
		private const string GUID_DEVINTERFACE_COMPORT="86E0D1E0-8089-11D0-9CE4-08003E301F73";
		[StructLayout(LayoutKind.Sequential)]
		private struct SP_DEVINFO_DATA {
			public Int32 cbSize;
			public Guid ClassGuid;
			public Int32 DevInst;
			public UIntPtr Reserved;
		};

		public enum ComPortCharacteristic {
			Description=0x00000000,
			FriendlyName=0x0000000C,
			HardwareID=0x00000001,
			Location=0x0000000D
		}

		[DllImport("setupapi.dll")]
		private static extern Int32 SetupDiDestroyDeviceInfoList(IntPtr DeviceInfoSet);

		[DllImport("setupapi.dll")]
		private static extern bool SetupDiEnumDeviceInfo(IntPtr DeviceInfoSet, Int32 MemberIndex, ref  SP_DEVINFO_DATA DeviceInterfaceData);

		[DllImport("setupapi.dll", CharSet=CharSet.Auto, SetLastError=true)]
		private static extern bool SetupDiGetDeviceRegistryProperty(IntPtr deviceInfoSet, ref SP_DEVINFO_DATA deviceInfoData,
			uint property, out UInt32 propertyRegDataType, StringBuilder propertyBuffer, uint propertyBufferSize, out UInt32 requiredSize);

		[DllImport("setupapi.dll", SetLastError=true)]
		private static extern IntPtr SetupDiGetClassDevs(ref Guid gClass, UInt32 iEnumerator, IntPtr hParent, UInt32 nFlags);

		[DllImport("Setupapi", CharSet=CharSet.Auto, SetLastError=true)]
		private static extern IntPtr SetupDiOpenDevRegKey(IntPtr hDeviceInfoSet, ref SP_DEVINFO_DATA deviceInfoData, uint scope,
			uint hwProfile, uint parameterRegistryValueKind, uint samDesired);

		[DllImport("advapi32.dll", CharSet=CharSet.Unicode, EntryPoint="RegQueryValueExW", SetLastError=true)]
		private static extern int RegQueryValueEx(IntPtr hKey, string lpValueName, int lpReserved, out uint lpType,
			StringBuilder lpData, ref uint lpcbData);

		[DllImport("advapi32.dll", CharSet=CharSet.Ansi, SetLastError=true, ExactSpelling=true)]
		private static extern int RegCloseKey(IntPtr hKey);

		[DllImport("kernel32.dll")]
		private static extern Int32 GetLastError();

		public struct ComInfo {
			public string Name;
			public string Description;
			public string FriendlyName;
			public string Location;
			public string HardwareID;
		}

		public static List<ComInfo> GetComPorts() {
			serialPorts.Clear();
			Guid guidComPorts=new Guid(GUID_DEVINTERFACE_COMPORT);
			IntPtr hDeviceInfoSet=SetupDiGetClassDevs(
				ref guidComPorts, 0, IntPtr.Zero, DIGCF_PRESENT|DIGCF_DEVICEINTERFACE);
			if (hDeviceInfoSet!=IntPtr.Zero) {
				try {
					List<ComInfo> devices=new List<ComInfo>();
					Int32 iMemberIndex=0;
					while (true) {
						SP_DEVINFO_DATA deviceInfoData=new SP_DEVINFO_DATA();
						deviceInfoData.cbSize=Marshal.SizeOf(typeof(SP_DEVINFO_DATA));
						bool success=SetupDiEnumDeviceInfo(hDeviceInfoSet, iMemberIndex, ref deviceInfoData);
						if (!success) {
							// No more devices in the device information set
							break;
						}

						ComInfo comInfo=new ComInfo();
						comInfo.Name=getName(hDeviceInfoSet, deviceInfoData);
						comInfo.Description=getString((UInt32)ComPortCharacteristic.Description, hDeviceInfoSet, deviceInfoData);
						comInfo.FriendlyName=getString((UInt32)ComPortCharacteristic.FriendlyName, hDeviceInfoSet, deviceInfoData);
						comInfo.HardwareID=getString((UInt32)ComPortCharacteristic.HardwareID, hDeviceInfoSet, deviceInfoData);
						comInfo.Location=getString((UInt32)ComPortCharacteristic.Location, hDeviceInfoSet, deviceInfoData);
						env.log("found: "+comInfo.Name+" = "+comInfo.Description+";FN="+comInfo.FriendlyName+
							"; HID="+comInfo.HardwareID+"; LOC="+comInfo.Location);
						serialPorts.Add(comInfo);
						iMemberIndex++;
					}
				} finally {
					SetupDiDestroyDeviceInfoList(hDeviceInfoSet);
				}
			}
			return serialPorts;
		}

		private static string getName(IntPtr pDevInfoSet, SP_DEVINFO_DATA deviceInfoData) {
			string name = "???";
			IntPtr hDeviceRegistryKey = SetupDiOpenDevRegKey(pDevInfoSet, ref deviceInfoData,
				DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_QUERY_VALUE);
			if (hDeviceRegistryKey!=IntPtr.Zero) {
				StringBuilder buf = new StringBuilder(256);
				try {
					uint lpRegKeyType;
					uint length = (uint)buf.Capacity;
					int result = RegQueryValueEx(hDeviceRegistryKey, "PortName", 0, out lpRegKeyType, buf, ref length);
					if (result!=0) {
						throw new Exception("Can not read registry value PortName for device "+deviceInfoData.ClassGuid);
					}
				} finally {
					RegCloseKey(hDeviceRegistryKey);
				}
				name=buf.ToString();
			}
			return name;
		}

		private static string getString(UInt32 SPDRP, IntPtr hDeviceInfoSet, SP_DEVINFO_DATA deviceInfoData) {
			StringBuilder buf = new StringBuilder(256);
			uint propRegDataType;
			uint length = (uint)buf.Capacity;
			bool success = SetupDiGetDeviceRegistryProperty(hDeviceInfoSet, ref deviceInfoData, SPDRP,
				out propRegDataType, buf, length, out length);
			if (!success) {
				throw new Exception("Can not read registry value PortName for device "+deviceInfoData.ClassGuid);
			}
			return buf.ToString();
		}
	}
}

Luc Pattyn wrote:

1.
SerialPort does enumerate all serial ports as it should, there is no problem, except it does not know about the underlying hardware, so for instance you can't differentiate motherboard vs USB ports.

Luc Pattyn wrote:

2.
I trust USB is called USB in all languages that use latin character sets, so you could use String.Contains on the friendlyname.

Luc Pattyn wrote:

I have my own class enumerating all serial ports, its underlying technology is somewhat similar to the class you referred; here it is, use at your leisure. It returns a list of struct ComInfo which holds the friendlyname as well as the location (for USB serial ports this is a concatenation of port numbers, pointing to the USB port actually used).

ManagementScope scope = new ManagementScope(@"\\.\root\microsoft\windows\storage");

using (ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM MSFT_Partition")) {
  scope.Connect();
  searcher.Scope = scope;

  foreach (ManagementObject queryObj in searcher.Get()) {
    char driveletter = (char)queryObj["DriveLetter"];
    if (driveletter == '\0') continue;
    FsVolume part = new FsVolume();
    part.driveletter = driveletter;
    part.diskNumber = (uint) queryObj["DiskNumber"];
    part.partNo =  (uint) queryObj["PartitionNumber"];
    part.partGuid = (string)queryObj["UniqueID"];
    partList.Add(part);
  }
}

public StatusType getAvailableComPorts()
{
  StatusType status = new StatusType(StatusCodeType.OK, null, "", "");
  try
  {
    string[] availableComPorts = SerialPort.GetPortNames();

    if ((availableComPorts == null) || (availableComPorts.Length <= 0))
    {
      status.statusCode = StatusCodeType.OTHER_ERROR;
      status.errorHeading = "No Com Ports Available";
      status.errorMessage = "No available com port was found on your computer. Please add a com port or use a different computer to control your PTT box.";
      return status;
    }
    Array.Sort(availableComPorts, new ComPortComparerClass());


    ComPortInformation[] comPortsInformation = new ComPortInformation[availableComPorts.Length];
    for (int i = 0; i < comPortsInformation.Length; i++)
    {
      comPortsInformation[i] = new ComPortInformation(availableComPorts[i]);
    }

    // Try to get the user friendly name for each Com port
    if ((availableComPorts != null) && (0 < availableComPorts.Length))
    {
      try
      {
        ManagementObjectSearcher searcher = new ManagementObjectSearcher("root\\CIMV2", "SELECT * FROM Win32_PnPEntity");
        for (int i = availableComPorts.Length - 1; 0 <= i; i--)
        {
          foreach (ManagementObject queryObj in searcher.Get())
          {
            if ((queryObj["Name"] != null) && (queryObj["Name"].ToString().Contains("(" + availableComPorts[i] + ")")))
            {
              comPortsInformation[i].comPortDescriptor = queryObj["Caption"].ToString().Replace("(" + availableComPorts[i] + ")", "").Trim();
              break;
            }
          }
        }
      }
      catch (ManagementException)
      {
      }
    }
    status.value = comPortsInformation;
  }
  catch (Exception e)
  {
    status.statusCode = StatusCodeType.OTHER_ERROR;
    status.errorHeading = "Error";
    status.errorMessage = "Error getting available com ports. Technical info: " + e.Message;
  }
  return status;
}