429 lines
13 KiB
C#
429 lines
13 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using ChamChat.Models;
|
|
|
|
namespace ChamChat
|
|
{
|
|
public partial class LHL113_Client : Client
|
|
{
|
|
private const Int32 _OptionRange = 3000;
|
|
private const Int32 _DataTransferTimeOut = 1000;
|
|
private DateTime _ReadyToSend = DateTime.Now; // Timestamp when client is ready to communicate
|
|
private const int _RAM = 1;
|
|
private DateTime _dtTestStart = DateTime.Now;
|
|
|
|
|
|
// To do
|
|
public LHL113_Client(Int32 MIDS, ClientType Type)
|
|
: base(MIDS, Type)
|
|
{
|
|
// Set options available in client
|
|
_Parameters = new List<Parameter>();
|
|
_Parameters.Add(Parameter.T);
|
|
_Parameters.Add(Parameter.RH);
|
|
_Parameters.Add(Parameter.RampT);
|
|
_Parameters.Add(Parameter.RampRH);
|
|
|
|
// Add option range
|
|
_ClientOptions = new List<ProfileOption>();
|
|
foreach (ProfileOption o in Enum.GetValues(typeof(ProfileOption)))
|
|
if ((int)o >= _OptionRange && (int)o < _OptionRange+999)
|
|
_ClientOptions.Add(o);
|
|
|
|
// Set availabel addresses for programming
|
|
_AvailableRAMs = new List<int>();
|
|
for (int i = 1; i < 31; i++)
|
|
_AvailableRAMs.Add(i);
|
|
|
|
|
|
_InterfaceType = InterfaceType.FDTI_USB_COM422;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// To do
|
|
public override Profile ReadProfile(int RAM, ref System.ComponentModel.BackgroundWorker bgw)
|
|
{
|
|
string sAddr = _Address.ToString();
|
|
string cmd;
|
|
string read;
|
|
Profile profile = new Profile();
|
|
|
|
try
|
|
{
|
|
// Communicate with client
|
|
cmd = sAddr + ",PRGMREAD,";
|
|
DataTransfer(cmd, out read, _DataTransferTimeOut);
|
|
|
|
|
|
List<Step> steps = new List<Step>();
|
|
List<Loop> loops = new List<Loop>();
|
|
List<ProfileOption> options = new List<ProfileOption>();
|
|
String name = "LHL113_Client";
|
|
|
|
// Create profile
|
|
profile = new Profile(name, steps, loops, options);
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
return profile;
|
|
}
|
|
|
|
|
|
public override Boolean WriteProfile(Profile profile)
|
|
{
|
|
return WriteProfile(profile, _RAM);
|
|
}
|
|
|
|
public override Boolean WriteProfile(Profile profile, int RAM)
|
|
{
|
|
// Only stand alone profiles allowed!
|
|
if (!IsProgrammable(profile))
|
|
return false;
|
|
|
|
|
|
string sRAM = String.Format("{0:0}", RAM);
|
|
|
|
string sCmdStart = _Address.ToString() + ", PRGM DATA WRITE, PGM:" + sRAM + ", ";
|
|
string cmd;
|
|
string read;
|
|
|
|
|
|
// Set to STANDBY if OFF
|
|
cmd = _Address.ToString() + ", MODE?";
|
|
DataTransfer(cmd, out read, _DataTransferTimeOut);
|
|
if (read.Contains("OFF"))
|
|
{
|
|
cmd = _Address.ToString() + ", MODE, STANDBY";
|
|
DataTransfer(cmd, out read, _DataTransferTimeOut);
|
|
}
|
|
|
|
|
|
|
|
// Communicate with client (page 49)
|
|
cmd = sCmdStart + "EDIT START";
|
|
DataTransfer(cmd, out read, _DataTransferTimeOut);
|
|
|
|
for (int i = 0; i < profile.SerializedStepList.Count; i++)
|
|
{
|
|
Step step = profile.SerializedStepList[i];
|
|
cmd = sCmdStart;
|
|
cmd += string.Format("STEP{0:0}, ", i + 1);
|
|
cmd += string.Format("TEMP{0:00.0}, ", step.T);
|
|
if (step.RampCtrlT) cmd += "TRAMPON,"; else cmd += "TRAMPOFF,";
|
|
cmd += string.Format("HUMI{0:00}, ", step.RH);
|
|
if (step.RampCtrlRH) cmd += "HRAMPON,"; else cmd += "HRAMPOFF,";
|
|
|
|
if (step.Hours < 100)
|
|
cmd += string.Format("TIME{0:00}:{1:00}, ", step.Hours, step.Minutes);
|
|
else
|
|
cmd += string.Format("TIME{0:00}:00, ", step.Hours);
|
|
cmd += "GRANTY OFF, ";
|
|
DataTransfer(cmd, out read, _DataTransferTimeOut);
|
|
System.Threading.Thread.Sleep(500);
|
|
}
|
|
|
|
// End options (off is default)
|
|
if (profile.Options.Contains(ProfileOption.LHL113_EndModeHold))
|
|
cmd = sCmdStart + "END, HOLD";
|
|
else
|
|
cmd = sCmdStart + "END, OFF";
|
|
DataTransfer(cmd, out read, _DataTransferTimeOut);
|
|
|
|
|
|
|
|
// Loop (see page 50)
|
|
if (profile.Loops.Count == 1)
|
|
{
|
|
Loop l = profile.Loops[0];
|
|
cmd = sCmdStart + String.Format("COUNT, ({0:0}. {1:0}. {2:0})", l.First, l.Last, l.N);
|
|
DataTransfer(cmd, out read, _DataTransferTimeOut);
|
|
}
|
|
|
|
cmd = sCmdStart + "EDIT END";
|
|
DataTransfer(cmd, out read, _DataTransferTimeOut);
|
|
|
|
|
|
Boolean result = false;
|
|
if (_Interface.InterfaceStatus == null)
|
|
result = true;
|
|
|
|
_Profile = profile;
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
public override Boolean IsProgrammable(Profile profile)
|
|
{
|
|
// Profile is programmable if all below applies
|
|
|
|
// Step is at least 3 minutes
|
|
foreach (Step step in profile.Steps)
|
|
if (step.DurationMin < 3)
|
|
return false;
|
|
|
|
// Temperature is limited between 30 & 90 °C
|
|
foreach (Step step in profile.Steps)
|
|
if (step.T < 30 || step.T > 90)
|
|
return false;
|
|
|
|
// RH is limited between 60 & 95 °C
|
|
foreach (Step step in profile.Steps)
|
|
if (step.RH < 60 || step.RH > 95)
|
|
return false;
|
|
|
|
// Only one program of a max of 9 steps and a maximum of 99 repeated steps can be stored at a time (page 44 of user's manual).
|
|
if (profile.Steps.Count > 9)
|
|
return false;
|
|
|
|
if (profile.Loops.Count == 1)
|
|
{
|
|
if (profile.Loops[0].N > 99)
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if (profile.SerializedStepList.Count > 9)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
// To do
|
|
public override Boolean HasAlarm(out List<Alarm> alarms)
|
|
{
|
|
alarms = new List<Alarm>();
|
|
return true;
|
|
}
|
|
|
|
|
|
public override Boolean IsIdle()
|
|
{
|
|
// IsIdle() returns true if status of chamber is 'Standby'. See page 31 MODE?.
|
|
string sAddr = _Address.ToString();
|
|
string cmd;
|
|
string read;
|
|
|
|
cmd = sAddr + ", MODE?";
|
|
DataTransfer(cmd, out read, _DataTransferTimeOut);
|
|
|
|
if (read.Contains("STANDBY") || read.Contains("OFF"))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
public override Boolean Start()
|
|
{
|
|
if (_Profile == null)
|
|
return false;
|
|
|
|
string sAddr = _Address.ToString();
|
|
string cmd;
|
|
string read;
|
|
|
|
cmd = sAddr + ", MODE, RUN "+_RAM; // See page 47.
|
|
DataTransfer(cmd, out read, _DataTransferTimeOut);
|
|
|
|
_dtTestStart = DateTime.Now;
|
|
|
|
return TxRxSucces(cmd, read);
|
|
}
|
|
|
|
|
|
public override Boolean IsFinished()
|
|
{
|
|
// Finished() returns true if chamber is not running. See page 34 MODE?.
|
|
string sAddr = _Address.ToString();
|
|
string cmd;
|
|
string read;
|
|
|
|
cmd = sAddr + ", MODE?";
|
|
DataTransfer(cmd, out read, _DataTransferTimeOut);
|
|
|
|
if (read.Contains("OFF") || read.Contains("STANDBY"))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
public override Boolean Stop()
|
|
{
|
|
string sAddr = _Address.ToString();
|
|
string cmd;
|
|
string read;
|
|
|
|
cmd = sAddr + ", MODE, STANDBY"; // Pg. 47
|
|
DataTransfer(cmd, out read, _DataTransferTimeOut);
|
|
|
|
return TxRxSucces(cmd, read);
|
|
}
|
|
|
|
|
|
|
|
public override Boolean IsOnline()
|
|
{
|
|
try
|
|
{
|
|
string sAddr = _Address.ToString();
|
|
string cmd;
|
|
string read;
|
|
cmd = sAddr + ", ROM?"; // Pg. 27
|
|
DataTransfer(cmd, out read, _DataTransferTimeOut);
|
|
return read.ToLower().Contains("jlc");
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public override String Progress()
|
|
{
|
|
string sAddr = _Address.ToString();
|
|
string cmd;
|
|
string read;
|
|
|
|
//cmd = sAddr + ", MON?"; // See page 31
|
|
//DataTransfer(cmd, out read, _DataTransferTimeOut);
|
|
//Double T = Double.Parse(read.Split(',')[0]);
|
|
//Double RH = Double.Parse(read.Split(',')[1]);
|
|
|
|
cmd = sAddr + ", PRGM MON?"; // See page 35
|
|
DataTransfer(cmd, out read, _DataTransferTimeOut);
|
|
|
|
int step = Int32.Parse(read.Split(',')[1]) - 1;
|
|
Double Tset = Double.Parse(read.Split(',')[2]);
|
|
Double RHset = Double.Parse(read.Split(',')[3]);
|
|
string time = read.Split(',')[4];
|
|
int hrs = Int32.Parse(time.Split(':')[0]);
|
|
int min = Int32.Parse(time.Split(':')[1]);
|
|
int cyclesLeft = Int32.Parse(read.Split(',')[5]);
|
|
|
|
double stepTimeLeft = hrs * 60 + min;
|
|
double stepDuration = _Profile.SerializedStepList[step].DurationMin;
|
|
double stepRuntime = stepDuration - stepTimeLeft;
|
|
double pStep = Math.Min(100, Math.Floor(stepRuntime / stepDuration * 100));
|
|
|
|
double testRunTime = (_dtTestStart - DateTime.Now).TotalMinutes;
|
|
double pTest = Math.Min(100, Math.Floor(testRunTime / _Profile.DurationMin * 100));
|
|
|
|
double testTimeRemain = _Profile.DurationMin - testRunTime;
|
|
double testTimeRemainHrs = Math.Floor(testTimeRemain / 60);
|
|
double testTimeRemainMin = Math.Floor(testTimeRemain - 60 * testTimeRemainHrs);
|
|
|
|
string progress = String.Format("Step #{0:00}/{1:00} progress {2:0}%, ", step + 1, _Profile.SerializedStepList.Count, pStep);
|
|
progress += String.Format("remaining step time {0:0}h{1:00}m, remaining cycles {2:0}, ",hrs,min, cyclesLeft);
|
|
progress += String.Format("test progress {0:0}%, remaining test time {1:0}h{2:00}m", pTest, testTimeRemainHrs,testTimeRemainMin);
|
|
return progress;
|
|
}
|
|
|
|
|
|
|
|
private bool TxRxSucces(string cmd, string read)
|
|
{
|
|
// Command not correctly processed
|
|
if (read.StartsWith("NA:"))
|
|
return false;
|
|
|
|
// No response received
|
|
if (read.Trim().Length < 1)
|
|
return false;
|
|
|
|
// Handle monitoring commands
|
|
if (cmd.Trim().Contains("?"))
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
if(read.Trim().Contains("OK:"))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Performs transfer and adds interface logs to list in Client parent class
|
|
private Boolean DataTransfer(string cmd, out string read, int ReturnDataWaitms)
|
|
{
|
|
// If no maximum number of attempts is given, it defaults to 3.
|
|
return DataTransfer(cmd, out read, ReturnDataWaitms, 3);
|
|
}
|
|
|
|
|
|
// Performs transfer and adds interface logs to list in Client parent class
|
|
private Boolean DataTransfer(string cmd, out string read, int ReturnDataWaitms, int MaxNumOfAttempts)
|
|
{
|
|
// Construct command to send
|
|
cmd += (char)13; // CR
|
|
cmd += (char)10; // LF
|
|
cmd = cmd.Replace(" ", "");
|
|
|
|
|
|
// Wait for _ReadyToSend or max 2 seconds
|
|
DateTime go = DateTime.Now.AddSeconds(2);
|
|
while (DateTime.Now < _ReadyToSend && DateTime.Now < go)
|
|
System.Threading.Thread.Sleep(10);
|
|
|
|
read = "";
|
|
bool success = false;
|
|
int attempts = 0;
|
|
while (!success && attempts <= MaxNumOfAttempts)
|
|
{
|
|
DataTransferLog log = _Interface.DataTransfer(cmd, out read, ReturnDataWaitms);
|
|
success = TxRxSucces(cmd, read);
|
|
attempts++;
|
|
|
|
// Mask for showing in GUI
|
|
if (cmd.Contains("MODE?") || cmd.Contains("MON?"))
|
|
log.ShowInGUI = false;
|
|
|
|
// Notify user via GUI of failed attempts
|
|
if (attempts > 1)
|
|
log.Command += string.Format(" [Attempt {0:0}]", attempts);
|
|
|
|
// Add to logs
|
|
AppendDataTransferLog(log);
|
|
|
|
|
|
// Set _ReadyToSend acc. manual specs
|
|
if (cmd.Contains("?"))
|
|
_ReadyToSend = DateTime.Now.AddMilliseconds(300);
|
|
else
|
|
_ReadyToSend = DateTime.Now.AddMilliseconds(1000);
|
|
|
|
|
|
// Sleeps
|
|
if (!success)
|
|
System.Threading.Thread.Sleep(3000); // Sleep 3 seconds before resending if failed
|
|
}
|
|
return success;
|
|
}
|
|
|
|
|
|
}
|
|
}
|