基于SCPI可编程仪器通讯-新能源/测试(万用表/内阻表/电压表通讯)(六)

背景:

　　SCPI是一套用于控制可编程测试测量仪器的标准语法和命令，广泛用于测量仪器比如万用表，内阻表中，工控领域如新能源行业上位机开发，或其他测试测量环节经常用到，下面开始记录C#对接模块SCPI通信开发。

• SCPI指令有很多，以下为本次电压、内阻测量使用的命令：

        #region BT3562A
        public const string 版本查询 = "*IDN?";
        public const string 初始化 = "∗RST";

        //量程
        public const string 设置电阻量程 = ":RESistance:RANGe";//0 ～ 3100 电阻量程的设定
        public const string 电阻量程查询 = ":RESistance:RANGe?";//3.000E-3 ～ 3.0000E+3 电阻量程的查询
        public const string 设置电压量程 = ":VOLTage:RANGe";//:VOLTage:RANGe -300 ～ 300 电压量程的设定
        public const string 电压量程查询 = ":VOLTage:RANGe?";//:VOLTage:RANGe? 6.00000E+0 ～300.000E+0 电压量程的查询

        //测量值的读出
        public const string 测量值的读出L1 = ":FETCh?";
        public const string 测量值的读出L2 = ":READ?";
        //:FETCh? < 电阻测量值 >， < 电压测量值 > ΩV最新测量值的读出功能
        //:READ? < 电阻测量值 >， < 电压测量值 > ΩV
        //功能设置查询
        public const string 设置功能 = ":FUNCtion";
        public const string 功能查询 = ":FUNCtion?";

        //自动量程
        public const string 自动量程查询 = ":AUT?"; //：AUTorange 1/ 0/ ON/ OFF 自动量程的设定
        public const string 自动量程设置 = ":AUT";//：AUTorange? ON/ OFF 自动量程设定的查询
        #endregion

        #region DMM7510
        public const string DMM7510_设置电压测量功能 = ":SENS:FUNC 'VOLT:DC'";
        public const string DMM7510_设置电压量程 = ":SENS:VOLT:RANG {0}";

        #endregion

        #region BT3562A
        public const string BT3562A_电阻功能 = "RESISTANCE";
        public const string BT3562A_电压功能 = "VOLTAGE";
        #endregion

