[Nuvem nativo] Desenvolvimento de aplicativos baseados em FlexManager para dispositivos na nuvem

---

prefácio

Os artigos anteriores introduziram várias operações de dados na nuvem do dispositivo FlexManager, acredito que todos o leram. No início deste artigo, apresentaremos como usar os dados do banco de dados da nuvem do dispositivo para o desenvolvimento de aplicativos cliente um por um. Claro que o equipamento mais básico para entrar na nuvem deve ter algum conhecimento básico de automação, se os alunos estiverem interessados, eles podem acessar meus materiais de aprendizagem para aprender uma onda, e não vou focar nisso aqui. Este artigo se concentra no desenvolvimento de aplicativos do Visual Studio baseados no FlexManager.

---

`Instruções especiais:
1. Aplicável ao Visual Studio versão 15.3 e superior.
2. Os pacotes de dependência do NuGet FBoxClientDriver e FBoxClientDriver.Contract precisam ser introduzidos.

1. Desenvolvimento de aplicativos do Visual Studio

1. Etapas do processo

①Parâmetros de configuração
②Criar objeto DefaultCredentialProvider

③Crie um objeto FBoxClientManager ④Faça login no
servidor

⑤Ouça o evento de mudança de estado da caixa
⑥Ouça o evento de mudança de push de dados em tempo real

⑦ Abra o push de dados de todos os pontos de monitoramento da caixa

⑧Definir método
⑨Chamar método

2. Código de exemplo

Nota: Você precisa abrir um ponto antes do envio de dados

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using FBoxClientDriver;
using FBoxClientDriver.Contract;
using FBoxClientDriver.Impl;

namespace SDKDEMO
{
    
    
    //配置参数
    public class FBoxClientParameters
    {
    
    
        public static string ClientId {
    
     get; set; } = "";
        public static string ClientSecret {
    
     get; set; } = "";
        public static string UserName {
    
     get; set; } = "";
        public static string Password {
    
     get; set; } = "";
        public static string IdServer {
    
     get; set; } = "https://account.flexem.com/core";
        public static string MainServer {
    
     get; set; } = "http://fbox360.com";
        public static string HdataServer {
    
     get; set; } = "http://fbhs1.fbox360.com";
    }

    public class FBoxDemo : IDisposable
    {
    
    
        private readonly IFBoxClientManager _fbox;
        private readonly string boxNo = "300015050009"; // 以这个为例子

        public FBoxDemo()
        {
    
    
            //创建对象并初始化
            var provider =
                new DefaultCredentialProvider(FBoxClientParameters.ClientId, FBoxClientParameters.ClientSecret,
                    FBoxClientParameters.UserName, FBoxClientParameters.Password);
            _fbox = new FBoxClientManager(FBoxClientParameters.IdServer, FBoxClientParameters.MainServer,
                FBoxClientParameters.HdataServer, provider, Guid.NewGuid().ToString("N"), null);
        }

        public void Dispose()
        {
    
    
            _fbox?.Dispose();
        }

       /// <summary>
        /// 启动
        /// </summary>
        public void Start()
        {
    
    
            //初始化SDK，内部建立signalr连接对象，Restart只需全局执行一次。
            _fbox.Restart().Wait();
            //侦听盒子状态变更事件
            _fbox.BoxConnectStateChanged += _fbox_BoxConnectStateChanged;
            //侦听实时数据变更事件
            _fbox.DataMonitorValueChanged += _fbox_DataMonitorValueChanged;
        }

        /// <summary>
        /// 实时数据变更函数
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void _fbox_DataMonitorValueChanged(object sender, IList<DataMonitorValueChangedArgs> e)
        {
    
    
            foreach (var dmon in e)
                Console.WriteLine($"dmv:{dmon.Uid}:{dmon.Value},{dmon.Status}");
        }

        /// <summary>
        /// 盒子状态变更函数
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void _fbox_BoxConnectStateChanged(object sender, IList<BoxConnectionStateItem> e)
        {
    
    
            //NewState：1、2是盒子在线状态。0、3为盒子不在线状态，根据盒子状态对盒子进行开点操作
            foreach (var stateItem in e)
            {
    
    
                Console.WriteLine($"{stateItem.BoxNo},{stateItem.NewState}");
            }
        }

        /// <summary>
        /// 开启盒子所有监控点
        /// </summary>
        public void StartAllDMonData()
        {
    
    
            //盒子每次掉线后，重新上线后均需要重新开点
            try
            {
    
    
                _fbox.StartAllDataMonitorPointsOnBox(new BoxArgs(boxNo)).Wait();//boxNo为盒子号
            }
            catch (Exception ex)
            {
    
    
                switch (ex.Message)
                    {
    
    
                        // 未登录服务器，请先Restart()
                        case "Box server not found.":; break;
                        // 当前账号下未找到BoxNo序列号的盒子
                        case "Not Found":; break;
                        default:; break;
                    }
            }
        }

        /// <summary>
        /// 获取盒子分组和盒子信息
        /// </summary>
        public void GetBoxGroups()
        {
    
    
            var grpList = _fbox.GetBoxGroups().Result;
            foreach (var grp in grpList)
            {
    
    
                Console.WriteLine(grp.Uid);                 // 盒子分组的Uid
                Console.WriteLine(grp.Name);                // 盒子分组名称
                foreach (var box in grp.Boxes)              // 遍历分组下的盒子集合
                {
    
    
                    Console.WriteLine(box.BoxId);           // 盒子Id
                    Console.WriteLine(box.Alias);           // 盒子名称
                    Console.WriteLine(box.BoxNo);           // 盒子号码
                    Console.WriteLine(box.ConnectionState); // 获取的时候盒子状态， 不能作为实时状态用，也不能一直调用这个接口来作为盒子状态变更，盒子状态变更请使用SignalR实时推送
                    Console.WriteLine(box.NetworkType);     // 网络类型   1:网络, 2:2G, 3:3G (这个不支持),4:Wifi ,5:4G 
                    Console.WriteLine(box.Disabled);        // 盒子是否被禁用
                    Console.WriteLine(box.ApiBaseUrl);      // ApiBaseUrl服务器地址
                    Console.WriteLine(box.SignalrUrl);      // SignalR服务器地址
                    Console.WriteLine(box.Owned);           // 是否为拥有者
                    Console.WriteLine(box.BoxType);         // 盒子类型， 0：标准盒子，1：mini盒子,2:Lite 3：VPN盒子
                }
            }
        }
        //定义方法
    }
    class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                fbox.Start();
                fbox.StartAllDMonData();
                fbox.GetBoxGroups();
                //调用定义的方法
                Console.ReadLine();
            }
        }
    }
}

Ao criar e inicializar uma instância IFBoxClientManager, você precisa fornecer os seguintes parâmetros: clientId, clientsecret, username, password, Id server, App server e Hdata Server.
nome de usuário e senha são a conta e a senha do FlexManager.
clientId e clientsecret são a conta e a senha do aplicativo de vendas.
Se o servidor de ID, o servidor de aplicativos e o servidor Hdata estiverem na nuvem pública, eles permanecerão inalterados e a nuvem privada será alterada para o endereço correspondente.

Em segundo lugar, o método de operação específico

1. Introduzir pacotes de dependência

Instruções especiais:
1. Este pacote de dependência se aplica ao Visual Studio versão 15.3 e superior.
Etapa 1: usar o VS2019 para criar um programa .NET Core Console
Etapa 2: apresentar pacotes de dependência do NuGet

FBoxClientDriver
FBoxClientDriver.Contract,
por exemplo, apresenta o pacote FBoxClientDriver
Método 1

Execute a seguinte instrução na linha de comando do Visual Studio2019
PM> Install-Package FBoxClientDriver
```

