EGFramework/Example/UsingTest/Script/EGTest.cs

using Godot;
using static Godot.GD;
using System.Collections.Generic;
using EGFramework;
using Newtonsoft.Json;
using System;
using System.Net;

public partial class EGTest : Node,IEGFramework
{
    public Label label { set; get; }

    public override void _Ready()
    {
        this.EGEnabledProtocolTools();
        
        this.EGMqtt().ConnectMQTTServer("192.168.1.220");
        
        //this.EGUDP().UDPDevices[5555].Connect(IPAddress.Parse("224.0.0.251"),5353);
        //byte[] sendData = { 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x5F, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73, 0x07, 0x5F, 0x64, 0x6E, 0x73, 0x2D, 0x73, 0x64, 0x04, 0x5F, 0x75, 0x64, 0x70, 0x05, 0x6C, 0x6F, 0x63, 0x61, 0x6C, 0x00, 0x00, 0x0C, 0x00, 0x01 };
        //this.EGUDP().UDPDevices[5555].Send(sendData);
        // this.EGRegisterMessageEvent<PrintResponse>((e,sender,protocol)=>{
        //     Print(sender);
        // });
        // this.EGOnMessage<PrintResponse>();
        // this.EGReadFromFile("SaveData/MySeg2.seg2");
        //TestTCPClient();
        //TestSerialPort();
        //TestTCPServer();
        //this.EGUDP();
        //this.EGUDPListen(11000);
        //this.EGSendMessage(new MessageStruct(1,"xxx"),"192.168.1.192:9002",ProtocolType.UDP);
        //this.EGHttpClient();
        //this.EGHttpServer().Listen("http://+:6555/index/");
    }
    public override void _Process(double delta)
    {
        //Print(this.EGMqtt().MqttDevices["192.168.1.220"].IsConnected);
    }
    public override void _ExitTree()
    {

    }

    public void OnButton1Click(){
        this.EGMqtt().SubScribeTheme("192.168.1.220","test");
        byte[] testData = {0x3A,0x55};
        this.EGMqtt().PublishTheme("192.168.1.220","test",testData);
    }
    
    public void RefreshMsg(bool coil){
        label.Text += coil+" ";
    }
    public void OnTimer(){
        //this.EGSendMessage(new MessageStruct(1,"山东博裕1"),"COM4",ProtocolType.SerialPort);
        //this.EGSendMessage(new MessageStruct(1,"山东博裕1"),"192.168.1.244:6060",ProtocolType.TCPClient);
        //this.EGSendMessage(new ModbusTCP_WriteMultiCoil(1,0,sendData),"192.168.1.200:3000",ProtocolType.TCPClient);
        //TestSingleCoil();
        //TestMultiCoil();
        //TestSingleHoldingRegister();
        //TestMultiHoldingRegister();
    }
    public void TestModbus(){
        label = this.GetNode<Label>("Label");
        label.Text = "[Modbus]";
        this.EGRegisterMessageEvent<MessageResponse>((e,sender,type)=>{
            Print("[Got Response]"+"[sender = "+sender+"]"+"["+type+"]"+ e.MessageId+"||"+e.Author);
        });
        this.EGOnMessage<MessageResponse>();
        this.EGRegisterMessageEvent<ModbusTCP_Response>((e,sender,type)=>{
            if(type == ProtocolType.TCPClient && e.FunctionType == ModbusFunctionType.ReadCoil){
                int registerId = 0;
                foreach(bool coil in e.Coil){
                    Print(registerId + "Status：" + coil);
                    registerId++;
                }
            }
            if(type == ProtocolType.TCPClient && e.FunctionType == ModbusFunctionType.ReadDiscreteInput){
                int registerId = 0;
                foreach(bool discreteInput in e.DiscreteInput){
                    Print(registerId + "Status：" + discreteInput);
                    registerId++;
                }
            }
            if(type == ProtocolType.TCPClient && e.FunctionType == ModbusFunctionType.ReadHoldingRegisters){
                int registerId = 0;
                foreach(ushort holdingRegister in e.HoldingRegister){
                    Print(registerId + "Status：" + holdingRegister);
                    registerId++;
                }
            }
            if(type == ProtocolType.TCPClient && e.FunctionType == ModbusFunctionType.ReadInputRegisters){
                int registerId = 0;
                foreach(ushort inputRegister in e.InputRegister){
                    Print(registerId + "Status：" + inputRegister);
                    label.Text+=registerId + "Status：" + inputRegister;
                    registerId++;
                }
            }
            //this.EGOffMessage<ModbusTCP_Response>();
        });

        this.EGRegisterMessageEvent<ModbusRTU_Response>((e,sender,type)=>{
            if(type == ProtocolType.SerialPort && e.FunctionType == ModbusFunctionType.ReadCoil){
                int registerId = 0;
                foreach(bool coil in e.Coil){
                    Print(registerId + "Status：" + coil);
                    registerId++;
                }
            }
            if(type == ProtocolType.SerialPort && e.FunctionType == ModbusFunctionType.ReadDiscreteInput){
                int registerId = 0;
                foreach(bool discreteInput in e.DiscreteInput){
                    Print(registerId + "Status：" + discreteInput);
                    registerId++;
                }
            }
            if(type == ProtocolType.SerialPort && e.FunctionType == ModbusFunctionType.ReadHoldingRegisters){
                int registerId = 0;
                foreach(ushort holdingRegister in e.HoldingRegister){
                    Print(registerId + "Status：" + holdingRegister);
                    registerId++;
                }
            }
            if(type == ProtocolType.SerialPort && e.FunctionType == ModbusFunctionType.ReadInputRegisters){
                int registerId = 0;
                foreach(ushort inputRegister in e.InputRegister){
                    Print(registerId + "Status：" + inputRegister);
                    label.Text+=registerId + "Status：" + inputRegister;
                    registerId++;
                }
            }
            //this.EGOffMessage<ModbusRTU_Response>();
        });
        
    }