　　其他指令：

        //调零
        //:ADJust:CLEAr 调零的解除 
        //:ADJust? 0/ 1 调零的执行与结果查询
        //采样速度
        //:SAMPle:RATE EXFast/ FAST/ MEDium/ SLOW 采样速度的设定
        //:SAMPle:RATE?   EXFast/ FAST/ MEDium/ SLOW  采样速度的查询
        //平均值功能
        //:CALCulate:AVERage:STATe 1/ 0/ ON/ OFF 平均值功能的设定
        //:CALCulate:AVERage:STATe? ON/ OFF 平均值功能执行的查询 133
        //:CALCulate:AVERage 2 ～ 16 平均次数的设定
        //:CALCulate:AVERage? 2 ～ 16 平均次数的查询 133

        //比较器
        //:CALCulate:LIMit:STATe 1/ 0/ ON/ OFF 比较器的设定 133 
        //:CALCulate:LIMit:STATe? ON/OFF 比较器的查询 133 
        //:CALCulate:LIMit:BEEPer OFF/ HL/ IN/ BOTH1/ BOTH2比较器判定蜂鸣器的设定 134 
        //:CALCulate:LIMit:BEEPer? OFF/ HL/ IN/ BOTH1/ BOTH2比较器判定蜂鸣器的查询 134 
        //:CALCulate:LIMit:RESistance:MODE HL/ REF 电阻比较器模式的设定 134 
        //:CALCulate:LIMit:RESistance:MODE? HL/ REF 电阻比较器模式的查询 134 
        //:CALCulate:LIMit:VOLTage:MODE HL/ REF 电压比较器模式的设定 134 
        //:CALCulate:LIMit:VOLTage:MODE? HL/ REF 电压比较器模式的查询 134 
        //:CALCulate:LIMit:RESistance:UPPer<上限值> 电阻上限值的设定 135 
        //:CALCulate:LIMit:RESistance:UPPer? < 上限值 > 电阻上限值的查询 135 
        //:CALCulate:LIMit:VOLTage:UPPer<上限值> 电压上限值的设定 135 
        //:CALCulate:LIMit:VOLTage:UPPer? < 上限值 > 电压上限值的查询 135 
        //:CALCulate:LIMit:RESistance:LOWer<下限值> 电阻下限值的设定 136 
        //:CALCulate:LIMit:RESistance:LOWer? < 下限值 > 电阻下限值的查询 136 
        //:CALCulate:LIMit:VOLTage:LOWer<下限值> 电压下限值的设定 136 
        //:CALCulate:LIMit:VOLTage:LOWer? < 下限值 > 电压下限值的查询 136 
        //:CALCulate:LIMit:RESistance:REFerence<基准电阻> 基准电阻值的设定 137 
        //:CALCulate:LIMit:RESistance:REFerence? < 基准电阻 > 电阻基准值的查询 137 
        //:CALCulate:LIMit:VOLTage:REFerence<基准电阻> 电压基准值的设定 137 
        //:CALCulate:LIMit:VOLTage:REFerence? < 基准电阻 > 电压基准值的查询 137 
        //:CALCulate:LIMit:RESistance:PERCent<范围 （%） > 电阻范围的设定 138 
        //:CALCulate:LIMit:RESistance:PERCent? < 范围 （%） > 电阻范围的查询 138 
        //:CALCulate:LIMit:VOLTage:PERCent<范围 （%） > 电压范围的设定 138 
        //:CALCulate:LIMit:VOLTage:PERCent? < 范围 （%） > 电压范围的查询 138 
        //:CALCulate:LIMit:RESistance:RESult? HI/ IN/ LO/ OFF/ ERR 电阻判定结果的查询 138 
        //:CALCulate:LIMit:VOLTage:RESult? HI/ IN/ LO/ OFF/ ERR 电压判定结果的查询 138 
        //:CALCulate:LIMit:ABS 1/ 0/ ON/ OFF 比较器绝对值判定功能的设定 139 
        //:CALCulate:LIMit:ABS? ON/ OFF 比较器绝对值判定功能的查询 139 统计功能
        //:CALCulate:STATistics:STATe 1/ 0/ ON/ OFF 统计运算功能执行的设定 139 
        //:CALCulate:STATistics:STATe? ON/OFF 统计运算功能执行的查询 139 
        //:CALCulate:STATistics:CLEAr 统计运算结果的清除 139
        //:CALCulate:STATistics:RESistance:NUMBer? < 总数据数 >， < 有效数据数 >电阻测量值数据数的查询 140 
        //:CALCulate:STATistics:VOLTage:NUMBer? < 总数据数 >， < 有效数据数 >电压测量值数据数的查询 140 
        //:CALCulate:STATistics:RESistance:MEAN? < 平均值 > 电阻测量值平均值的查询 140 
        //:CALCulate:STATistics:VOLTage:MEAN? < 平均值 > 电压测量值平均值的查询 140 
        //:CALCulate:STATistics:RESistance:MAXimum? < 最大值 >， < 数据编号 >电阻测量值最大值的查询 141 
        //:CALCulate:STATistics:VOLTage:MAXimum? < 最大值 >， < 数据编号 >电压测量值最大值的查询 141 
        //:CALCulate:STATistics:RESistance:MINimum? < 最大值 >， < 数据编号 >电阻测量值最小值的查询 141 
        //:CALCulate:STATistics:VOLTage:MINimum? < 最小值 >， < 数据编号 >电压测量值最小值的查询 141 
        //:CALCulate:STATistics:RESistance:LIMit? <Hi 数 >， <IN 数 >，<Lo 数 >， < 测试异常数 >电阻测量值比较器判定结果的查询142 
        //:CALCulate:STATistics:VOLTage:LIMit? <Hi 数 >， <IN 数 >，<Lo 数 >， < 测试异常数 >电压测量值比较器判定结果的查询142 
        //:CALCulate:STATistics:RESistance:DEViation? <σ n>， <σ n-1> 电阻测量值标准偏差的查询 142 
        //:CALCulate:STATistics:VOLTage:DEViation? <σ n>， <σ n-1> 电压测量值标准偏差的查询 142 
        //:CALCulate:STATistics:RESistance:CP? <Cp>, <Cpk> 电阻测量值工序能力指数的查询 143 
        //:CALCulate:STATistics:VOLTage:CP? <Cp>, <Cpk> 电压测量值工序能力指数的查询 143
        //存储功能
        //:MEMory:STATe 1/ 0/ ON/ OFF 存储功能设定 143 
        //:MEMory:STATe? ON/ OFF 存储功能查询 143 
        //:MEMory:CLEAr 存储数据清除 143 
        //:MEMory:COUNt? 0 ～ 400 存储数据数查询 144 
        //:MEMory:DATA?[STEP] 存储数据查询 144 
        //自校正
        //:SYSTem:CALibration 自校正的执行 145 
        //:SYSTem:CALibration:AUTO 1/ 0/ ON/ OFF 自动自校正的设定 145 
        //:SYSTem:CALibration:AUTO? ON/ OFF 自动自校正的查询 145 
        //触发输入测量值输出
        //:SYSTem:DATAout 1/ 0/ ON/ OFF 触发输入时的测量值输出设定 145 
        //:SYSTem:DATAout? ON/ OFF 触发输入时的测量值输出查询 145
        //按键操作音
        //:SYSTem:BEEPer:STATe 1/ 0/ ON/ OFF 按键操作音设定 146 
        //:SYSTem:BEEPer:STATe? ON/ OFF 按键操作音的查询 146
        //电源频率
        //:SYSTem:LFRequency AUTO/50/ 60 电源频率的设定 146 
        //:SYSTem:LFRequency? AUTO/50/ 60 电源频率的查询 146 
        //按键锁定
        //:SYSTem:KLOCk 1/ 0/ ON/ OFF 按键锁定状态的设定 146 
        //:SYSTem:KLOCk? ON/ OFF 按键锁定状态的查询 146 
        //EXT I/O 输出
        //:SYSTem:ELOCk 1/ 0/ ON/ OFF 外部输入端子锁定的设定 147 
        //:SYSTem:ELOCk? ON/ OFF 外部输入端子锁定的 ON/OFF 查询 147 
        //本地
        //:SYSTem:LOCal 本地状态的设定 147 
        //测量条件的保存和读入
        //:SYSTem:SAVE<Table No.> 测量条件的保存 147 
        //:SYSTem:LOAD<Table No.> 测量条件的读出 147 
        //:SYSTem:BACKup 测量条件的备份 147 
        //信息头有无
        //:SYSTem:HEADer 1/ 0/ ON/ OFF 信息头有无的设定 148 
        //:SYSTem:HEADer? ON/ OFF 信息头有无的查询 148 
        //ERR 输出
        //:SYSTem:ERRor SYNChronous/ ASYNchronous错误输出时序的设定 148 
        //:SYSTem:ERRor? SYNCHRONOUS/ ASYNCHRONOUS
        //错误输出时序的查询 148 
        //EOM 输出
        //:SYSTem:EOM:MODE<HOLD/PULSe> EOM 输出模式的设定 149 
        //:SYSTem:EOM:MODE? (<HOLD/PULSE>) EOM 输出模式的查询 149 
        //:SYSTem:EOM:PULSe<脉冲宽度> EOM 脉冲宽度的设定 149 
        //:SYSTem:EOM:PULSe? (0.001 ～ 0.099) EOM 脉冲宽度的查询 149 
        //测量电流脉冲输出功能的设定
        //:SYSTem:CURRent CONTinuous/PULSe 测量电流脉冲输出功能的设定 149 
        //:SYSTem:CURRent? CONTINUOUS/PULSE 测量电流脉冲输出功能的查询 149
        //终止符
        //:SYSTem:TERMinator 0/ 1 终止符的设定 148 
        //:SYSTem:TERMinator? 0/ 1 终止符的查询 148 
        //系统复位
        //:SYSTem:RESet 执行包括测量条件保存数据在内的复位 149 
        //EXT I/O
        //:IO:IN? 0 ～ 31 EXT I/O 输入 150 
        //触发
        //:INITiate:CONTinuous 1/ 0/ ON/ OFF 连续测量的设定 152 
        //:INITiate:CONTinuous? ON/ OFF 连续测量的查询 152 
        //:INITiate[:IMMediate] 等待触发的设定 152 
        //触发源的设定
        //:TRIGger:SOURce IMMediate/ EXTernal 触发源的设定 153 
        //:TRIGger:SOURce? IMMEDIATE/ EXTERNAL 触发源的查询 153 
        //:TRIGger:DELay:STATe 1/ 0/ ON/ OFF 触发延迟执行的设定 153 
        //:TRIGger:DELay:STATe? ON/ OFF 触发延迟的查询 153 
        //:TRIGger:DELay<延迟时间> 触发延迟时间的设定 153 
        //:TRIGger:DELay? 0 ～ 9.999 触发延迟时间的查询 153

