ESP8266 WiFi物联网智能插座—上位机软件实现

最新推荐文章于 2024-05-18 09:52:01 发布

weixin_44079197

最新推荐文章于 2024-05-18 09:52:01 发布

阅读量693

点赞数 29

文章标签：物联网

本文链接：https://blog.csdn.net/weixin_44079197/article/details/137879241

版权

1、软件架构

上位机主要作为下位机数据上传服务端以及节点调试的控制端，可以等效认为是专属版本调试工具。针对智能插座协议，对于下位机进行可视化监测和管理。软件技术架构如下，主要为针对 Windows 的PC 端应用程序，采用WPF以及C# 实现功能开发，其中包含MVVM架构。

// 日志库-Log4net // 通信库-SuperSocket // WPF组件库-HandyControl // 插件库-G2Cy.Plugins.NETCore.WPF

添加图片注释，不超过 140 字(可选)

项目PCB、原理图和代码下载：https://download.csdn.net/download/m0_38106923/89089246

2、开发环境

主要在Windows10操作系统中，使用Visual Studio 2022 进行开发，项目源码结构如下：

添加图片注释，不超过 140 字(可选)

G2CyHome.Models : 包含UI部分通用的一些依赖类，例如工具，协议枚举、命令控制类等。
G2CyHome.Wpf : 包含主程序相关窗体和类。
G2CyHome.WpfOutlet : 主要包含插座UI组件相关类。

3、程序设计

上位机测试程序主要功能如下，其中主要包括：服务配置、节点数据以及节点控制。

添加图片注释，不超过 140 字(可选)

4、程序功能

4.1、服务配置

服务配置，主要在当前同局域网下，启动Socket 服务，对应端口和IP 与同局域网下位机形成通信，基础代码逻辑如下，包括UI、ViewModel以及服务。 1)UI部分

添加图片注释，不超过 140 字(可选)

主要代码如下：

```

<StackPanel Margin="12,18,18,0">
    <TextBlock Text="服务配置" LineHeight="33.6" FontSize="{DynamicResource TitleFontSize}" Foreground="{DynamicResource PrimaryTextBrush}"></TextBlock>
    <hc:ComboBox x:Name="cmbx_type" SelectedIndex="{Binding Proto,Mode=OneWay}" hc:TitleElement.Title="协议类型" Padding="{DynamicResource TextboxPadding}"  BorderThickness="1" Background="{DynamicResource BackgroundBrush}" BorderBrush="{DynamicResource BorderBrush}">
        <ComboBoxItem Content="TCP"></ComboBoxItem>
        <ComboBoxItem Content="UDP"></ComboBoxItem>
    </hc:ComboBox>
    <hc:ComboBox x:Name="cmbx_ip" SelectedIndex="0" hc:TitleElement.Title="IP地址" SelectedValue="{Binding IP,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}" Margin="0,10,0,0" Padding="{DynamicResource TextboxPadding}" BorderThickness="1" Background="{DynamicResource BackgroundBrush}" BorderBrush="{DynamicResource BorderBrush}">
    </hc:ComboBox>
    <TextBlock Text="默认选择localhost" FontSize="{DynamicResource MainFontSize}" Margin="0,7,0,0" Foreground="{DynamicResource SecondaryTextBrush}"></TextBlock>
    <UniformGrid Rows="1">
        <hc:TextBox x:Name="txt_port" hc:TitleElement.Title="监听端口" Text="{Binding Port,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}" Width="68.8" Margin="0,10,0,0" Padding="{DynamicResource TextboxPadding}" BorderThickness="1" Background="{DynamicResource BackgroundBrush}" BorderBrush="{DynamicResource BorderBrush}"></hc:TextBox>
        <ContentControl x:Name="socket_status" Content="停止" Foreground="{DynamicResource PrimaryTextBrush}"
                        hc:TitleElement.Title="服务状态" 
                        hc:TitleElement.TitlePlacement="Top" 
                        Width="Auto" Margin="10,10,0,0" HorizontalContentAlignment="Left" Padding="{DynamicResource TextboxPadding}" Template="{StaticResource ContentTopTemplate}">
        </ContentControl>
    </UniformGrid>
    <TextBlock Text="建议端口1000~65535间" FontSize="{DynamicResource MainFontSize}" Margin="0,7,0,0" Foreground="{DynamicResource SecondaryTextBrush}"></TextBlock>
    <UniformGrid Rows="1" Margin="0,12,0,0">
        <Button x:Name="btn_start" Click="btn_start_Click" Padding="{DynamicResource ButtonPadding}" hc:BackgroundSwitchElement.MouseHoverBackground="{DynamicResource InfoBrush}"  hc:BackgroundSwitchElement.MouseDownBackground="{DynamicResource InfoBrush}" HorizontalAlignment="Left" VerticalAlignment="Center" Style="{DynamicResource ButtonCustom}" hc:BorderElement.CornerRadius="{DynamicResource MainCornerRadius}" Content="开启" Background="{DynamicResource InfoBrush}"></Button>
        <Button x:Name="btn_stop" IsEnabled="False" Click="btn_stop_Click"  Padding="{DynamicResource ButtonPadding}" HorizontalAlignment="Right" VerticalAlignment="Center"   Style="{DynamicResource ButtonCustom}" hc:BorderElement.CornerRadius="4" Content="停止" BorderThickness="1" BorderBrush="{DynamicResource BorderBrush}" Background="{DynamicResource DarkPrimaryBrush}"></Button>
    </UniformGrid>
</StackPanel>

```