Método 2

Importe o projeto no Visual Studio 2019 e introduza o nome do pacote dependente na biblioteca de pacotes NuGet, conforme mostrado abaixo.

2. Inicialização

Faça login no servidor através dos parâmetros de configuração

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using FBoxClientDriver;
using FBoxClientDriver.Contract;
using FBoxClientDriver.Impl;

namespace SDKDEMO
{
    
    
    //配置参数
    public class FBoxClientParameters
    {
    
    
        public static string ClientId {
    
     get; set; } = "ClientId";
        public static string ClientSecret {
    
     get; set; } = "ClientSecret";
        public static string UserName {
    
     get; set; } = "UserName";
        public static string Password {
    
     get; set; } = "Password";
        public static string IdServer {
    
     get; set; } = "https://account.flexem.com/core";
        public static string MainServer {
    
     get; set; } = "http://fbox360.com";
        public static string HdataServer {
    
     get; set; } = "http://fbhs1.fbox360.com";
    }

    public class FBoxDemo : IDisposable
    {
    
    
        private readonly IFBoxClientManager _fbox;
        private readonly string boxNo = "300015050009"; // 以这个为例子

        public FBoxDemo()
        {
    
    
            //创建对象并初始化
            var provider =
                new DefaultCredentialProvider(FBoxClientParameters.ClientId, FBoxClientParameters.ClientSecret,
                    FBoxClientParameters.UserName, FBoxClientParameters.Password);
            _fbox = new FBoxClientManager(FBoxClientParameters.IdServer, FBoxClientParameters.MainServer,
                FBoxClientParameters.HdataServer, provider, Guid.NewGuid().ToString("N"), null);
        }

        public void Dispose()
        {
    
    
            _fbox?.Dispose();
        }

       /// <summary>
        /// 启动
        /// </summary>
        public void Start()
        {
    
    
            //初始化SDK，内部建立signalr连接对象，Restart只需全局执行一次。
            _fbox.Restart().Wait();
        }
    }
    class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                //调用启动方法，内部建立signalr连接对象，Restart只需全局执行一次。
                fbox.Start();

                Console.ReadLine();
            }
        }
    }
}

3. Abra todos os pontos de monitoramento do FBox especificado

Habilita o envio de dados de todos os pontos de monitoramento do FBox online atual

/// <summary>
/// 开启盒子所有监控点
/// </summary>
public void StartAllDMonData()
{
    
    
    //盒子掉线后，每次上线均需要调此接口
    _fbox.StartAllDataMonitorPointsOnBox(new BoxArgs(boxNo)).Wait();//boxNo为盒子号
}
//在Program，Main函数中调用
class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                fbox.Start();  //启动
                fbox.StartAllDMonData();//开启FBox所有监控点
            }
        }
    }

Habilitar envio de dados do ponto de monitoramento Você
pode habilitar o envio de dados do ponto de monitoramento especificado

/// <summary>
/// 开启监控点数据推送
/// </summary>
public void StartDmonData()
{
    
    
    // 调接口新增监控点后，需要调此接口才能收到新增点的数据推送
    _fbox.StartDataMonitorPoint(new DataMonitorPointArgs()
    {
    
    
        BoxNo = boxNo,                      //盒子号
        DataMonitorUid = 113470726140747285 //监控点Uid
    });
}
//在Program，Main函数中调用
class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                fbox.Start();  //启动
                fbox.StartDmonData();//开启监控点
            }
        }
    }

4. Push de mudança de status da caixa

Quando o servidor detecta que o estado do FBox mudou, ele enviará uma
mensagem. O conteúdo da mensagem é um array
. As propriedades de um único objeto são as seguintes