    public void TestTCPServer(){
        this.EGTCPServer().OnClientConnect.Register(e=>{
            Print(e +" is connected");
            this.EGSendMessage(new MessageStruct(1,"Hello"),e,ProtocolType.TCPServer);
        });
        this.EGTCPServer().OnClientDisconnect.Register(e=>{
            Print(e +" is disconnect");
        });
        this.EGTCPServerListen(9999);
    }

    public void TestSqlite(){
        this.EGSqlite().SaveData(new TestBoxMessage());
        List<TestBoxMessage> result = this.EGSqlite().GetDataSet<TestBoxMessage>();
        if(result == null){
            PrintErr(this.EGSqlite().ExceptionMsg);
        }
        Print("Result = " + result[0].TestDouble + result[0].TestFloat);
    }
    public void TestSerialPort(){
        this.EGSerialPort().SetBaudRate(9600);
        this.EGSendMessage(new ModbusRTU_ReadInputRegisters(1,0,2),"COM4",ProtocolType.SerialPort);
        this.EGSendMessage(new ModbusRTU_ReadCoils(1,0,8),"COM4",ProtocolType.SerialPort);
        this.EGOnMessage<ModbusRTU_Response>();
    }

    public void TestTCPClient(){
        this.EGTCPClient();
        this.EGSendMessage(new ModbusTCP_ReadDiscreteInput(1,0,8),"192.168.1.196:6000",ProtocolType.TCPClient);
        this.EGSendMessage(new ModbusTCP_ReadInputRegisters(1,0,2),"192.168.1.196:6000",ProtocolType.TCPClient);
        this.EGOnMessage<ModbusTCP_Response>();
    }

