ATLS PF4000 串口通信协议

已于 2024-04-25 11:39:41 修改
阅读量213 收藏
点赞数 1
文章标签： c#
于 2024-04-25 11:34:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fanwenhu/article/details/138184078
版权

基于开放协议,

1.发送前缀+开放协议+结束尾缀,

前缀与尾缀不计算长度

以连接控制器为例:

前缀:0x07, 0x09, 0x07, 0x09, 0x02

数据长度:0020       (ASCII转Byte[])

内容:0001001         (长度16,  9个空格 ,ASCII转Byte[])

尾缀:0x00, 0x03

连接控制器

发送(十进制程序监控复制导出,自行转换16进制核对)

7,9,7,9,2,48,48,50,48,48,48,48,49,48,48,49,32,32,32,32,32,32,32,32,32,0,3

2.接收数据 

前缀+内容+尾缀

前缀: 0x02

内容:与开发协议接收保持一致

尾缀:0x00 0x03

开放协议参考以前写过的博客,自行翻阅.

通信类库:

using BascInfo;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO.Ports;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;

namespace Tor
{
    public class Serial_Tor
    {
        private SerialPort SerialPort_sc;
        private string ScName = "";
        private const int BufferSize = 256;
        private byte[] _readBuffer;
        private AsyncCallback _readCallback;
        MsgTips mt;
        /// <summary>
        /// 打开串口 串口序号简写Com1→1 , 波特率,数据位,停止位,校验位
        /// </summary>
        public bool OpenPort(string name, int portNum, int rate, int dataBits, int stopBits, int parity, MsgTips _mt)
        {
            mt=_mt;
            if (SerialPort_sc != null)
            {
                SerialPort_sc.Close();
            }
            ScName=name;
            SerialPort_sc = new SerialPort();
            SerialPort_sc.PortName = "COM" + portNum.ToString();
            SerialPort_sc.BaudRate = rate;
            SerialPort_sc.DataBits = dataBits;
            SerialPort_sc.StopBits = stopBits == 0 ? StopBits.None : (stopBits == 1 ? StopBits.One : StopBits.Two);
            SerialPort_sc.Parity = parity == 0 ? Parity.None : (parity == 1 ? Parity.Odd : Parity.Even);

            try
            {
                _readBuffer = new byte[BufferSize];
                _readCallback = new AsyncCallback(OnReadComplete);
                SerialPort_sc.Open();
                SendCmdInfo(Commd.Connect);
                BeginAsyncRead();
                Task.Run(() => { SendQueMsg(); });
                Task.Run(() => { SendDate(); });
                return true;
            }
            catch (Exception ex)
            {
                mt.Show($"NG,拧紧串口{SerialPort_sc.PortName}打开异常,"+ex.Message, true);
                return false;
            }
        }
        private void BeginAsyncRead()
        {
            if (SerialPort_sc.IsOpen)
            {
                SerialPort_sc.BaseStream.BeginRead(_readBuffer, 0, BufferSize, _readCallback, null);
            }
        }

        private void OnReadComplete(IAsyncResult ar)
        {
            try
            {
                int bytesRead = SerialPort_sc.BaseStream.EndRead(ar);
                if (bytesRead > 0)
                {
                    byte[] receivedData = new byte[bytesRead];
                    Array.Copy(_readBuffer, 0, receivedData, 0, bytesRead);
                    ChaiJie(receivedData);
                    BeginAsyncRead(); // 继续异步读取
                }
            }
            catch (Exception ex)
            {
                mt.Show($"NG,拧紧串口{SerialPort_sc.PortName}打开异常,"+ex.Message, true);
            }
        }

        List<byte> _queuedMsg = new List<byte>();
        private byte Delimiter = 0x00;
        private void ChaiJie(byte[] bt)
        {
            int tj = bt.Count();
            for (int i = 0; i < tj; i++)
            {
                if (bt[i]==Delimiter)
                {
                    byte[] msg = _queuedMsg.ToArray();
                    string Rcmsg = Encoding.ASCII.GetString(msg.ToArray());
                    _queuedMsg.Clear();
                    FenXi(Rcmsg);
                }
                else
                {
                    if (bt[i]!=0x02 && bt[i]!=0x03)
                    {
                        _queuedMsg.Add(bt[i]);
                    }
                }
            }
        }
        private void FenXi(string Rcmsg)
        {
            if (Rcmsg.Length < 20)
            {
                return;
            }
            isSendCmd=false;
            mt.Show($"Tor:接收信息:{Rcmsg}__{isKepCon},{isUnableDY},{isSendCmd}", false);
            string jieguo = Rcmsg.Substring(4, 4);
            switch (jieguo)
            {
                case "0002"://首次握手成功
                    isKepCon=true;
                    num_ConOverTime=0;
                    break;
                case "0061":
                    num_ConOverTime=0;
                    SendCmdInfo(Commd.AckNowledgeTorResult);
                    //拧紧数据解析
                    JX(Rcmsg);
                    break;
                case "9999":
                    num_ConOverTime=0;
                    break;
                case "0004":
                    string cmd2 = Rcmsg.Substring(24, 2); //二次通信
                    if (cmd2 =="96")
                    {
                        isKepCon=true;
                        num_ConOverTime=0;
                        isUnableDY=true;
                    }
                    break;
                case "0005":
                    string cmd3 = Rcmsg.Substring(20, 4);
                    if (cmd3 =="0060")
                    {
                        num_ConOverTime=0;
                        isUnableDY=true;
                    }
                    break;
                default:
                    break;
            }

        }