• 通信基类-SOCKET实现（TcpClientSocketHelper）

　　SCPI也是通过socket进行数据发送与接收，所以在测试时，需要设置好IP与端口号。

　　socket需实现连接、关闭连接、接收数据、发送数据

连接：

 public bool Open(out string msg)
        {
            lock(Lock)
            {
                msg = string.Empty;
                try
                {
                    if (!PingCheck(Ip, ConnectTimeout))
                    {
                        msg = $"网络故障:Ip|{Ip},ConnectTimeout|{ConnectTimeout}!";
                        return false;
                    }
                    System.Diagnostics.Stopwatch sp = new System.Diagnostics.Stopwatch();
                    sp.Start();
                    this.tcpClient = new TcpClient();
                    this.tcpClient.ReceiveTimeout = ReceiveTimeout;
                    this.tcpClient.SendTimeout = SendTimeout;
                    this.tcpClient.Connect(Ip, Port);
                    Thread.Sleep(10);
                    if (!tcpClient.Connected)
                    {
                        throw new ApplicationException($"未连接到{Ip}");
                    }
                    if (!IsConnected) SocketConnectedEvent?.BeginInvoke(this, EventArgs.Empty, null, null);
                    IsConnected = true;
                    msg = $"连接[{Ip}]成功,耗时{sp.Elapsed.TotalMilliseconds.ToString()}ms";

                    return true;

                }
                catch (Exception ex)
                {
                    Close(out string _msg);
                    msg = $"连接失败:{ex.Message},{_msg}";
                    return false;
                }
            }
        }

