laatzen/Common/modbus_master_csharp/Device/md_test.cs

using XYLEM.Device.Value;
using MagFlux6200_metrology_reg_list;
using XYLEM.Communication;
using System;
using System.IO.Ports;
using System.Threading.Tasks;

namespace XYLEM.Device
{
    public enum MD_Reg_list
    {
        APP,
        MET
    }

    public class md_test
    {
        #region Access data from normal Application RS485
        internal static readonly Device_value App_F32FlowRate_m3ps = new Device_value("App_F32FlowRate_m3ps", 600, ValueDataType.F32, ValueRW_Type.ReadOnly, "App read flow");
        #endregion


        const int ch_lng_dv = -15;
        const int ch_lng_Version = -3;
        const int ch_lng_MD_adr = -7;
        const int dig_value = 10;

        public void Go(MD_Reg_list md_reg_list_selection, string serial_port, int baudRate, Parity parity)
        {
            ModbusCom md = new ModbusCom(serial_port, baudRate, parity);
            ReadTests(md_reg_list_selection, md);

        }

        public void ReadTests(MD_Reg_list md_reg_list_selection, ModbusCom md)
        {
            var device_id = 1;
            //{ // Testing read of specific registers
            //    var test_rw_items = new[] { reg_list.Met_U32MdbsRegsVer, reg_list.Met_U16DeviceType, reg_list.Met_U32DeviceTypeDetail };

            //    foreach (var testRead in test_rw_items)
            //    {// Testing
            //        Device_value dv = null;
            //        if (md_reg_list_selection == MD_Reg_list.MET) // Metrology
            //        {
            //            dv = testRead;
            //            var ret = md.Read(device_id, dv, new UInt32());
            //            if (ret.IsOkay)
            //            {
            //                var value = ret.Data;
            //                Console.WriteLine($"Read={dv,ch_lng_dv}: Reg_Ver={dv.Version,ch_lng_Version} Adr={dv.MD_adr,-7} value={value,dig_value}");
            //            }
            //        }
            //        else // To application
            //        {
            //            dv = null; // Not yet supported
            //        }
            //    }
            //    return;
            //}


            { // Read ID
                Device_value dv = reg_list.Met_U16DeviceType;
                var ret = md.Read(device_id, dv, new UInt16());
                if (ret.IsOkay)
                {
                    var value = ret.Data;
                    Console.WriteLine($"Read={dv,ch_lng_dv}: Reg_Ver={dv.Version,ch_lng_Version} Adr={dv.MD_adr,ch_lng_MD_adr} value={value,dig_value}");
                }
            }
            {// Read Met_U32MdbsRegsVer 
                Device_value dv = null;
                if (md_reg_list_selection == MD_Reg_list.MET) // Metrology
                {
                    dv = reg_list.Met_U32MdbsRegsVer;
                    var ret = md.Read(device_id, dv, new UInt32());
                    if (ret.IsOkay)
                    {
                        var value = ret.Data;
                        Console.WriteLine($"Read={dv,ch_lng_dv}: Reg_Ver={dv.Version,ch_lng_Version} Adr={dv.MD_adr,-7} value={value,dig_value}");
                    }
                }
                else // To application
                {
                    dv = null; // Not yet supported
                }
            }
            {// Read flow 
                Device_value dv = null;
                string unit = "m3/h";
                Single scale = 1.0f;
                if (md_reg_list_selection == MD_Reg_list.MET) // Metrology
                {
                    dv = reg_list.Met_F32FlowRate_lps;
                    scale = 3.6f; // From l/s to m3/h
                }
                else // To application
                {
                    dv = App_F32FlowRate_m3ps;
                    scale = 3600f; // From m3/s to m3/h
                }
                var ret = md.Read(device_id, dv, new Single());
                if (ret.IsOkay)
                {
                    var value = ret.Data;
                    Console.WriteLine($"Read={dv,ch_lng_dv}: Reg_Ver={dv.Version,ch_lng_Version} Adr={dv.MD_adr,-7} value={(value*scale),dig_value} {unit}");
                }
            }

            {// Read / Write scratch
                Device_value dv = null;
                string unit = "";
                Single scale = 1.0f;
                if (md_reg_list_selection == MD_Reg_list.MET) // Metrology
                {
                    dv = reg_list.Met_F32Scratch_F32;

                    Single value = Single.NaN;
                    { // read
                        var ret = md.Read(device_id, dv, new Single());
                        if (ret.IsOkay)
                        {
                            value = ret.Data;
                            Console.WriteLine($"Read={dv,ch_lng_dv}: Reg_Ver={dv.Version,ch_lng_Version} Adr={dv.MD_adr,-7} value={(value*scale),dig_value} {unit}");
                        }
                    }
                    { // write
                        value += 10;
                        if (!md.Write(device_id, dv, value))
                        {
                            Console.WriteLine($"Write failed={dv,ch_lng_dv}: Reg_Ver={dv.Version,ch_lng_Version} Adr={dv.MD_adr,-7} value={value,dig_value} {unit}");
                        }
                        else
                        {
                            Console.WriteLine($"Write={dv,ch_lng_dv}: Reg_Ver={dv.Version,ch_lng_Version} Adr={dv.MD_adr,-7} value={value,dig_value} {unit}");
                        }
                    }
                    { // read back
                        var ret = md.Read(device_id, dv, new Single());
                        if (ret.IsOkay)
                        {
                            value = ret.Data; ;
                            Console.WriteLine($"Read={dv,ch_lng_dv}: Reg_Ver={dv.Version,ch_lng_Version} Adr={dv.MD_adr,-7} value={(value*scale),dig_value} {unit}");
                        }
                    }
                }
                else // To application
                {
                    dv = null; // Not yet supported
                }
            }
        }
    }
}