nome do campo	modelo	Descrição do parâmetro
Eu iria	corda	ID do FBox
Estado	int	Estado atual da caixa, 0: desconhecido, 1: conectado, 2: esgotado, 3: desconectado
internet	int	Tipo de rede Box 1: rede 2: 2G, 3: 3G (atualmente não suportado) 4: WIFI, 5: 4G
rssi	int	Sinal: 0~8
em direção	objeto json	Versão do firmware FBox, fcs, fds, floader.
modo	int	Status FBox 0: normal, 1: transmissão transparente

ouvir eventos

/// <summary>
/// 启动
/// </summary>
public void Start()
{
    
    
    // 通过参数登录服务器
    _fbox.Restart().Wait();
    //侦听盒子状态变更事件
    _fbox.BoxConnectStateChanged += _fbox_BoxConnectStateChanged;
}
//在Program，Main函数中调用
class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                fbox.Start();  //启动
                fbox.StartAllDMonData();//开启FBox所有监控点
            }
        }
    }

/// <summary>
/// 盒子状态变更函数
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void _fbox_BoxConnectStateChanged(object sender, IList<BoxConnectionStateItem> e)
{
    
    
    foreach (var stateItem in e)
    {
    
    
        Console.WriteLine($"{stateItem.BoxNo},{stateItem.NewState}");
    }
}

5. Envio de dados em tempo real

Pré-requisitos: O ponto de monitoramento foi aberto e toda vez que a caixa ficar offline, ela precisa ser reaberta depois que ficar online novamente.
Quando os dados do ponto de monitoramento mudam ou o item de monitoramento é aberto, o servidor envia uma mensagem .

nome do campo	modelo	Descrição do parâmetro
boxSessionId	int	Ignorar por enquanto
valores	matriz json	O conjunto de valores do ponto de monitoramento, os detalhes de um único atributo são mostrados na tabela a seguir
boxUid	corda	id do FBox

valor atributo correspondente

nome do campo	modelo	Descrição do parâmetro
Eu iria	corda	uid de entrada do ponto de monitoramento
valor	corda	valor, se a entrada estiver configurada com casas decimais, o programa precisa ser transferido sozinho, e o servidor não faz nenhuma transferência
status	int	Não esta propriedade se a entrada estiver OK 1: Sem dados, 2: Tempo limite, 3: Erro, 4: Exceção de soquete, 5: Erro de FDS, 16: Incompleto

ouvir eventos

/// <summary>
/// 启动
/// </summary>
public void Start()
{
    
    
    // 通过参数登录服务器
    _fbox.Restart().Wait();
    //侦听实时数据变更事件
    _fbox.DataMonitorValueChanged += _fbox_DataMonitorValueChanged;
}
//在Program，Main函数中调用
class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                fbox.Start();  //启动
                fbox.StartAllDMonData();//开启FBox所有监控点
            }
        }
    }

/// <summary>
/// 实时数据变更函数
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void _fbox_DataMonitorValueChanged(object sender, IList<DataMonitorValueChangedArgs> e)
{
    
    
    foreach (var dmon in e)
        Console.WriteLine($"dmv:{dmon.Uid}:{dmon.Value},{dmon.Status}");
}

6. Obtenha informações e agrupamento de caixas

/// <summary>
/// 获取盒子分组和盒子信息
/// </summary>
public void GetBoxGroups()
{
    
    
    var grpList = _fbox.GetBoxGroups().Result;
    foreach (var grp in grpList)
    {
    
    
        Console.WriteLine(grp.Uid);                 // 盒子分组的Uid
        Console.WriteLine(grp.Name);                // 盒子分组名称
        foreach (var box in grp.Boxes)              // 遍历分组下的盒子集合
        {
    
    
            Console.WriteLine(box.BoxId);           // 盒子Id
            Console.WriteLine(box.Alias);           // 盒子名称
            Console.WriteLine(box.BoxNo);           // 盒子号码
            Console.WriteLine(box.ConnectionState); // 获取的时候盒子状态， 不能作为实时状态用，也不能一直调用这个接口来作为盒子状态变更，盒子状态变更请使用SignalR实时推送
            Console.WriteLine(box.NetworkType);     // 网络类型   1:网络, 2:2G, 3:3G (这个不支持),4:Wifi ,5:4G 
            Console.WriteLine(box.Disabled);        // 盒子是否被禁用
            Console.WriteLine(box.ApiBaseUrl);      // ApiBaseUrl服务器地址
            Console.WriteLine(box.SignalrUrl);      // SignalR服务器地址
            Console.WriteLine(box.Owned);           // 是否为拥有者
            Console.WriteLine(box.BoxType);         // 盒子类型， 0：标准盒子，1：mini盒子,2:Lite 3：VPN盒子
        }
    }
}
//在Program，Main函数中调用
class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                fbox.Start();  //启动
                fbox.StartAllDMonData();//开启FBox所有监控点
                fbox.GetBoxGroups();//调用此方法
            }
        }
    }

7. Obtenha o agrupamento de pontos de monitoramento da caixa e a entrada do ponto de monitoramento