        private void JX(string msg)
        {
            if (msg.Length == 231)
            {
                //版本1 001或者3个空格
                //string rev = msg.Substring(8, 3);
                //string Vin = msg.Substring(59, 25);
                bool rel = msg.Substring(107, 1) == "1" ? true : false;
                string nj = msg.Substring(140, 6);
                string jd = msg.Substring(169, 5);
                //string id = msg.Substring(221, 10).Trim();
                float f_nj = (float.Parse(nj) * 1.0f / 100.0f);
                float f_jd = (float.Parse(jd) * 1.0f / 100.0f);

                ScEventArgs e = new ScEventArgs(ScName, f_nj, f_jd, rel);
                _MsgChange(e);
            }
        }

        bool isRun = true;
        public void Close()
        {
            isRun=false;
            SerialPort_sc?.Close();
        }
        /// <summary>
        /// 允许执行保持通信
        /// </summary>
        bool isKepCon = false;
        /// <summary>
        /// 不允许订阅
        /// </summary>
        bool isUnableDY = false;
        /// <summary>
        /// 是否发送了指令
        /// </summary>
        bool isSendCmd = false;

        int num_ConOverTime = 0;
        public void SendDate()
        {
            int js = 0;
            while (isRun)
            {
                if (!isKepCon)
                {
                    SendCmdInfo(Commd.Connect);
                }
                if (isKepCon && !isUnableDY && !isSendCmd)
                {
                    SendCmdInfo(Commd.SubscribeTorResult);
                    isSendCmd = true;
                }
                if (isKepCon && !isSendCmd &js>=50)
                {
                    //无指令交互情况下10秒发送一次保持通信
                    SendCmdInfo(Commd.KeepCon);
                    js=0;
                    isSendCmd=true;
                }
                js++;
                num_ConOverTime++;
                //应答超时
                if (num_ConOverTime>=100)
                {
                    isKepCon=false;
                    isUnableDY=false;
                }
                Thread.Sleep(200);
            }
        }
        private ConcurrentQueue<byte[]> sendQue = new ConcurrentQueue<byte[]>();
        public void SendCmdInfo(Commd Canshu, string msg = "")
        {
            switch (Canshu)
            {
                case Commd.LockGun:
                    msg = "0042001".PadRight(16, ' ');
                    break;
                case Commd.UnLockGun:
                    msg = "0043001".PadRight(16, ' ');
                    break;
                case Commd.Connect:
                    msg = "0001001".PadRight(16, ' ');
                    break;
                case Commd.KeepCon:
                    msg = "9999001".PadRight(16, ' ');
                    break;
                case Commd.DisConnect:
                    msg = "0003001".PadRight(16, ' ');
                    break;
                case Commd.SubscribeTorResult:
                    msg = "0060001".PadRight(16, ' ');
                    break;
                case Commd.AckNowledgeTorResult:
                    msg = "0062001".PadRight(16, ' ');
                    break;
                //case Commd.UnSubscribeTorResult:
                //    msg = "0063001".PadRight(16, ' ');
                //    break;
                case Commd.Pre:
                    msg = "0064001".PadRight(16, ' ') + msg.PadLeft(10, ' ');
                    break;
                case Commd.Vin:
                    msg = "0050001".PadRight(16, ' ') + msg;
                    break;
                case Commd.Channel:
                    msg = "0018001".PadRight(16, ' ') + msg.PadLeft(3, '0');
                    break;
                case Commd.Job:
                    msg = "002200380010    00  "+ msg;
                    break;

                default:
                    break;
            }
            byte[] t_head = new byte[] { 0x07, 0x09, 0x07, 0x09, 0x02 };
            byte[] t_end = new byte[] { 0x00, 0x03 };

            byte[] bt_Data = Encoding.ASCII.GetBytes(msg);
            byte[] bt_head = Encoding.ASCII.GetBytes((bt_Data.Length + 4).ToString("0000"));

            byte[] bt_send = t_head.Concat(bt_head).Concat(bt_Data).Concat(t_end).ToArray();

            sendQue.Enqueue(bt_send);

        }
        string pattern = @"[^a-zA-Z0-9]+"; // 匹配一个或多个非字母数字字符
        private void SendQueMsg()
        {
            byte[] buf = new byte[0];

            while (isRun)
            {
                while (sendQue.TryDequeue(out buf))
                {
                    mt.Show($"发送:{Regex.Replace(Encoding.ASCII.GetString(buf), pattern, "")}", false);
                    SerialPort_sc?.Write(buf, 0, buf.Length);
                }
                Thread.Sleep(200);
            }
        }