2)ViewModel部分，主要代码在ServerCfgVM中。

``` ///

/// 服务配置实体 ///

public class ServerCfgVM : VMBase { public ServerCfgVM() { Port = 6886; Proto = 0; SSIds = WiFiUtils.GetWiFiSSID().ToList(); SelectedMode = 0;// 默认为运行模式 ModeIsEnabled = true;// 默认为启用状态 ResetEnabled = true;// 默认为启用状态 }

private string iP;

// 协议格式
private int proto;

public int Proto
{
    get { return proto; }
    set { proto = value; RaisePropertyChanged(); }
}

// IP地址
public string IP { 
    get {
        return iP;
    } set { iP = value; RaisePropertyChanged(); } }
// 端口号
private int port;
private List<string> sSIds;

public int Port
{
    get {
        return port;
    }
    set { port = value; RaisePropertyChanged(); }
}

/// <summary>
/// WIFI列表
/// </summary>
public List<string> SSIds { get => sSIds; set { sSIds = value; RaisePropertyChanged(); } }

private string ssid;
/// <summary>
/// 选中ssid
/// </summary>
public string Ssid
{
    get { return ssid; }
    set { ssid = value;  RaisePropertyChanged(); }
}

/// <summary>
/// 选中模式
/// </summary>
private int selectedMode;
/// <summary>
/// 选中模式
/// </summary>
public int SelectedMode
{
    get { return selectedMode; }
    set { selectedMode = value;  RaisePropertyChanged(); }
}

private bool modeIsEnabled;
/// <summary>
/// 是否启用模式切换
/// </summary>
public bool ModeIsEnabled
{
    get { return modeIsEnabled; }
    set { modeIsEnabled = value;RaisePropertyChanged(); }
}

private bool configEnabled;
/// <summary>
/// 是否启用配置下发
/// </summary>
public bool ConfigEnabled
{
    get { return configEnabled; }
    set { configEnabled = value; RaisePropertyChanged(); }
}

private bool resetEnabled;
/// <summary>
/// 是否启用配置重置
/// </summary>
public bool ResetEnabled
{
    get { return resetEnabled; }
    set { resetEnabled = value; RaisePropertyChanged(); }
}

} ```

3)服务部分

服务主要为Socket服务端，配置项用于对服务进行监听和关闭服务管理。

``` try { SuperSocketHostBuilder socketHostBuilder = CreateSocketServerBuilder (); // socket服务配置 socketHostBuilder.ConfigureSuperSocket(config => { config.ClearIdleSessionInterval = 60; config.DefaultTextEncoding = Encoding.UTF8; config.IdleSessionTimeOut = 150; config.Name = "deviceserver"; }); server = socketHostBuilder .UsePackageDecoder () .UsePackageHandler(async (s, p) => { // 更新页面数据 IServiceProvider serviceProvider = Program.DefaultHost.Services; var Vm = serviceProvider.GetRequiredService ();

try
        {
            DeviceVm deviceSession = Vm.AppSessions.FirstOrDefault(x => x.SessionID == s.SessionID);
            if (deviceSession != null)
            {
                // 判定设备类型
                switch (p.NodeType)
                {
                    // 智能插座
                    case DeviceNodeType.Outlet:
                        // 执行插座处理逻辑
                        break;
                    case DeviceNodeType.None:
                    default:
                        break;
                }
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex.Message, ex);
        }
    })
    .UseSession<AppSession>()
    .UseClearIdleSession()
    .UseHostedService<CustomSocketService>()
    .UseInProcSessionContainer()
    .BuildAsServer();

await server.StartAsync();
UpdateEnabled(true);

} catch (Exception ex) { _logger.LogError(ex.Message, ex); } ```