/// <summary>
/// 获取盒子监控点分组和监控点条目
/// </summary>
/// <returns></returns>
public IList<DmonItemDtoV2> GetDmonGroups()
{
    
    
    var dmonGrps = _fbox.GetDmonGroupDmonsV2(new BoxArgs(boxNo)).Result;
    foreach (var grp in dmonGrps)
    {
    
    
        Console.WriteLine(grp.Id);          // 监控点分组的Id
        Console.WriteLine(grp.Name);        // 监控点分组的名称
        foreach (var item in grp.Items)     // 遍历当前分组grp下所有的监控点条目
        {
    
    
            Console.WriteLine(item.Id);     //监控点Id
            Console.WriteLine(item.Name);   //监控点名称
            Console.WriteLine(item.DevAlias); //PLC别名
            Console.WriteLine(item.StationNo); //站号
            Console.WriteLine(item.IsDeviceChanged);//设备是否被移除（只有在移除时出现该参数，为true）FBox的连接设备変更后会出现该参数
            Console.WriteLine(item.TaskState);  //条目状态
            Console.WriteLine(item.DeadValue);  //死值区
            Console.WriteLine(item.BitIndex);   //按位索引号
            Console.WriteLine(item.BitIndexEnabled);//是否启用按位索引号
            Console.WriteLine(item.BitStateLabel);//位类型数据标签
            Console.WriteLine(item.CharCount);  //字符个数
            Console.WriteLine(item.DataType);   //数据类型
            Console.WriteLine(item.Encoding);   //编码方式
            Console.WriteLine(item.FractionalDigits);//小数位
            Console.WriteLine(item.GroupId);    //监控点分组
            Console.WriteLine(item.GroupName);  //监控点名称
            Console.WriteLine(item.IntegralDigits);//整数位（目前无作用）
            Console.WriteLine(item.IoWidth);    //寄存器位宽
            Console.WriteLine(item.MainAddress);//主地址
            Console.WriteLine(item.Memo);       //备注
            Console.WriteLine(item.Privilege);  //读写模式
            Console.WriteLine(item.RegId);      //寄存器Id
            Console.WriteLine(item.RegName);    //寄存器名称
            Console.WriteLine(item.StringByteOrder);//字节序
            Console.WriteLine(item.SubAddress); //子地址
            Console.WriteLine(item.SubIndex);   //DB块地址
            Console.WriteLine(item.TrafficSaving);//是否开启省流量模式
            Console.WriteLine(item.Unit);       //单位
            Console.WriteLine(item.ValueTransform);//数据运算
        }
    }
    return dmonGrps.SelectMany(x => x.Items).ToArray();//监控点条目集合
}
//在Program，Main函数中调用
class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                fbox.Start();  //启动
                fbox.StartAllDMonData();//开启FBox所有监控点
                fbox.GetDmonGroups();//调用此方法
            }
        }
    }

8. Gravação do valor do ponto de monitoramento

/// <summary>
/// 监控点写值
/// </summary>
/// <param name="requet"></param>
public void WriteDmonValue(WriteDmonRequest requet)
{
    
    
    _fbox.WriteValue(new DataMonitorWriteValueArgsV2()
    {
    
    
        BoxNo = requet.BoxNo,                     //盒子号
        DataMonitorGroupName = requet.DmonGrpName,//监控点组名称
        DataMonitorName = requet.DmonName,        //监控点条目名称
        Value = requet.Value,                     //条目的值
        Type = WriteValueType.AutoParse //条目值类型，0：和监控点值类型一致,1：十进制,2：字符串,
    }).Wait();
}

public class WriteDmonRequest
{
    
    
    public string BoxNo {
    
     get; set; }
    public string DmonGrpName {
    
     get; set; }
    public string DmonName {
    
     get; set; }
    public object Value {
    
     get; set; }
}
//在Program，Main函数中调用
class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                fbox.Start();  //启动
                fbox.StartAllDMonData();//开启FBox所有监控点
                fbox.WriteDmonValue();//调用此方法
            }
        }
    }

9. Operação de acionamento

Obtenha todos os PLCs sob a caixa

/// <summary>
/// 获取盒子下的所有PLC
/// </summary>
public void GetPlcs()
{
    
    
    var boxplc = _fbox.GetPlcDeviceV2(new BoxArgs()
    {
    
    
        BoxNo = boxNo                              //盒子号
    }).Result;
    foreach (var plc in boxplc)
    {
    
    
        Console.WriteLine(plc.Alias);               //plc别名
        Console.WriteLine(plc.BaudRate);            //波特率
        Console.WriteLine(plc.BroadcastStationNo);  //广播站号
        Console.WriteLine(plc.Class);//设备类型，0:主设备，1：从设备，2：主从设备（目前不支持）
        Console.WriteLine(plc.DataBits);            //数据位
        Console.WriteLine(plc.DefaultStationNo);    //默认广播站号
        Console.WriteLine(plc.EnableBroadcast);     //使能广播站号
        Console.WriteLine(plc.Interface);//串口接口类型，0：RS232，1：RS485_2，2：RS485_4，85：网络（串口1支持RS232、RS485_2和RS485_4,串口2仅支持RS485_2，串口3仅支持RS232）
        Console.WriteLine(plc.Ip);        //IP地址
        Console.WriteLine(plc.ParityType);//校验位，none：无校验，odd：奇校验，even：偶校验
        Console.WriteLine(plc.PlcAdvancedSettings); //高级设置
        Console.WriteLine(plc.PlcDongleFlag);  //远程停机状态
        Console.WriteLine(plc.PlcId);         //PLCId
        Console.WriteLine(plc.SlaveNo);        //从设备号
        Console.WriteLine(plc.StopBits);     //停止位
        Console.WriteLine(plc.PlcName);      //PLC名称
        Console.WriteLine(plc.Type);       //类型，0：串口，2：以太网
        Console.WriteLine(plc.Port);       //以太网端口号
        Console.WriteLine(plc.PortNo);     //站号
    }
}
//在Program，Main函数中调用
class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                fbox.Start();  //启动
                fbox.StartAllDMonData();//开启FBox所有监控点
                fbox.GetPlcs();//调用此方法
            }
        }
    }

Baixar PLC

