C#

ResponseColumn ParseResponseString(string FieldName,string ResponseString)
{
    ResponseColumn rc = new ResponseColumn();

    int pos = ResponseString.IndexOf(FieldName);

    string ColumnName = ResponseString.Substring(pos,5);
    int DataLen = Convert.ToInt32(ColumnName[4]);
    pos+= 5; // this moves the pointer along the string to the value part
    string ColumnValue = ResponseString.Substring(pos,DataLen); // this reads the string starting at pos the length of DataLen

    rc.ColumnName = FieldName;
    rc.ColumnValue = ColumnValue;
    return rc;
}

public class ResponseColumn
{
    public string ColumnName {get;set;}
    public string ColumnValue{get;set;}
}

ResponseColumn rcPortNumber = ParseResponseString("JSON",ResponseString); // Gets me the port number.
ResponseColumn rcServerName = ParseResponseString("NAME",ResponseString); // Gets me the server name.
ResponseColumn rcServerVer  = ParseResponseString("VERS",ResponseString); // Gets me the server version.

ENAMEZVERSAJSON9000UUID$0b5a576d-a276-VERS-a9e8-134c41133102VERS7.9.2
       ^^^^   

private Dictionary<string,string> parseLine(line) {
	dict=New Dictionary<string,string>;
	while not at end of line
		key=readString(4)
		length=readInt(1)
		value=readString(length)
		dict[key]=value
	repeat
	return dict
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace LMS
{
    public class ParseLMSResponse
    {
        private const string NAME = "ENAME";
        private const string PORT = "JSON";
        private const string UUID = "UUID";
        private const string VERS = "VERS";

        private byte[] ResponseBytes { get; set;}
        private Dictionary<string, string> KeyValuePairs { get; set; }

        // Pass the byte array to the constructor
        public ParseLMSResponse(byte[] ResponseBytes)
        {
            this.ResponseBytes = ResponseBytes;
            this.GetKeyValuePairs();
        }

        private void GetKeyValuePairs()
        {
            // Local working variables
            string keyname = "";
            string keyvalue = "";
            int i = 0;
            byte b;
            int DataLen = 0;

            KeyValuePairs = new Dictionary<string, string>();

            while (i < ResponseBytes.Length) // Process the entire array
            {
                keyname = "";
                keyvalue = "";
                b = ResponseBytes[i];

                while (b >= 65 && b <= 90) // Read while byte is an upper case value
                {
                    // This builds up the keyname byte by byte
                    keyname += Convert.ToChar(b);
                    ++i;
                    b = ResponseBytes[i];
                }

                // At the end of the keyname is the data length
                DataLen = Convert.ToInt32(b);

                ++i; // move i to the start of the value

                // Get string value from bytes
                keyvalue = Encoding.UTF8.GetString(ResponseBytes, i, DataLen);

                // Add to dictionary
                KeyValuePairs.Add(keyname, keyvalue);
                i += DataLen;
            }
        }

        public string GetHostName
        {
            get
            {
                return GetValue(NAME);
            }
        }

        public string GetUUID
        {
            get
            {
                return GetValue(UUID);
            }
        }
        public string GetVersion
        {
            get
            {
                return GetValue(VERS);
            }
        }

        public int GetPortNumber
        {
            get
            {
                return Convert.ToInt32(GetValue(PORT));
            }
        }

        private string GetValue(string Name)
        {
            string RetVal = "";
            KeyValuePairs.TryGetValue(Name, out RetVal);
            return RetVal;
        }
    }
}

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();