        public delegate void MsgChange(object sender, ScEventArgs args);
        public event MsgChange OnMsgChange;
        protected virtual void _MsgChange(ScEventArgs e)
        {
            if (OnMsgChange != null)
            {
                OnMsgChange(this, e);
            }
        }
    }

    public class ScEventArgs : EventArgs
    {
        public string Name;
        public float NJ;
        public float JD;
        public bool Result;
        public ScEventArgs(string name, float nj, float jd, bool result)
        {
            Name=name;
            NJ = nj;
            JD = jd;
            Result=result;
        }
    }

    public enum Commd
    {
        /// <summary>
        /// 连接  0001
        /// </summary>
        Connect,
        /// <summary>
        /// 断开  0003
        /// </summary>
        DisConnect,
        /// <summary>
        /// 锁枪  0042
        /// </summary>
        LockGun,
        /// <summary>
        /// 解枪  0043
        /// </summary>
        UnLockGun,
        /// <summary>
        /// 订阅拧紧数据  0060001
        /// </summary>
        SubscribeTorResult,
        /// <summary>
        /// 订阅信息收到回传  0062
        /// </summary>
        AckNowledgeTorResult,
        /// <summary>
        /// 取消订阅拧紧数据  0063
        /// </summary>
        UnSubscribeTorResult,
        /// <summary>
        /// 读取历史  0064
        /// </summary>
        Pre,
        /// <summary>
        /// 保持通信 9999
        /// </summary>
        KeepCon,
        /// <summary>
        /// 写入Vin 0050
        /// </summary>
        Vin,
        /// <summary>
        /// 写入通道 0018
        /// </summary>
        Channel,
        /// <summary>
        /// Job 请求
        /// </summary>
        Job
    }
}