/// <summary>
/// 下载PLC
/// </summary>
public void DownloadPlc()
{
    
    
    _fbox.DownLoadPlcsV2(new AddOrUpdatePlcDeviceArgsV2()
    {
    
    
        BoxNo = boxNo,
        PlcList = new List<AddOrUpdatePlcDeviceV2>()
        {
    
    
            //以下为下载一个plc为例
            //注意，本方法下载plc时会覆盖之前的plc，如需多个plc，自行添加
            new AddOrUpdatePlcDeviceV2()
            {
    
    
                PlcId =  305,                       //PLCId
                PlcName = "ABB",                    //PLC名称
                Alias = "ABB AC500_RTU",            //别名
                Type = ServerType.Serial,     //类型，0：串口，2：以太网
                PortNo = 1,                        //编号
                Class = PlcClass.Master,       //设备类型，0:主设备，1：从设备，2：主从设备（目前不支持）
                DefaultStationNo = 1,               //默认站号
                Interface = DeviceInterfaceTypes.Tcp,//串口接口类型，0：RS232，1：RS485_2，2：RS485_4，85：网络（串口1支持RS232、RS485_2和RS485_4,串口2仅支持RS485_2，串口3仅支持RS232）
                BaudRate = 9600,                   //波特率
                Port = 0,                       //网络设备端口号
                DataBits = 8,                     //数据位
                StopBits = 1,                      //停止位
                ParityType = ParityType.None, //校验位，none：无校验，odd：奇校验，even：偶校验
                Ip = "0",                        //IP地址
                EnableBroadcast = false,      //是否启动广播站号
                BroadcastStationNo = 0,        //广播站号
            }
        }
    }).Wait();
}
//在Program，Main函数中调用
class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                fbox.Start();  //启动
                fbox.StartAllDMonData();//开启FBox所有监控点
                fbox.DownloadPlc();//调用此方法
            }
        }
    }

10. Operação do ponto de monitoramento

Adicionar entrada de ponto de monitoramento

Depois que o ponto de monitoramento é adicionado, você precisa se conectar ao SignalR e habilitar o envio de dados do ponto de monitoramento adicionado.

/// <summary>
/// 新增监控点条目
/// </summary>
public void AddDMon()
{
    
    
    _fbox.AddDataMonitorPointV2(new AddDmonsArgsV2()
    {
    
    
        AddDmons = new List<AddDataMonitorDefinitionV2>()
        {
    
    
            new AddDataMonitorDefinitionV2()
            {
    
    
                GroupName =  "fff",//监控点分组名称，和groupId任选一个使用，若使用不存在的监控点分组，则会自动增加该分组
                Name  = "xxxxx",//监控点名称
                DevAlias = "Local",//PLC别名
                StationNo = 1,//站号
                DataType = DataType.Int16,//数据类型，详情见接口文档中附录二
                RegName = "LW",//寄存器名称，和regId、iowidth确定唯一寄存器
                Privilege = PrivilegeType.ReadWrite,//读写权限，2：Write,4：ReadOnly,6：ReadWrite,
                //地址请根据设备的配置进行填写
                MainAddress =  5,//主地址
                SubAddress = 0,//子地址
                SubIndex = 0,//DB块地址
                BitIndexEnabled = false,//是否启用按位索引
                IntegralDigits = 0,//整数位（目前无作用）
                FractionalDigits = 1,//小数位
                Unit = "度",//单位，仅对字类型有效
                TrafficSaving = false,//是否启用省流量模式，true:启用，false：不启用
                BitStateLabel = new BitStateLabel(){
    
    FalseLabel = "关机",TrueLabel = "开机"},//位类型时显示标签，属性ttext:值为1时显示的文本，ftext：值为0时显示的文本
                Memo = "xxx",//备注
                DeadValue = 0,//死区值，数据再±deadValue范围内数据不推送
                //只有在DataType = DataType.String（字符串类型） 时有以下参数
                //Encoding = EncodeType.None,//编码格式，字符串类型使用0：无，非字符串类型使用，1：Unicode,2:Ascii
                //StringByteOrder = StringByteOrder.O12,//字符串字节序，编码为Ascii格式时有效0：倒序，1：正序
                //CharCount = 5, //字符个数
            }
        },
        BoxNo = boxNo,//盒子号
    }).Wait();
}
//在Program，Main函数中调用
class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                fbox.Start();  //启动
                fbox.StartAllDMonData();//开启FBox所有监控点
                fbox.AddDMon();//调用此方法
            }
        }
    }

Atualizar entrada de ponto de controle

Depois que o ponto de monitoramento é adicionado, você precisa se conectar ao SignalR e habilitar o envio de dados do ponto de monitoramento.

/// <summary>
/// 更新监控点条目
/// </summary>
public void UpdateDmon()
{
    
    
    _fbox.UpdateDataMonitorPointV2(new UpdateDmonArgsV2()
    {
    
    
        BoxNo = boxNo,//盒子号
        UpdateDmonList = new List<UpdateDataMonitorDefinitionV2>()
        {
    
    
            new UpdateDataMonitorDefinitionV2()
            {
    
    
                Id = 113470726140747285,//需要更新条目的Id
                GroupName = "fff",//监控点分组名称，和groupId任选一个使用，若使用不存在的监控点分组，则会自动增加该分组
                Name = "ggg",//监控点名称
                DevAlias = "Local",//PLC别名
                StationNo = 1,//站号
                DataType = DataType.Int16,//数据类型，详情见接口文档中附录二
                RegName = "LW",//寄存器名称，和regId、iowidth确定唯一寄存器
                //地址请根据设备的配置进行填写
                MainAddress = 9,//主地址
                SubAddress = 0,//子地址
                SubIndex = 0,//DB块地址
                IntegralDigits = 0,//整数位（目前无作用）
                FractionalDigits = 1,//小数位
                Unit = "度",//单位
                Privilege = PrivilegeType.ReadOnly,//读写权限，2：Write,4：ReadOnly,6：ReadWrite,
                TrafficSaving = true,//是否启用省流量模式，true:启用，false：不启用
                DeadValue = 15,//死区值，数据再±deadValue范围内数据不推送
                BitStateLabel =  new BitStateLabel(),//位类型时显示标签，属性ttext:值为1时显示的文本，ftext：值为0时显示的文本
                Memo = "ggg",//备注
                Encoding = EncodeType.None//编码格式，字符串类型使用0：无，非字符串类型使用，1：Unicode,2:Ascii
            }
        }
    }).Wait();
}
//在Program，Main函数中调用
class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                fbox.Start();  //启动
                fbox.StartAllDMonData();//开启FBox所有监控点
                fbox.UpdateDmon();//调用此方法
            }
        }
    }