关闭：

      public bool Close(out string msg)
        {
            lock(Lock)
            {
                msg = string.Empty;
                try
                {
                    if (IsConnected) SocketClosedEvent?.BeginInvoke(this, EventArgs.Empty,null,null);
                    this.tcpClient?.Close();
                    this.tcpClient = null;
                    return true;
                }
                catch (Exception ex)
                {
                    msg = $"关闭失败:{ex.Message}";
                    tcpClient = null;
                    return false;
                }
                finally
                {
                    IsConnected = false;
                }
            }
        }

发送接收数据

     public bool SendAndRecive(out string msg, byte[] sd,byte[] rd, int receiveTimeout = 3000)
        {
            msg = string.Empty; ReceiveTimeout = receiveTimeout;
            try
            {
                #region 连接状态
                if (tcpClient == null || !tcpClient.Connected)
                {
                    if (!Open(out msg))
                    {
                        Thread.Sleep(40);
                        if (!Open(out msg)) return false;
                    }
                }
                #endregion
                tcpClient.GetStream().Write(sd, 0, sd.Length);

                Thread.Sleep(100);
                //
                int index = 0;
                System.Diagnostics.Stopwatch sp = new System.Diagnostics.Stopwatch();
                sp.Start();
                do
                {
                    int len = tcpClient.GetStream().Read(rd, index, rd.Length - index);
                    if (len == 0)
                        return false;//这里控制读取不到数据时就跳出,网络异常断开，数据读取不完整。
                    else
                        index += len;

                    if (sp.ElapsedMilliseconds > ReceiveTimeout) return false;//超时截止

                } while (index < rd.Length);

                return true;
            }
            catch (Exception ex)
            {
                msg = ex.Message;
                Close(out msg);
                return false;
            }
        }