fanwenhu
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
基于STM32的儿童误锁车内远程报警系统(华为云IOT)
08-01 2236
本文设计了一种基于STM32的儿童误锁车内远程报警系统，本设计分为车辆状态检测模块、车内情况采集模块以及执行模块三大模块。其中包括电源模块、GPS模块、加速度传感器、霍尔接近开关、人体检测模块、温度传感器、二氧化碳传感器、振动传感器、摄像头、蜂鸣器、车窗升降控制电路、以及 GPRS通讯模块。
golang简单tls协议用法完整示例
09-21
主要介绍了golang简单tls用法,分析了tls协议的使用步骤及客户端与服务器端的相关实现代码,需要的朋友可以参考下
联网常见通信协议与通讯协议梳理- 通讯协议
LJH_Gemini的博客
01-18 4882
1  “通信”与“通讯”傻傻分得清 传统意义上的“通讯”主要指电话、电报、电传。通讯的“讯”指消息（Message）,媒体讯息通过通讯网络从一端传递到另外一端。媒体讯息的内容主要是话音、文字、图片和视频图像。其网络的构成主要由电子设备系统和无线电系统构成，传输和处理的信号是模拟的。所以，“通讯”一词应特指采用电报、电话、网络等媒体传输系统实现上述媒体信息传输的过程。“通讯”重在内容形式，因此...
IOT(34 )---联网常见通信协议与通讯协议梳理- 通讯协议
zhangbijun1230的专栏
05-22 1万+
联网常见通信协议与通讯协议梳理【上】- 通讯协议1  “通信”与“通讯”傻傻分得清传统意义上的“通讯”主要指电话、电报、电传。通讯的“讯”指消息（Message）,媒体讯息通过通讯网络从一端传递到另外一端。媒体讯息的内容主要是话音、文字、图片和视频图像。其网络的构成主要由电子设备系统和无线电系统构成，传输和处理的信号是模拟的。所以，“通讯”一词应特指采用电报、电话、网络等媒体传输系统实现上述媒体信...
go技术文章梳理（2018）
热门推荐
NicolasLearner的博客
03-02 6万+
gocn_news_2018-12-31 1. Go 入门简介：http://t.cn/EbjzeSt 2. Go GraphQL 新手指南： https://tutorialedge.net/golang/go-graphql-beginners-tutorial/ 3. 你需要 Go web 框架吗：https://medium.com/@tusharsoni/do-you-need-a-web-framework-for-go-51171bb0ea8c 4. OpenEdge：开放的边缘计算平
ATLS拧紧枪错误代码
01-30
ATLS拧紧枪错误代码；ATLS拧紧枪错误代码；ATLS拧紧枪错误代码； 大多数工业必备文档；
中国科大网络安全协议 ssl - tls 安全协议
08-23
中国科大网络安全协议 ssl - tls 安全协议
TLS/SSL协议文档，简单易懂
03-06
本文档对ssl/tls协议进行了分析和梳理，内容清晰明了，简单易懂，适合初学者，和对ssl、tls有兴趣的人。
TLS安全网络传输协议简介
01-10
TLS安全网络传输协议简介安全传输层协议（TLS）用于在两个通信应用程序之间提供保密性和数据完整性。该协议由两层组成： TLS 记录协议（TLS Record）和 TLS 握手协议（TLS Handshake）。较低的层为 TLS 记录协议，...
【OpenVINO™】在 C# 中使用 OpenVINO™ 部署 Blazeface 模型快速实现人脸检测
grape_yan的博客
05-06 307
Blazeface模型是Google推出的一款专为移动GPU推理量身定制的轻量级且性能卓越的人脸检测器。在本文中，我们将使用OpenVINO™ C# API 部署 Blazeface 实现人脸检测。
【OpenVINO™】在 C# 中使用OpenVINO™ 部署 YOLO-World 模型实现实时开放词汇对象检测
grape_yan的博客
05-06 764
YOLO-World是一个融合了实时目标检测与增强现实（AR）技术的创新平台，旨在将现实世界与数字世界无缝对接。该平台以YOLO（You Only Look Once）算法为核心，实现了对视频中物体的快速准确识别，并通过AR技术将虚拟元素与真实场景相结合，为用户带来沉浸式的交互体验。在本文中，我们将结合OpenVINO™ C# API 使用最新发布的OpenVINO™ 2024.0部署 YOLO-World实现实时开放词汇对象检测.
企业微信hook接口协议,ipad协议http,设置是否自动同意
企微HOOK 协议
05-06 113
【代码】企业微信hook接口协议,ipad协议http,设置是否自动同意。
C#中的委托是什么？事件是不是一种委托？
最新发布
wangnanofspirit的博客
05-06 182
C#中的委托（Delegate）是一种类型安全的函数指针，它提供了将方法作为参数传递给其他方法、从方法返回方法、或将方法赋值给变量的能力。在C#中，委托（Delegate）是一种类型安全的函数指针，它允许你定义可调用的方法类型，并将这些方法作为参数传递或赋值给变量。通过使用委托，你可以将某些常见或重复的代码块封装到单独的方法中，并通过委托将它们传递给其他方法。委托的声明定义了一个可调用的方法必须具有的确切签名，包括返回类型和方法参数。然后，你可以创建委托的实例，并将其与具有匹配签名的方法相关联。
C# 继承和静态属性或方法
beenles的博客
04-30 506
在C#中，继承（inheritance）和静态属性或方法的概念与Java类似。
c#绘制渐变色的Led
weixin_42103688的博客
05-06 114
c#绘制渐变色的button。
迅睿CMS中实现关键词搜索高亮
QQ183718318的博客
05-06 132
通过使用迅睿CMS中的函数和dr_strcut函数，你可以轻松实现关键词搜索高亮功能。这不仅可以提升用户体验，还可以帮助用户更快速地找到所需信息。记得在循环中正确使用这些函数，并根据实际情况调整参数值。原文地址：https://www.bmhysw.com/article/49803.html。
C#核心之概述
AMrss的博客
05-02 223
C#核心概述。
sdut java lab7.2
2302_80130040的博客
05-03 522
分数 9全屏浏览切换布局作者 马新娟单位 山东理工大学。
通信协议tls1.2和ssl协议
06-10
TLS 1.2和SSL协议都是用于保护网络通信安全的协议。SSL是TLS的前身，TLS是SSL的后继者。TLS 1.2是当前最新的TLS版本，而SSL协议已经被广泛淘汰。 TLS 1.2和SSL协议都采用了加密、身份认证和完整性保护等安全机制，以确保通信过程中的数据不被窃取、篡改或伪造。它们的加密方式都是基于公钥加密和对称加密相结合的方式，其中公钥加密用于建立安全通道和身份认证，对称加密用于保护通信过程中的数据。 但是，TLS 1.2相比于SSL协议提供了更高的安全性和更强的加密算法支持，如AES、SHA-256等。此外，TLS 1.2还增强了握手协议，包括支持更强的密钥交换算法和完整性校验机制等，使得它比SSL更加安全可靠。 综上所述，TLS 1.2是目前网络通信中最安全可靠的协议之一，建议尽可能使用它来保障网络通信的安全。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

fanwenhu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值