删除监控点条目
/// <summary>
/// 删除监控点条目
/// </summary>
public void RemoveDmon()
{
    
    
    List<long> ids = new List<long> {
    
     113470815205744205 };
    _fbox.RemoveDataMonitorPointV2(new RemoveDataMonDefArgsV2()
    {
    
    
        BoxNo = boxNo, //盒子号
        Ids = ids      //需要删除的监控点条目Id集合
    }).Wait();
}
//在Program，Main函数中调用
class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                fbox.Start();  //启动
                fbox.StartAllDMonData();//开启FBox所有监控点
                fbox.RemoveDmon();//调用此方法
            }
        }
    }

11. Operação de alarme

Obter todas as entradas de alarme sob a caixa

/// <summary>
/// 获取盒子底下所有的报警条目
/// </summary>
/// <returns></returns>
public IList<AlarmDefintitionDtoV2> GetAlarmItems()
{
    
    
    var allitems = _fbox.GetAllAlarmDefinitionsV2(new BoxArgs()
    {
    
    
        BoxNo = boxNo
    }).Result;
    foreach (var items in allitems)
    {
    
    
        Console.WriteLine(items.TaskState);    //条目状态
        Console.WriteLine(items.AlarmGroup);   //报警分组
        Console.WriteLine(items.AlarmMessage); //报警信息
        Console.WriteLine(items.Code);         //报警条目编码
        Console.WriteLine(items.Condition1);   //报警条件一
        Console.WriteLine(items.ConditionCombineMethod);//条件组合
        Console.WriteLine(items.Id);            //报警条目Id
        Console.WriteLine(items.IsDeviceChanged);//设备是否已经变更
        Console.WriteLine(items.Memo);          //备注
        Console.WriteLine(items.Name);          //报警条目名称
        Console.WriteLine(items.Operand1);      操作数，若选择Bit数据类型，操作数0为OFF，1为ON
        Console.WriteLine(items.Condition2);    //报警条件二
        Console.WriteLine(items.Operand2);      //操作数二
    }
    return allitems;
}
//在Program，Main函数中调用
class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                fbox.Start();  //启动
                fbox.StartAllDMonData();//开启FBox所有监控点
                fbox.GetAlarmItems();//调用此方法
            }
        }
    }

Obter entradas do histórico de alarmes

/// <summary>
/// 获取报警历史记录
/// </summary>
public void GetAlarmHistory()
{
    
    
    var hdata = _fbox.GetAlarmEvents(new AlarmEventQuery()
    {
    
    
        BeginTime = DateTime.Parse("2018-4-5"), //开始时间 long型的utc时间戳unix epoch
        BoxNo = boxNo,                          //盒子号
        EndTime = DateTime.Parse("2018-4-24"),  //结束时间 long型的utc时间戳unix epoch
        Limit = 500,                            //获取条数限制，结果条数限制 负值为向前查询，建议使用500.
        Name = "313265"                         //报警条目的编码，若全查则无需该参数
    }).Result;
    foreach (var data in hdata)
    {
    
    
        Console.WriteLine(data.Action);         //类型
        Console.WriteLine(data.AlarmId);        //报警条目Id
        Console.WriteLine(data.Code);           //报警条目编码
        Console.WriteLine(data.Message);        //报警信息
        Console.WriteLine(data.Value);          //监控点值
        Console.WriteLine(data.TimestampUnixEpoch); //时间戳
    }
}
//在Program，Main函数中调用
class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                fbox.Start();  //启动
                fbox.StartAllDMonData();//开启FBox所有监控点
                fbox.GetAlarmHistory();//调用此方法
            }
        }
    }

Adicionar entrada de alarme

/// <summary>
/// 新增报警条目
/// </summary>
public void AddAlarm()
{
    
    
    _fbox.AddAlarmDefinitionV2(new AddAlarmDefArgsV2()
    {
    
    
        AddAlarms = new List<AddAlarmDefinitionV2>()
        {
    
    
            new AddAlarmDefinitionV2()
            {
    
    
                Name = "报警名称",        // 新增报警条目名称是唯一的，不可同名
                DevAlias = "Modbus_TCP", //设备驱动别名
                StationNo = 1,          //PLC通讯站号
                DataType = DataType.Bit, //数据类型，详情见接口文档中附录二
                RegName = "4X_bit",    //寄存器名称，和regId、iowidth确定唯一寄存器
                //地址请根据报警条目需要检测的监控点配置
                MainAddress = 8, //主地址
                SubAddress = 0,//子地址
                SubIndex = 0,//DB块地址
                AlarmMessage = "XXXX",  //报警信息
                GroupName = "报警分组", //报警点分组名称或使用GroupId报警分组Id，优先名称
                Memo = "",             //备注
                //以下为报警条件
                Condition1 = AlarmConditionType.Eq,//触发报警条件类型，报警条件一，0：不等于，1：等于，2：大于，3：大于等于，4：小于，5：小于等于
                Operand1 = 80,  //条件值
                ConditionCombineMethod = AlarmConditionCombineMethod.And, //条件联合，None：无，And：与，Or：或
                Condition2 = AlarmConditionType.Eq,//触发报警条件类型，报警条件一，0：不等于，1：等于，2：大于，3：大于等于，4：小于，5：小于等于
                Operand2 = 90 //条件值
            }
        },
        BoxNo = boxNo     //新增报警条目的盒子号
    }).Wait();
}
//在Program，Main函数中调用
class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                fbox.Start();  //启动
                fbox.StartAllDMonData();//开启FBox所有监控点
                fbox.AddAlarm();//调用此方法
            }
        }
    }