    private bool IsOpen = false;
    public void TestSingleCoil(){
        if(IsOpen){
            //this.EGSendMessage(new ModbusRTU_WriteSingleCoil(1,0,false),"COM4",ProtocolType.SerialPort);
            this.EGSendMessage(new ModbusTCP_WriteSingleCoil(1,0,false),"192.168.1.196:6000",ProtocolType.TCPClient);
            IsOpen = false;
        }else{
            //this.EGSendMessage(new ModbusRTU_WriteSingleCoil(1,0,true),"COM4",ProtocolType.SerialPort);
            this.EGSendMessage(new ModbusTCP_WriteSingleCoil(1,0,true),"192.168.1.196:6000",ProtocolType.TCPClient);
            IsOpen = true;
        }
    }
    public void TestMultiCoil(){
        byte[] OpenCode = {0xFF};
        byte[] CloseCode = {0x00};
        if(IsOpen){
            this.EGSendMessage(new ModbusRTU_WriteMultiCoil(1,0,CloseCode.ToBoolArray()),"COM4",ProtocolType.SerialPort);
            IsOpen = false;
        }else{
            this.EGSendMessage(new ModbusRTU_WriteMultiCoil(1,0,OpenCode.ToBoolArray()),"COM4",ProtocolType.SerialPort);
            IsOpen = true;
        }
    }
    public void TestSingleHoldingRegister(){
        if(IsOpen){
            this.EGSendMessage(new ModbusRTU_WriteSingleHoldingRegister(1,0,0x00),"COM4",ProtocolType.SerialPort);
            IsOpen = false;
        }else{
            this.EGSendMessage(new ModbusRTU_WriteSingleHoldingRegister(1,0,0x01),"COM4",ProtocolType.SerialPort);
            IsOpen = true;
        }
    }
    public void TestMultiHoldingRegister(){
        ushort[] OpenCode = {1,1,1,1,1,1,1,1};
        ushort[] CloseCode = {0,0,0,0,0,0,0,0};
        if(IsOpen){
            this.EGSendMessage(new ModbusRTU_WriteMultiHoldingRegister(1,0,CloseCode),"COM4",ProtocolType.SerialPort);
            IsOpen = false;
        }else{
            this.EGSendMessage(new ModbusRTU_WriteMultiHoldingRegister(1,0,OpenCode),"COM4",ProtocolType.SerialPort);
            IsOpen = true;
        }
    }

}
public class TestBoxMessage {
    public int Code = 0;
    public float TestFloat = 0.1f;
    public double TestDouble;
    public bool IsHaveMessage;
    public string MessageInfo;
    public MessageType MsgType;
    public MessageStruct MsgStruct;
    public MessagePair MsgPair;
    public TestBoxMessage(){
        this.Code = 1;
        this.TestFloat = 1.2f;
        this.TestDouble = 2.52;
        this.IsHaveMessage = true;
        this.MessageInfo = "DefaultInfo";
        MsgType = MessageType.TypeInt;
        MsgPair = new MessagePair();
        MsgStruct = new MessageStruct(5,"Ad");
    }
    public string ToProtocolData()
    {
        return JsonConvert.SerializeObject(this);
    }
}
public class MessagePair{
    public int MessageId;
    public string Author;
    public string MessageInfo;
    public int TimeStamp;
    public MessagePair(){
        this.MessageId = 10001;
        this.Author = "Admin";
        this.MessageInfo = "Hello every one!";
        this.TimeStamp = 1690188342;
    }
}
public struct MessageStruct : IRequest,IEGFramework{
    public string FunctionCode;
    public int MessageId;
    public string Author;
    public MessageStruct(int messageId,string author){
        FunctionCode = "Message";
        MessageId = messageId;
        Author = author;
    }
    public byte[] ToProtocolByteData()
    {
        return JsonConvert.SerializeObject(this).ToBytesByEncoding("GBK");
    }
    public string ToProtocolData()
    {
        return "";
        //return JsonConvert.SerializeObject(this);
    }
}
public struct MessageResponse : IResponse
{
    public string FunctionCode { set; get; }
    public int MessageId;
    public string Author;
    public bool TrySetData(string protocolData, byte[] protocolBytes)
    {
        try
        {
            //GD.Print(protocolData);
            MessageResponse res = JsonConvert.DeserializeObject<MessageResponse>(protocolData);
            if(res.FunctionCode == "Message"){
                this.FunctionCode = res.FunctionCode;
                this.MessageId = res.MessageId;
                this.Author = res.Author;
                return true;
            }
            return false;
        }
        catch (Exception)
        {
            return false;
        }
    }
}

public struct PrintResponse : IResponse
{
    public bool TrySetData(string protocolData, byte[] protocolBytes)
    {
        //Print("Received String is " + protocolData);
        Print("Received bytes is " + protocolBytes.ToStringByHex());
        return true;
    }

}

public enum MessageType{
    TypeString = 1,
    TypeInt = 2,
    TypeObject = 3,
    TypeArray = 4
}