eaxing_back_africa_charger/ConsoleStarter/Program.cs

// See https://aka.ms/new-console-template for more information

using System.Diagnostics;
using System.IO.Pipes;
using HslCommunication.Core;
using HybirdFrameworkCore.Autofac.Attribute;
using HybirdFrameworkCore.Utils;
using HybirdFrameworkDriver.ModbusTcpMaster;

internal class Program
{
    public static void Main(string[] args)
    {
        ModbusTcpMaster master = new ModbusTcpMaster()
        {
            Ip = "192.168.1.5",
            //默认DataFormat.ABCD
            //DataFormat = DataFormat.ABCD,
            ReadAction = ReadFunc
        };

        bool connected = master.Connect();
        Debug.Assert(connected, "连接modbus server 失败");

        #region 测试写
        WaterCoolData coolData = new WaterCoolData();

        //写入ushort
        coolData.ushortType.Value = 18;
        bool writeResult4 = master.WriteValue(coolData.ushortType);
        Debug.Assert(writeResult4, "写入失败");
        //写入byte 0-8 byte[1]
        coolData.Status.Value = 12;
        bool writeResult1 = master.WriteValue(coolData.Status);
        Debug.Assert(writeResult1, "写入失败");
        //写入bit
        coolData.DraughtFan1.Value = true;
        bool writeResult3 = master.WriteValue(coolData.DraughtFan1);
        Debug.Assert(writeResult3, "写入失败");

        coolData.Temperature1.Value = 12.7f;
        bool writeResult5 = master.WriteValue(coolData.Temperature1);
        Debug.Assert(writeResult5, "写入失败");

        #endregion 测试写
    }
    private static WaterCoolData coolData = new WaterCoolData();
    private static void ReadFunc(ModbusTcpMaster master)
    {
        byte[]? bytes = master.BatchRead(1, 46);
        if (bytes != null)
        {
            ModbusDecoder.Decode<WaterCoolData>(bytes, coolData);
            Debug.WriteLine("12.7f" + coolData.Temperature1.Value);
            Debug.WriteLine("12" + coolData.Status.Value);
            Debug.WriteLine("fasle" + coolData.CompressorState1.Value);
            Debug.WriteLine("18" + coolData.ushortType.Value);
        }
    }

    private static void Test1()
    {
        Console.WriteLine("Hello, World!");
        List<PropertyAttribute> list = new List<PropertyAttribute>
        {
            new(0, 4),
            new(4, 8),
            new(12, 1),
            new(13, 2),
            new(15, 1),
            new(16, 1),
            new(17, 1),
            new(18, 2),
            new(20, 2),
            new(22, 2),
            new(24, 2),
            new(26, 1),
            new(27, 2),
            new(29, 2),
            new(31, 1),
            new(32, 1),
            new(33, 29)
        };


        Queue<EncodeData> queue = new Queue<EncodeData>();
        int size = 0;
        foreach (PropertyAttribute p in list)
        {
            size += p.Length;
            if (size < 8)
            {
                queue.Enqueue(new EncodeData()
                {
                    Start = 0,
                    Length = p.Length
                });
            }
            else
            {
                Console.WriteLine("---------------------------begin one byte---------------------");
                int length = 0;
                while (queue.Count > 0)
                {
                    EncodeData data = queue.Dequeue();
                    length += data.Length;
                    Console.WriteLine($"use {data.Start}, {data.Length}");
                }

                size -= length;

                int occupy = 8 - length;
                Console.WriteLine($"use 0, {occupy}");
                Console.WriteLine("---------------------------end one byte---------------------");
                size -= occupy;
                while (size >= 8)
                {
                    Console.WriteLine("---------------------------begin one byte---------------------");
                    Console.WriteLine($"use {occupy}, 8");
                    Console.WriteLine("---------------------------end one byte---------------------");
                    size -= 8;
                    occupy += 8;
                }

                if (size > 0)
                {
                    queue.Enqueue(new EncodeData()
                    {
                        Start = occupy,
                        Length = size
                    });
                }
            }
        }

        foreach (EncodeData d in queue)
        {
            Console.WriteLine($"{d.Start}, {d.Length}");
        }

        UInt32 i = UInt32.MaxValue - 1;
        byte[] bytes = BitConverter.GetBytes(i).Reverse().ToArray();
        foreach (byte b in bytes)
        {
            Console.WriteLine(b);
        }

        Console.WriteLine(BitUtls.BytesToHexStr(bytes));
        UInt32 r = BitConverter.ToUInt32(bytes);
        Console.WriteLine(r);
        bytes = BitConverter.GetBytes(r);
        foreach (byte b in bytes)
        {
            Console.WriteLine(b);
        }

        Console.WriteLine(BitUtls.BytesToHexStr(bytes));
    }
}

public struct EncodeData
{
    public int Start { get; set; }
    public int Length { get; set; }
    public byte[] Value { get; set; }
}