4.2、节点数据

在保证数据服务监听已经启动的情况下，采集来自目标选中节点的传输数据。 1)节点协议解析数据字节包解析类RequestModelPipelineFilter:

``` public class RequestModelPipelineFilter : FixedHeaderPipelineFilter { ///

/// 是否发现头部 ///

private bool _foundHeader; ///

/// 头部长度 ///

private readonly int _headerSize; ///

/// 目标数据包总长度 ///

private int _totalSize; ///

/// 校验长度 ///

private int _verifySize; // 设置对应从接收缓冲区中获取的头部字节长度 public RequestModelPipelineFilter() : base(3) { _verifySize = 1; _headerSize = 3; } ///

/// 从Header头部获取内容长度 ///

/// 数据字节包 /// 内容长度 protected override int GetBodyLengthFromHeader(ref ReadOnlySequence buffer) { var reader = new SequenceReader (buffer); reader.Advance(buffer.Length - 1); //reader.TryRead(out byte length); byte[] bytes = reader.Sequence.Slice(1, 2).ToArray(); //Array.Reverse(bytes); int length = BitConverter.ToInt16(bytes, 0); return length; }

/// <summary>
/// 过滤执行函数
/// </summary>
/// <param name="reader">数据字节包</param>
/// <returns>数据包实例</returns>
public override RequestModel Filter(ref SequenceReader<byte> reader)
{
    if (!_foundHeader)
    {
        if (reader.Length < _headerSize)
        {
            return null;
        }

        ReadOnlySequence<byte> buffer = reader.Sequence.Slice(0, _headerSize);
        int bodyLengthFromHeader = GetBodyLengthFromHeader(ref buffer);
        if (bodyLengthFromHeader < 0)
        {
            throw new ProtocolException("Failed to get body length from the package header.");
        }

        if (bodyLengthFromHeader == 0)
        {
            try
            {
                return DecodePackage(ref buffer);
            }
            finally
            {
                reader.Advance(_headerSize);
                // 重置是否找到头部
                _foundHeader = false;
            }
        }

        _foundHeader = true;
        // 总长度
        _totalSize = bodyLengthFromHeader;
    }

    int totalSize = _totalSize;
    // 判定当前实际数据包长度是否小于目标数据包总长度
    if (reader.Length < totalSize)
    {
        return null;
    }

    ReadOnlySequence<byte> buffer2 = reader.Sequence.Slice(0, totalSize);
    try
    {
        return DecodePackage(ref buffer2);
    }
    finally
    {
        reader.Advance(totalSize);
        // 重置是否找到头部
        _foundHeader = false;
    }
}

} ```

数据接收类RequestModel:

``` public class RequestModel { public byte[] Data { get; set; }=new byte[0]; ///

/// 设备节点类型 ///

public DeviceNodeType NodeType { get; set; } ///

/// 功能码 ///

public FeatureType FeatureType { get; set; } public Msg Type MsgType { get; set; }

public byte[] GetBytes(Encoding encoding)
{
    return this.ToJson().ToBytes(encoding);
}

/// <summary>
/// 构建包数据
/// </summary>
/// <param name="buffer">原始字节组</param>
public static RequestModel CreatedModel(ReadOnlySequence<byte> buffer)
{
    RequestModel requestModel = new RequestModel();
    // 填充数据
    var reader = new SequenceReader<byte>(buffer);
    // 获取产品类型
    reader.TryRead(out byte devicetype);
    // 高位(设备类型) 
    byte heigth = (byte)(devicetype & 0xf0);
    requestModel.NodeType = (DeviceNodeType)Enum.ToObject(typeof(DeviceNodeType), heig
    // 低位(功能码)
    byte lower = (byte)(devicetype & 0x0f);
    requestModel.FeatureType = (FeatureType)Enum.ToObject(typeof(FeatureType), lower);
    int lentype = (int)buffer.Length-3;//包含校验位-crc校验(2)
    // 跳过总长度(2)
    reader.Advance(2);
    try
    {
        //string datastr = reader.ReadString(Encoding.UTF8, lentype);
        byte[] datas = reader.Sequence.Slice(reader.Position,lentype).ToArray();
        requestModel.Data = datas;
    }
    catch (System.Text.Json.JsonException ex)
    {
        // 异常处理
        return new RequestModel();
    }
    return requestModel;
}

public static bool VerifyCRC(ReadOnlySequence<byte> buffer)
{
    byte[] nobytes = buffer.Slice(0,buffer.Length-2).ToArray();
    byte[] flagbytes = buffer.Slice(buffer.Length-2).ToArray();
    byte[] crcs = CRCUtils.Crc18(nobytes, 0, nobytes.Length);
    for (int i = 0; i < 2; i++)
    {
        if (flagbytes[i] != crcs[i])
        {
            return false;
        }
    }
    return true;
}

}

public enum Msg_Type { // 节点数据上报 Upload, // 控制回发 Call } ```

2)UI展示部分

添加图片注释，不超过 140 字(可选)

设备列表：

添加图片注释，不超过 140 字(可选)

主要代码：

内容部分：

添加图片注释，不超过 140 字(可选)

主要代码：

4.3、节点控制

1)协议下发涉及到的下发协议主要包含：控制继电器开关、节点配置、模式切换、控制状态回发。主要通过数据包协议类型FeatureType进行区分判定：

/// <summary> /// 功能类型 /// </summary> public enum FeatureType:byte { /// <summary> /// 0x01 设备数据上传功能码 /// </summary> [Description("数据上传")] Upload = 0x01, /// <summary> /// 0x02 下发响应功能码 /// </summary> [Description("下发响应")] Callback = 0x02, /// <summary> /// 0x05 节点控制功能码 /// </summary> [Description("节点控制")] Push = 0x05, /// <summary> /// 0x04 节点配置功能码 /// </summary> [Description("节点配置")] Config= 0x04, /// <summary> /// 0x03 模式切换功能码 /// </summary> [Description("模式切换")] ModeCfg = 0x03, /// <summary> /// 0x06 升级响应功能码 /// </summary> [Description("升级响应")] UpdateAck = 0x06, }

功能类型通过不同类型接口进行下发指令区分：

例如控制回发类接口，实现IDeviceCallback

``` ///

/// 设备响应回发接口 ///

public interface IDeviceCallback { ///

/// 客户端IP ///

[JsonPropertyName("clientip")] public string ClientIP { get; set; } ///

/// 设备标识 ///

[JsonPropertyName("device id")] public int DeviceId { get; set; } ///

/// 软件版本号 ///

[JsonPropertyName("software version")] public string SoftwareVersion { get; set; } ///

/// 硬件版本号 ///

[JsonPropertyName("hardware version")] public string HardwareVersion { get; set; } ///

/// 状态码：0 响应成功，1 响应失败 ///

public bool State_Code { get; set; } // 字节转对象 T BytesToObject(byte[] bytes); }

```

设备回发基类：

// 设备回发基类 public class DeviceCallback : VMBase, IDeviceCallback<DeviceCallback> { public virtual DeviceCallback BytesToObject(byte[] bytes) { return null; } }

插座控制回发类实现内容如下：

/// <summary> /// 智能插座响应类 /// </summary> public class OutletCallback:DeviceCallback { public override DeviceCallback BytesToObject(byte[] bytes) { SequenceReader<byte> read = new SequenceReader<byte>(new ReadOnlySequence<byte>(bytes)); // 设备id byte[] deviceid = new byte[2]; read.TryCopyTo(deviceid); read.Advance(deviceid.Length); Device_Id = BitConverter.ToUInt16(deviceid); // 软件版本 byte[] software = new byte[15]; read.TryCopyTo(software); read.Advance(software.Length); Software_Version = software.GetStrFromBytes(15); // 硬件版本 byte[] hardware = new byte[15]; read.TryCopyTo(hardware); Hardware_Version = hardware.GetStrFromBytes(15); read.Advance(hardware.Length); // 状态码 read.TryRead(out byte state); // 高位(回发功能码) 高位转低位 byte heigth = (byte)((state & 0xf0)>>4); FeatureCallType = (FeatureType)Enum.ToObject(typeof(FeatureType), heigth); // 低位(状态码) byte lower = (byte)(state & 0x0f); State_Code = lower == 0x00; return this; } }

