/// <summary>
/// 执行断路器检测命令
/// </summary>
/// <param name="client">PcbTesterClient句柄</param>
/// <param name="parameter">命令参数</param>
/// <param name="context">不同命令之间的通信参数</param>
/// <returns>检测结果</returns>
public CommandResult Execute(PcbTesterClient client, CommandParameter parameter, CommandContext context)
{
WriteResult writeResult = client.Write("0-0:199.128.11", string.Empty);
if (!writeResult.Success)
{
string message = string.Format("{0};0x{1:X};{2}", Resources.BreakerTest, string.Empty, writeResult.Error.ToString());
logger.ErrorFormat("{0}", message);
throw new CommunicationException(message);
}
ReadResult testResult = client.Read("0-0:199.128.11", string.Empty);
//检测结果为错误码
if (!testResult.Success)
{
logger.ErrorFormat("{0}", testResult.Data);
throw new CommunicationException(testResult.Data);
}
//检测板支持三路断路器检测，三路检测结果用逗号隔开，取值为“OK”/“ERROR”。e.g. OK,ERROR,ERROR
string[] breakerState = testResult.Data.Split(',');
for (int i = 0; i < breakerState.Length; i++)
{
if (breakerState[i] == "ERROR")
{
return(new CommandResult(false, testResult.Data));
}
}
return(new CommandResult(true, testResult.Data));
}
/// <summary>
/// 补偿秒信号
/// </summary>
/// <param name="client">PcbTesterClient句柄</param>
/// <param name="parameter">秒信号参数</param>
/// <param name="clockValue"></param>
private void CompensateClockSignal(PcbTesterClient client, SecondSignalCalibrationParameter parameter, decimal clockValue)
{
//1.开透明通道
MeterCommunicationCommand communicationCommand = new MeterCommunicationCommand();
var openResult = MeterCommunicationHelper.OpenTransparentChannel(
client,
new MeterCommunicationCommandParameter(
parameter.ComPort,
parameter.BaudRate,
parameter.DataBits,
parameter.Parity));
//2.发送读部标信息帧
byte[] resultBuffer = client.Write(MinistryStandardFrames.ReadMeterMessage, true);
//3.处理表回的信息帧
int b = resultBuffer[14] - 0x33;
if ((b & 0x40) != 0)
{
b = b | 0x80;
}
int complementCode = (int)ComplementCodeHelper.CalcComplementCode(clockValue);
int sendComplementCode = (b + complementCode) & 0x7F;
//秒信号无法修补
if (!((0x00 <= sendComplementCode && sendComplementCode <= 0x0A) || (0x70 <= sendComplementCode && sendComplementCode <= 0x7F)))
{
MeterCommunicationHelper.ExitTransparentChannel(client); //退出透明通道
return;
}
//4.若能补偿，则发送补偿秒信号的帧
string clockChipFrame = GetWriteClockChipFrame((byte)sendComplementCode); //写时钟芯片信号帧
client.Write(clockChipFrame, true);
string compensateClockSignalFrame = GetCompensateClockSignalFrame((byte)sendComplementCode);
client.Write(clockChipFrame, true);
MeterCommunicationHelper.ExitTransparentChannel(client); //退出透明通道
}
/// <summary>
/// 执行被测表通信命令
/// </summary>
/// <param name="client">PcbTesterClient句柄</param>
/// <param name="parameter">命令参数</param>
/// <param name="context">不同命令之间的通信参数</param>
/// <returns>检测结果</returns>
public CommandResult Execute(PcbTesterClient client, CommandParameter parameter, CommandContext context)
{
var communicationParameter = parameter as MeterCommunicationCommandParameter;
//打开透明通道
WriteResult writeResult = client.Write(Obis, FormatWriteParameter(communicationParameter));
var result = new CommandResult(writeResult.Success);
if (!result.Success) //应答错误
{
string message = string.Format(
Resources.MeterCommunicationCommand_WriteFailedMessageFormat,
this.Name,
writeResult.Error.ToString(),
communicationParameter.ToString());
logger.Error(message);
throw new CommunicationException(message);
}
byte[] recvData = client.Write(communicationParameter.SendData, communicationParameter.IsHex);
string actualRecvData = Microstar.Utility.Hex.ToString(recvData, " ");
string expectedRecvData = communicationParameter.ExpectedReceiveData.Trim();
if (actualRecvData == expectedRecvData)
{
return(new CommandResult(true, actualRecvData));
}
else
{
return(new CommandResult(
false,
actualRecvData,
string.Format(
Resources.MeterCommunicationCommand_CommErrorMessageFormat,
this.Name,
communicationParameter.ToString(),
expectedRecvData,
actualRecvData)));
}
}
/// <summary>
/// 执行强制编程命令
/// </summary>
/// <param name="client">PcbTesterClient句柄</param>
/// <param name="parameter">命令参数</param>
/// <param name="context">不同命令之间的通信参数</param>
/// <returns>检测结果</returns>
public CommandResult Execute(PcbTesterClient client, CommandParameter parameter, CommandContext context)
{
var forceProgramParameter = parameter as ForceProgramCommandParameter;
WriteResult writeResult = client.Write(Obis, FormatWriteParameter(forceProgramParameter));
if (!writeResult.Success)
{
string message = string.Format(
Resources.ForceProgramCommand_WriteFailedMessageFormat,
this.Name,
writeResult.Error.ToString(),
forceProgramParameter.ToString());
logger.Error(message);
throw new CommunicationException(message);
}
//读取强编状态
ReadResult readResult = client.Read(Obis, string.Empty);
while (StringResultToEnum(readResult.Data) == ForceProgramState.ForceProgramProcessing)
{
System.Threading.Thread.Sleep(1000);
readResult = client.Read(Obis, string.Empty);
if (!readResult.Success)
{
break;
}
if (readResult.Data == ForceProgramState.Succeed.ToString())
{
break;
}
}
//强编失败
if (!readResult.Success)
{
return(new CommandResult(
false,
readResult.Error.ToString(),
string.Format(
Resources.ForceProgramCommand_ForceProgramErrorMessageFormat,
this.Name,
forceProgramParameter.ToString(),
ForceProgramState.Succeed.ToString(),
readResult.Error.ToString())));
}
return(new CommandResult(true));
}
/// <summary>
/// 激活表的秒信号
/// </summary>
/// <returns></returns>
private void ActivateSecond(PcbTesterClient client, SecondSignalCalibrationParameter parameter)
{
//1.开透明通道
MeterCommunicationCommand communicationCommand = new MeterCommunicationCommand();
var communicationParamter = new MeterCommunicationCommandParameter(
parameter.ComPort,
parameter.BaudRate,
parameter.DataBits,
parameter.Parity);
MeterCommunicationHelper.OpenTransparentChannel(client, communicationParamter);
//2.发送激活秒信号帧
client.Write(MinistryStandardFrames.ActivateSecond, true); //激活秒信号帧
//3.发完退出透明通道
MeterCommunicationHelper.ExitTransparentChannel(client); //退出透明通道
}
/// <summary>
/// 执行继电器控制命令
/// </summary>
/// <param name="client">PcbTesterClient句柄</param>
/// <param name="parameter">命令参数</param>
/// <param name="context">不同命令之间的通信参数</param>
/// <returns>检测结果</returns>
public CommandResult Execute(PcbTesterClient client, CommandParameter parameter, CommandContext context)
{
var relayParameter = parameter as RelayControlCommandParameter;
WriteResult writeResult = client.Write(Obis, FormatWriteParameter(relayParameter));
var result = new CommandResult(writeResult.Success);
if (!result.Success)
{
string message = string.Format(
Resources.RelayControlCommand_WriteFailedMessageFormat,
this.Name,
writeResult.Error.ToString(),
relayParameter.ToString());
logger.Error(message);
throw new CommunicationException(message);
}
return(result);
}
/// <summary>
/// 开启透明通道
/// </summary>
/// <param name="client">PcbTesterClient实例</param>
/// <param name="parameter">端口参数</param>
/// <returns>运行结果</returns>
public static CommandResult OpenTransparentChannel(PcbTesterClient client, CommandParameter parameter)
{
var communicationParameter = parameter as MeterCommunicationCommandParameter;
MeterCommunicationCommand command = new MeterCommunicationCommand();
//打开透明通道
WriteResult writeResult = client.Write(command.Obis, command.FormatWriteParameter(communicationParameter));
var result = new CommandResult(writeResult.Success);
if (!result.Success) //应答错误
{
string message = string.Format(
Resources.MeterCommunicationCommand_WriteFailedMessageFormat,
command.Name,
writeResult.Error.ToString(),
communicationParameter.ToString());
logger.Error(message);
throw new CommunicationException(message);
}
return(result);
}
/// <summary>
/// 执行秒信号检测命令
/// </summary>
/// <param name="client">PcbTesterClient句柄</param>
/// <param name="parameter">命令参数</param>
/// <param name="context">不同命令之间的通信参数</param>
/// <returns>检测结果</returns>
public CommandResult Execute(PcbTesterClient client, CommandParameter parameter, CommandContext context)
{
var secondParameter = parameter as SecondSignalCalibrationParameter;
while (true)
{
RelayControlHelper.On5V(client);
if (secondParameter.EnableActivateClockSignal) //如果需要激活表秒信号功能
{
logger.Debug("Activate second signal...");
ActivateSecond(client, secondParameter);
}
logger.Debug("Start test second signal...");
WriteResult writeResult = client.Write(Obis, string.Empty);
//开始检测秒信号失败
if (!writeResult.Success)
{
string message = string.Format(
Resources.SecondSignalCalibrationCommand_WriteFailedMessageFormat,
this.Name,
writeResult.Error.ToString(),
string.Empty);
logger.Error(message);
throw new CommunicationException(message);
}
//等待发送读取秒信号检测结果命令
System.Threading.Thread.Sleep((int)secondParameter.DelayTime);
logger.Debug("Read test second signal result...");
ReadResult readResult = client.Read(Obis, string.Empty); //发送读秒信号检测结果帧
//检测结果为错误码
if (!readResult.Success)
{
string message = string.Format(
Resources.SecondSignalCalibrationCommand_ReadResultFailedMessageFormat,
this.Name,
readResult.Error.ToString(),
string.Empty);
logger.Error(message);
throw new CommunicationException(message);
}
decimal clockValue = ParseClockSignalResult(readResult.Data);
if (clockValue == noValue) //无秒信号值
{
logger.Error(Resources.SecondSignalCalibrationCommand_NoValue);
throw new CommunicationException(Resources.SecondSignalCalibrationCommand_NoValue);
}
//结果在误差范围内 正确结果
if (secondParameter.IsWithinRange(clockValue))
{
return(new CommandResult(true, readResult.Data));
}
//秒信号错误，不在误差范围内，判断是否需要补偿秒信号
if (!secondParameter.EnableAutoClockCompensation) // 不需要补偿，返回错误结果
{
string expectedValue = secondParameter.ExpectedValueRange;
return(new CommandResult(
false,
readResult.Data,
string.Format(
Resources.SecondSignalCalibrationCommand_MeasureErrorMessageFormat,
this.Name,
secondParameter.ToString(),
secondParameter.ExpectedValueRange,
readResult.Data)));
}
logger.Debug("Compensate second signal...");
//补偿秒信号
CompensateClockSignal(client, secondParameter, clockValue);
}
}
/// <summary>
/// 执行脉冲检测命令
/// </summary>
/// <param name="client">PcbTesterClient句柄</param>
/// <param name="parameter">命令参数</param>
/// <param name="context">不同命令之间的通信参数</param>
/// <returns>检测结果</returns>
public CommandResult Execute(PcbTesterClient client, CommandParameter parameter, CommandContext context)
{
RelayControlHelper.On5V(client);
StringBuilder sb = new StringBuilder();
var relayControlPara = new RelayControlCommandParameter();
relayControlPara.SelectedNumber = "20";
RelayControlHelper.PulseRelayControl(client, RelayControlAction.OPEN);
CommandResult commandResult = new CommandResult();
for (int i = 0; i < 2; i++)
{
if (i == 0)
{
relayControlPara.Action = RelayControlAction.OPEN;
}
else if (i == 1)
{
relayControlPara.Action = RelayControlAction.CLOSE;
}
//控制脉冲检测对应继电器
var relayControlCommand = new RelayControlCommand();
commandResult = relayControlCommand.Execute(client, relayControlPara, context);
//继电器操作失败
if (!commandResult.Success)
{
return(commandResult);
}
System.Threading.Thread.Sleep(500);
//发送检测命令
WriteResult writeResult = client.Write("0-0:199.128.1", string.Empty);
//启动脉冲采集命令异常应答
if (!writeResult.Success)
{
string message = string.Format("{0};0x{1:X};{2}", this.Name, string.Empty, writeResult.Error.ToString());
logger.ErrorFormat("{0}", message);
throw new CommunicationException(message);
}
//等待1s发送读取脉冲检测结果命令
System.Threading.Thread.Sleep(1000);
ReadResult testResult = client.Read("0-0:199.128.1", string.Empty);
//检测结果为错误码
if (!testResult.Success)
{
logger.ErrorFormat("{0}", testResult.Data);
throw new CommunicationException(testResult.Data);
}
commandResult.Success = true;
sb.Append(testResult);
if (i == 0)
{
sb.Append(",");
}
}
commandResult.Data = sb.ToString();
return(commandResult);
}
/// <summary>
/// 校正相位命令
/// </summary>
/// <param name="client">PcbTesterClient句柄</param>
/// <param name="phase">相位标准值</param>
/// <returns>命令结果</returns>
public static WriteResult CalibratePhase(PcbTesterClient client, int phase)
{
return(client.Write("0-0:199.128.5*6", string.Format("0x{0:X2}", phase)));
}
/// <summary>
/// 校正电压测量命令
/// </summary>
/// <param name="client">PcbTesterClient句柄</param>
/// <param name="voltage">电压标准值，单位V</param>
/// <returns>命令结果</returns>
public static WriteResult CalibrateVoltage(PcbTesterClient client, decimal voltage)
{
return(client.Write("0-0:199.128.5*5", string.Format("{0}V", voltage)));
}
/// <summary>
/// 校正电流测量命令
/// </summary>
/// <param name="client">PcbTesterClient句柄</param>
/// <param name="current">电流标准值，单位mA</param>
/// <returns>命令结果</returns>
public static WriteResult CalibrateCurrent(PcbTesterClient client, decimal current)
{
return(client.Write("0-0:199.128.5*4", string.Format("{0}mA", current)));
}
/// <summary>
/// 退出透明通道
/// </summary>
/// <param name="client">PcbTesterClient句柄</param>
public static void ExitTransparentChannel(PcbTesterClient client)
{
client.Write(MinistryStandardFrames.ExitTransparentChannel, true);
}
/// <summary>
/// 执行电量测量
/// </summary>
/// <param name="client">PcbTesterClient句柄</param>
/// <param name="parameter">命令参数</param>
/// <param name="context">不同命令之间的通信参数</param>
/// <returns>检测结果</returns>
public CommandResult Execute(PcbTesterClient client, CommandParameter parameter, CommandContext context)
{
var electricalParameter = parameter as MeasureParameter;
WriteResult writeResult = client.Write(Obis, FormatWriteParameter(electricalParameter));
if (!writeResult.Success)
{
string message = string.Format(
Resources.MeasureCommandBase_StartFailedMessageFormat,
this.Name,
writeResult.Error.ToString(),
electricalParameter.ToString());
logger.Error(message);
throw new CommunicationException(message);
}
ReadResult readResult = client.Read(ReadResultObis, string.Empty);
//检测结果为错误码
if (!readResult.Success)
{
string message = string.Format(
Resources.MeasureCommandBase_ReadResultFailedMessageFormat,
this.Name,
readResult.Error.ToString(),
string.Empty);
logger.Error(message);
throw new CommunicationException(message);
}
decimal measureValue = ParseMeasureValue(readResult.Data, Unit);
if (Unit == "mV") //单位mv
{
electricalParameter.LowerLimit *= 1000m; //UI上设置的电压单位是V,直流电压测量的数据单位是mV，将V转为mV
electricalParameter.UpperLimit *= 1000m;
}
//测量结果不在所规定的误差范围
if (!electricalParameter.IsWithinRange(measureValue))
{
string expectedValue = string.Format("{0}{1}-{2}{3}", electricalParameter.LowerLimit, Unit, electricalParameter.UpperLimit, Unit);
return(new CommandResult(
false,
readResult.Data,
string.Format(
Resources.MeasureCommandBase_MeasureErrorMessageFormat,
this.Name,
electricalParameter.PinNumber,
electricalParameter.CurrentRange,
electricalParameter.Phase,
expectedValue,
readResult.Data)));
}
return(new CommandResult(true, readResult.Data));
}