• SCPI通信基类实现(SCPIClientBase)

 有三个主要功能消息接收、发送命令、查询指令：

  public bool ReceiveMsg(out string msg, int receiveTimeout = 3000)
        {
            msg = string.Empty;
            byte[] ary = new byte[65536];
            StringBuilder buf = new StringBuilder();
            Stopwatch sw = new Stopwatch();
            try
            {
                #region 连接状态
                if (tcpClient == null || !tcpClient.Connected)
                {
                    if (!Open(out msg))
                    {
                        Thread.Sleep(40);
                        if (!Open(out msg)) return false;
                    }
                }
                #endregion
                sw.Start();
                string rcv;
                for (; ; )
                {
                    if (tcpClient.GetStream().DataAvailable)
                    {
                        int len = tcpClient.GetStream().Read(ary, 0, ary.Length);
                        rcv = Encoding.Default.GetString(ary).Substring(0, len);
                        rcv = rcv.Replace("\r", "");
                        if (rcv.IndexOf("\n") >= 0)
                        {
                            break;
                        }
                        buf.Append(rcv);
                    }
                    if (sw.ElapsedMilliseconds > receiveTimeout)
                    {
                        goto Block_5;
                    }
                }
                rcv = rcv.Substring(0, rcv.IndexOf("\n"));
                buf.Append(rcv);
                msg = buf.ToString();
                sw.Stop();
                return true;
            Block_5:
                msg = $"接收超时:[{receiveTimeout}]";
                return false;
            }
            catch (Exception ex)
            {
                msg = $"接收失败:{ex.Message}";
                return false;
            }
        }

  public bool SendMsg(string cmd, out string msg)
        {
            msg = string.Empty;
            try
            {
                cmd += "\r\n";
                var SendBuffer = Encoding.Default.GetBytes(cmd);
                return SendData(out msg, SendBuffer);
            }
            catch (Exception ex)
            {
                msg = $"指令[{cmd}]发送失败:{ex.Message}";
                return false;
            }
        }

public bool SendQueryMsg(string cmd, int timeout_ms, out string msg)
        {
            msg = string.Empty;
            try
            {
                if (!this.SendMsg(cmd, out msg)) return false;

                if (!cmd.Contains("?"))
                {
                    msg = "非查询指令";
                    return false;
                }

                return ReceiveMsg(out msg, timeout_ms);
            }
            catch (Exception ex)
            {
                msg = $"查询失败:{ex.Message}";
                return false;
            }
        }

• 电表通信类(以BT3562表为例)

  public override bool 版本获取(out string msg)
        {
            msg = string.Empty;
            try
            {
                var ar = SendQueryMsg($"{SCPI指令集.版本查询}", 2000, out msg);

                if(!ar) return false;
                //版本校验
                if (!msg.StartsWith(BT3562常量定义.厂商))
                {
                    //型号不正确
                    msg = $"非{BT3562常量定义.厂商}厂商";
                    return false;
                }
                string p = msg;
                if (!BT3562常量定义.型号.Any(f=> p.Contains(f)))
                {
                    msg = $"型号不正确:{p}";
                    return false;
                }

                VersionID = msg;
                return true;
            }
            catch (Exception ex)
            {
                msg = $"版本获取失败:{ex.Message}";
                return false;
            }
        }

public override bool 设置功能(out string msg, MultimeterFunc funcstring= MultimeterFunc.InternalResistance)
        {
            msg = string.Empty;
            try
            {
                string cmd;
                switch(funcstring)
                {
                    case MultimeterFunc.Voltage:
                    case MultimeterFunc.ShellPressure:
                        cmd = SCPI指令集.设置功能 + " " + SCPI指令集.BT3562A_电压功能;
                        break;
                    case MultimeterFunc.InternalResistance:
                    default:
                        cmd = SCPI指令集.设置功能 + " " + SCPI指令集.BT3562A_电阻功能;
                        break;
                }
               
                return SendMsg(cmd, out msg);
            }
            catch (Exception ex)
            {
                msg = $"设置功能失败:{ex.Message}";
                return false;
            }
        }

        public override bool 设置量程(out string msg,string cmd="3E-3")
        {
            msg = string.Empty;
            try
            {
                string rand = $"{SCPI指令集.设置电阻量程} {cmd}";
                if(rand.Contains("AUTO"))
                {
                    //自动量程
                    rand = ":AUT ON";
                }
                return SendMsg(rand, out msg);
            }
            catch (Exception ex)
            {
                msg = $"设置量程失败:{ex.Message}";
                return false;
            }
        }

public override bool 测量(out string msg,out double v)
        {
            msg = string.Empty; v = 0;
            try
            {
                if(!SendQueryMsg($"{SCPI指令集.测量值的读出L1}", 1000, out msg))
                {
                    return false;
                }
                if(!double.TryParse(msg,out v))
                {
                    msg = $"测量值不正确:{msg}";
                    return false;
                }
                //转毫欧
                v *= 1000;
                return true;
            }
            catch (Exception ex)
            {
                msg = $"测量失败:{ex.Message}";
                return false;
            }
        }

• 测试结果

 

 读取到电压值