Atualizar entrada de alarme

/// <summary>
/// 更新报警条目
/// </summary>
public void UpdateAlarm()
{
    
    
    _fbox.UpdateAlarmDefinitionV2(new UpdateAlarmDefArgsV2()
    {
    
    
        BoxNo = boxNo,//报警条目的盒子号
        UpdateAlarms = new List<UpdateAlarmDefinitionV2>()
        {
    
    
            new UpdateAlarmDefinitionV2()
            {
    
    
                Id = 113522543645056649,//报警条目的Id
                Name = "修改了", //报警条目名称 
                DevAlias = "Modbus_TCP",//设备驱动别名
                StationNo = 1, //PLC通讯站号
                DataType = DataType.Int16,//数据类型，详情见接口文档中附录二
                RegName = "4X",//寄存器名称，和regId、iowidth确定唯一寄存器
                //地址请根据报警条目需要检测的监控点配置
                MainAddress = 2, //主地址
                SubAddress = 0,//子地址
                SubIndex = 0,//DB块地址
                GroupName = "报警分组",//报警分组名称，与groupId使用一个即可
                //以下为报警条件
                Condition1 = AlarmConditionType.Lt,//触发报警条件类型，报警条件一，0：不等于，1：等于，2：大于，3：大于等于，4：小于，5：小于等于
                Operand1 = 12,//条件值一，若选择Bit数据类型，操作数0为OFF，1为ON
                ConditionCombineMethod = AlarmConditionCombineMethod.And, //条件联合，None：无，And：与，Or：或
                Condition2 = AlarmConditionType.Eq,//触发报警条件类型，报警条件二，0：不等于，1：等于，2：大于，3：大于等于，4：小于，5：小于等于
                Operand2 = 90 //条件值二
            }
        }
    }).Wait();
}
//在Program，Main函数中调用
class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                fbox.Start();  //启动
                fbox.StartAllDMonData();//开启FBox所有监控点
                fbox.UpdateAlarm();//调用此方法
            }
        }
    }

excluir entrada de alarme

/// <summary>
/// 删除报警条目
/// </summary>
public void RemoveAlarm()
{
    
    
    var ids = new List<long>(){
    
     110424333146494353};
    _fbox.RemoveAlarmDefinitionV2(new RemoveAlarmDefArgsV2()
    {
    
    
        BoxNo = boxNo,      //盒子号
        Ids = ids           //删除的报警条目UId
    }).Wait();
}
//在Program，Main函数中调用
class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                fbox.Start();  //启动
                fbox.StartAllDMonData();//开启FBox所有监控点
                fbox.RemoveAlarm();//调用此方法
            }
        }
    }

12. Operações históricas

Obtenha dados históricos de vários canais

/// <summary>
/// 获取历史记录多通道数据
/// </summary>
public IList<ByRowHistoryDataRow> GetHdataHistory()
{
    
    
    var hdata =  _fbox.GetByRowHistoryData(new GetHistoryDataArgs()
    {
    
    
        BoxNo = boxNo,                                //盒子号
        StartTime = DateTime.Parse("2018-06-06 08:58:32"),       //起始时间
        EndTime = DateTime.Parse("2018-06-07 08:58:32"),        //结束时间
        Limit = 500,                                 //最大获取数据条数
        TimeRange = TimeRangeTypes.BeginOpenEndOpen, //区间类型,BeginCloseEndClose:全毕区间,BeginCloseEndOpen:左闭右开，BeginOpenEndClose:左开右闭，BeginOpenEndOpen:全开区间
        HdataItemName = "XX",                        //历史数据条目名称
        HdataChannelNames = new List<string>() {
    
     "11", "22"}//通道名称
    }).Result;
    foreach (var d in hdata.Rows)
    {
    
    
        Console.WriteLine(d.Time); // 历史数据条目的采集时间
        Console.WriteLine(d.Values[0]); // 对应通道名称集合中的第一个元素
        Console.WriteLine(d.Values[1]); // 对应通道名称集合中的第二个元素
    }
    return hdata.Rows;
}
//在Program，Main函数中调用
class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                fbox.Start();  //启动
                fbox.StartAllDMonData();//开启FBox所有监控点
                fbox.GetHdataHistory();//调用此方法
            }
        }
    }

Obter entradas do histórico

/// <summary>
/// 获取历史记录条目
/// </summary>
public void GetHdataList()
{
    
    
    var itemlist =  _fbox.GetHdataItems(new BoxArgs()
    {
    
    
        BoxNo = boxNo                                       //盒子号
    }).Result;
    foreach (var items in itemlist)
    {
    
    
        Console.WriteLine(items.BoxId);                     //盒子Id
        foreach (var channels in items.Channels)
        {
    
    
            Console.WriteLine(channels.Uid);                //通道Id
            Console.WriteLine(channels.HasSubAddress);      //寄存器是否有子地址
            Console.WriteLine(channels.HasSubIndex);        //寄存器是否有DB块地址
            Console.WriteLine(channels.DataType);           //数据类型，详情见接口文档中附录二
            Console.WriteLine(channels.MainAddress);        //主地址
            Console.WriteLine(channels.RegName);            //寄存器名称
            Console.WriteLine(channels.RegId);              //寄存器Id
            Console.WriteLine(channels.IoWidth);            //寄存器位宽
            Console.WriteLine(channels.StationNo);          //站号
            Console.WriteLine(channels.SubAddress);         //子地址
            Console.WriteLine(channels.DevAlias);           //PLC别名
            Console.WriteLine(channels.SubIndex);           //DB块地址
        }
        Console.WriteLine(items.Name);                      //名称
        Console.WriteLine(items.RecordingPeriod);           //采集周期
        Console.WriteLine(items.Uid);                       //主键
        Console.WriteLine(items.IsControl);                 //是否使用使能
    }
}
//在Program，Main函数中调用
class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                fbox.Start();  //启动
                fbox.StartAllDMonData();//开启FBox所有监控点
                fbox.GetHdataList();//调用此方法
            }
        }
    }