2)UI展示部分

添加图片注释，不超过 140 字(可选)

主要代码：

5、程序功能特点

程序目前设计采用插件方式加载，数据协议提供数据调试和程序本地日志查看。

添加图片注释，不超过 140 字(可选)

本地日志封装如下：

``` ///

/// log4net日志记录 ///

public class Log4NetLogger : ILogger { private readonly ILog _log;

/// <summary>
/// 初始化一个<see cref="Log4NetLogger"/>类型的新实例
/// </summary>
public Log4NetLogger(string loggerRepository, string name)
{
    _log = LogManager.GetLogger(loggerRepository, name);
}

/// <summary>Writes a log entry.</summary>
/// <param name="logLevel">日志级别，将按这个级别写不同的日志</param>
/// <param name="eventId">事件编号.</param>
/// <param name="state">The entry to be written. Can be also an object.</param>
/// <param name="exception">The exception related to this entry.</param>
/// <param name="formatter">Function to create a <c>string</c> message of the <paramref name="state" /> and <paramref name="exception" />.</param>
public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
{
    if (!IsEnabled(logLevel))
    {
        return;
    }
    string message = null;
    if (formatter != null)
    {
        message = formatter(state, exception);
    }

    if (!string.IsNullOrEmpty(message) || exception != null)
    {
        switch (logLevel)
        {
            case LogLevel.Trace:
            case LogLevel.Debug:
                _log.Debug(message);
                break;
            case LogLevel.Information:
                _log.Info(message);
                break;
            case LogLevel.Warning:
                _log.Warn(message);
                break;
            case LogLevel.Error:
                _log.Error(message, exception);
                break;
            case LogLevel.Critical:
                _log.Fatal(message, exception);
                break;
            case LogLevel.None:
                break;
            default:
                _log.Warn($"遇到未知的日志级别 {logLevel}, 使用Info级别写入日志。");
                _log.Info(message, exception);
                break;
        }
    }
}

/// <summary>
/// Checks if the given <paramref name="logLevel" /> is enabled.
/// </summary>
/// <param name="logLevel">level to be checked.</param>
/// <returns><c>true</c> if enabled.</returns>
public bool IsEnabled(LogLevel logLevel)
{
    switch (logLevel)
    {
        case LogLevel.Trace:
        case LogLevel.Debug:
            return _log.IsDebugEnabled;
        case LogLevel.Information:
            return _log.IsInfoEnabled;
        case LogLevel.Warning:
            return _log.IsWarnEnabled;
        case LogLevel.Error:
            return _log.IsErrorEnabled;
        case LogLevel.Critical:
            return _log.IsFatalEnabled;
        case LogLevel.None:
            return false;
        default:
            throw new ArgumentOutOfRangeException(nameof(logLevel), logLevel, null);
    }
}

/// <summary>Begins a logical operation scope.</summary>
/// <param name="state">The identifier for the scope.</param>
/// <returns>An IDisposable that ends the logical operation scope on dispose.</returns>
public IDisposable BeginScope<TState>(TState state)
{
    return null;
}

```

项目PCB、原理图和代码下载：https://download.csdn.net/download/m0_38106923/89089246

weixin_44079197

关注

29
点赞
踩
21

收藏

觉得还不错? 一键收藏
打赏
0
评论
ESP8266 WiFi物联网智能插座—上位机软件实现

1、软件架构上位机主要作为下位机数据上传服务端以及节点调试的控制端，可以等效认为是专属版本调试工具。针对智能插座协议，对于下位机进行可视化监测和管理。软件技术架构如下，主要为针对 Windows 的PC 端应用程序，采用WPF以及C# 实现功能开发，其中包含MVVM架构。// 日志库-Log4net// 通信库-SuperSocket// WPF组件库-HandyControl/...
复制链接

扫一扫