Adicionar entrada de histórico

/// <summary>
/// 新增历史记录多通道
/// </summary>
public void AddHdata()
{
    
    
    _fbox.AddHdataItems(new AddHdataItemArgs()
    {
    
    
        BoxNo = boxNo,                          //盒子号
        HdataItems = new List<AddHdataItemDto>()
        {
    
    
            //以下为增加一个通道为例，增加多个通道自行增加
                    new AddHdataChannelsDto()
                    {
    
    
                        ChannelName = "xxx",    //通道名称
                        AddressDescription = "LW",//地址描述
                        StationNo = 2,          //站号
                        DataType = DataType.Bcd16,//数据类型，详情见接口文档中附录二
                        DevAlias = "Modbus_TCP",  //PLC别名
                        RegName = "4X",        //寄存器名称，与regId，iowidth确认唯一寄存器
                        //请根据设备的配置填写
                        MainAddress = 5,        //主地址
                        SubAddress = 0,         //子地址
                        SubIndex = 0,           //DB块地址
                        BitIndex = 0,           //按位索引号
                        BitIndexEnabled = false,//是否启用按位索引 
                        FractionalDigits = 1,   //通道小数位
                    }
                },
                IsControl = true, //是否使能控制
                //当使能控制为true时，填写以下使能参数
                ControlOptions = new HDataControlOptionsV2()//使能参数
                {
    
    
                    ControlType = HControlType.OFF,//使能配置,0:OFF,1:ON
                    DataType = DataType.Bit,    //数据类型，详情见接口文档中附录二
                    DevAlias = "Modbus_TCP",    //PLC别名
                    StationNo = 2,              //站号
                    RegName = "4X_bit",         //寄存器名称，和regId、iowidth确定唯一寄存器
                    //请根据设备的配置填写
                    MainAddress = 2,            //主地址
                    SubAddress = 3,             //子地址
                    AddressDescription = "LW",  //地址描述
                    BitIndex = 2,               //按位索引号
                    BitIndexEnabled = false     //是否启用按位索引
                }
            }
        }
    }).Wait();
}
//在Program，Main函数中调用
class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                fbox.Start();  //启动
                fbox.StartAllDMonData();//开启FBox所有监控点
                fbox.AddHdata();//调用此方法
            }
        }
    }

Atualizar entrada do histórico

/// <summary>
/// 更新历史记录多通道
/// </summary>
public void UpdateHdata()
{
    
    
    _fbox.UpdateHdataItems(new UpdateHdataItemArgs()
    {
    
    
        BoxNo = boxNo,
        HdataItems = new List<UpdateHdataItemDto>()
        {
    
    
            //以下为更新一个通道为例
                    new UpdateHdataChannelsDto()
                    {
    
    
                        Uid = 97427676249298676, //通道Uid
                        ChannelName = "15",//通道名称
                        DevAlias = "ABB AC500_RTU",//PLC别名
                        StationNo = 2,//站号
                        DataType =   DataType.Int16,//数据类型，详情见接口文档中附录二
                        RegName = "4X",//寄存器名称，与regId，iowidth确认唯一寄存器
                        //请根据设备的配置进行填写
                        MainAddress = 7,//主地址
                        SubAddress = 0,//子地址
                        SubIndex = 0,//索引地址
                        Unit = "°",//单位
                        IntegralDigits = 0,//整数位
                        FractionalDigits = 2//小数位
                    }
                },
                IsControl = true,   //是否启用使能配置
                //当启用使能配置时，请配置使能参数
                ControlOptions = new HDataControlOptionsV2()//使能参数
                {
    
    
                    ControlType = HControlType.OFF,//使能状态,0:OFF,1:ON
                    DataType = DataType.Bit,  //数据类型，详情见接口文档中附录二
                    DevAlias = "ABB AC500_RTU",   //PLC别名
                    StationNo = 2,              //站号
                    RegName = "0X",             //寄存器名称与regId，iowidth确认唯一寄存器
                    //请根据设备的配置进行填写
                    MainAddress = 2,            //主地址
                    SubAddress = 0,             //子地址
                    AddressDescription = "ABB",  //地址描述
                    BitIndex = 0,               //按位索引号
                    BitIndexEnabled = false     //是否启用按位索引
                },
            }
        }
    });
}
//在Program，Main函数中调用
class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                fbox.Start();  //启动
                fbox.StartAllDMonData();//开启FBox所有监控点
                fbox.UpdateHdata();//调用此方法
            }
        }
    }
删除历史记录条目
/// <summary>
/// 删除历史记录条目
/// </summary>
public void RemoveHdata()
{
    
    
    _fbox.RemoveHdataItem(new RemoveHdataItemArgs()
    {
    
    
        BoxNo = boxNo,                                  //盒子号
        Ids = new List<long>() {
    
     85289974828733605 }    //历史记录Id集合
    }).Wait();
}
//在Program，Main函数中调用
class Program
    {
    
    
        static void Main(string[] args)
        {
    
    
            using (var fbox = new FBoxDemo())
            {
    
    
                fbox.Start();  //启动
                fbox.StartAllDMonData();//开启FBox所有监控点
                fbox.RemoveHdata();//调用此方法
            }
        }
    }

Resumir

O assunto acima é sobre o que falaremos hoje. Este artigo apresenta apenas brevemente o desenvolvimento de aplicativos do Visual Studio com base no FlexManager, e o FlexManager oferece várias maneiras de criar aplicativos clientes usando dados em nuvem. Os alunos podem aprender mais sobre eles. O próximo artigo descreverá os detalhes reais da operação de transferência de dados na nuvem com base no FlexManager.Os alunos são convidados a estudar mais.