private void spanCalibrate()
{
byte[] result = null;
byte[] payload = { 0x00 };
while (spanCalibrationRunning)
{
result = QuattroProtocol.sendCommand(COMM_COMMAND_LIST.COMM_CMD_GET_GAS_READING, payload, ref err, 100);
if (err != ERROR_LIST.ERROR_NONE)
{
continue;
}
Dispatcher.BeginInvoke(new Action(() =>
{
tTxt_GasReading.Text = Utility.getF32FromByteA(result, offset + 1).ToString("N1");
if (tPbar_GasReading.Value < 20)
{
tPbar_GasReading.Value++;
}
}));
Thread.Sleep(1000);
}
}
/*
* Need Debug
*/
private void zeroCalibrateAccept()
{
if (zeroCalibrationRunning == false)
{
return;
}
byte[] payload0 = new byte[1];
payload0[0] = (byte)tCmb_CalibrationType.SelectedIndex;
float baseLineConcentrate = 0;
byte[] payload1 = Utility.getBytesFromF32(baseLineConcentrate);
payload0 = Utility.mergeByteArray(payload0, payload1);
byte[] result = QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_ACCEPT_ZERO_CAL, payload0, ref err, 400);
if (err == ERROR_LIST.ERROR_NCK)
{
MessageBox.Show("Failed in zeroing");
return;
}
if (err != ERROR_LIST.ERROR_NONE)
{
MessageBox.Show("ERROR - ZERO CLIBRATION");
return;
}
float zeroCalibrationFactor = Utility.getF32FromByteA(result, offset);
float gasReading = Utility.getF32FromByteA(result, offset + 4);
tTxt_ZeroCalibration.Text = gasReading.ToString("N1");
MessageBox.Show("Calculated Zero Factor: " + zeroCalibrationFactor.ToString("N2"));
}
public void spanCalibrationStop()
{
if (spanCal != null)
{
spanCalibrationRunning = false;
spanCal.Join();
QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_STOP_SPAN_CAL, ref err);
releaseOutput();
if (err == ERROR_LIST.ERROR_PORT_NOT_OPEN)
{
return;
}
if (err != ERROR_LIST.ERROR_NONE)
{
MessageBox.Show("ERROR - STOP SPAN CLIBRATION");
return;
}
}
tTabitem_CalType.IsEnabled = true;
tTabitem_TargetSpanGas.IsEnabled = true;
tTabItem_Zero.IsEnabled = true;
}
private void spanCalibrateAccept()
{
if (spanCalibrationRunning == false)
{
return;
}
/*
* Get data to accept span
*/
byte[] payload0 = new byte[1];
payload0[0] = (byte)tCmb_CalibrationType.SelectedIndex;
float targetSpan = 0;
try
{
targetSpan = float.Parse(tTxt_TargetSpanConc.Text);
}
catch
{
MessageBox.Show("ERROR - Span Calibration Parse");
return;
}
byte[] payload1 = Utility.getBytesFromF32(targetSpan);
payload0 = Utility.mergeByteArray(payload0, payload1);
byte[] payload2 = Utility.getBytesFromU16((ushort)INNCOM_CONF_LIST.GAS_PARAM_CORRECTION_FACTOR);
byte[] result = QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_READ_CONFIG, payload2, ref err, 200);
if (err != ERROR_LIST.ERROR_NONE)
{
MessageBox.Show("ERROR - Read Span Gas Data");
return;
}
byte[] sensitivity = new byte[4];
Array.Copy(result, offset + (int)INNCOM_CONF.SZ_PARAM_INDEX, sensitivity, 0, 4);
Utility.mergeByteArray(payload0, sensitivity);
/*
* Accept Span Cal
*/
result = QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_ACCEPT_SPAN_CAL, payload0, ref err, 400);
if (err == ERROR_LIST.ERROR_NCK)
{
MessageBox.Show("Failed in spaning");
return;
}
if (err != ERROR_LIST.ERROR_NONE)
{
MessageBox.Show("ERROR - ZERO CLIBRATION");
return;
}
float spanCalibrationFactor = Utility.getF32FromByteA(result, offset);
float gasReading = Utility.getF32FromByteA(result, offset + 4);
tTxt_GasReading.Text = gasReading.ToString("N1");
MessageBox.Show("Calculated Zero Factor: " + spanCalibrationFactor.ToString("N2"));
}
private void spanCalibrationStart()
{
setInhitbitOutput();
/*
* Stop Span Cal befor Start
*/
QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_STOP_SPAN_CAL, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
MessageBox.Show("ERROR - Span Calibration Start");
return;
}
/*
* Start Span Cal;
*/
byte[] payload0 = new byte[1];
payload0[0] = (byte)tCmb_CalibrationType.SelectedIndex;
float targetSpan = 0;
try
{
targetSpan = float.Parse(tTxt_TargetSpanConc.Text);
}
catch
{
MessageBox.Show("ERROR - Span Calibration Parse");
return;
}
byte[] payload1 = Utility.getBytesFromF32(targetSpan);
payload0 = Utility.mergeByteArray(payload0, payload1);
float targetsensitivitiy = 1;
payload1 = Utility.getBytesFromF32(targetsensitivitiy);
payload0 = Utility.mergeByteArray(payload0, payload1);
QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_START_SPAN_CAL, payload0, ref err, 200);
if (err != ERROR_LIST.ERROR_NONE)
{
MessageBox.Show("ERROR - Span Calibration Start");
return;
}
spanCalibrationRunning = true;
tTabitem_CalType.IsEnabled = false;
tTabitem_TargetSpanGas.IsEnabled = false;
tTabItem_Zero.IsEnabled = false;
tTab_GasCalibration.SelectedIndex = 3;
tPbar_GasReading.Maximum = 20;
tPbar_GasReading.Value = 0;
spanCal = new Thread(spanCalibrate);
spanCal.Start();
}
private void resetAlarmFaults()
{
QuattroProtocol.sendCommand(COMM_COMMAND_LIST.COMM_CMD_RESET_ALARMS, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
MessageBox.Show("ERROR - Reset Alarms and Faults");
return;
}
MessageBox.Show("Succesfully Reset Alarms and Faults");
}
public bool setInhitbitOutput()
{
QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_INHIBIT_OUTPUT, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
return(false);
}
return(true);
}
private void zeroCalibrationStart()
{
/*
* Check Sensor Gas Type
*/
byte[] result = QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_READ_SENSOR_INFO, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
MessageBox.Show("ERROR - Gas Calibration Start");
return;
}
byte gasType = result[offset + 1];
if (gasType == (byte)GAS_TYPE.O2)
{
MessageBox.Show("O2 Sensor Does not need zero calibration");
setInhitbitOutput();
return;
}
/*
* Stop Zero Cal befor Start
*/
QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_STOP_ZERO_CAL, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
MessageBox.Show("ERROR - Gas Calibration Start");
return;
}
/*
* Start Zero Cal;
*/
byte[] payload0 = new byte[1];
payload0[0] = (byte)tCmb_CalibrationType.SelectedIndex;
float baseLineConcentrate = 0;
byte[] payload1 = Utility.getBytesFromF32(baseLineConcentrate);
payload0 = Utility.mergeByteArray(payload0, payload1);
QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_START_ZERO_CAL, payload0, ref err, 200);
if (err != ERROR_LIST.ERROR_NONE)
{
MessageBox.Show("ERROR - Gas Calibration Start");
return;
}
zeroCalibrationRunning = true;
tTabitem_CalType.IsEnabled = false;
tTabitem_TargetSpanGas.IsEnabled = false;
tTabitem_SpanCalibration.IsEnabled = false;
tTab_GasCalibration.SelectedIndex = 1;
}
public bool releaseOutput()
{
QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_RELEASE_OUTPUT, ref err, 200);
if (err == ERROR_LIST.ERROR_PORT_NOT_OPEN)
{
return(false);
}
if (err != ERROR_LIST.ERROR_NONE)
{
return(false);
}
return(true);
}
private void resetAlarmFault()
{
/*
* Reset Alarms and Faults
*/
QuattroProtocol.sendCommand(COMM_COMMAND_LIST.COMM_CMD_RESET_ALARMS, ref err, 1500);
if (err != ERROR_LIST.ERROR_NONE)
{
tTxt_Logs.AppendText("ERROR - Reset Alarms and Faults");
tTxt_Logs.AppendText(Environment.NewLine);
return;
}
tTxt_Logs.AppendText("Reset Alarms and Faults : OK");
tTxt_Logs.AppendText(Environment.NewLine);
}
private void resetToFactory()
{
/*
* Reset To Factory
*/
QuattroProtocol.sendCommand(COMM_COMMAND_LIST.COMM_CMD_RESET_FACTORY, ref err, 500);
if (err != ERROR_LIST.ERROR_NONE)
{
tTxt_Logs.AppendText("ERROR - Reset To Factory");
tTxt_Logs.AppendText(Environment.NewLine);
return;
}
tTxt_Logs.AppendText("Reset To Factory : OK");
tTxt_Logs.AppendText(Environment.NewLine);
}
private void setTime()
{
Dispatcher.BeginInvoke(new Action(() =>
{
tBtn_SetTime.IsEnabled = false;
tBtn_ReadTime.IsEnabled = false;
byte[] timeToSend = new byte[7];
DateTime setDate = tDate_DatePicker.SelectedDate.Value;
DateTime setTime = (DateTime)tTime_TimePicker.Value;
int year = setDate.Year;
timeToSend[0] = (byte)(year >> 8);
timeToSend[1] = (byte)year;
timeToSend[2] = (byte)setDate.Month;
timeToSend[3] = (byte)setDate.Day;
timeToSend[4] = (byte)setTime.Hour;
timeToSend[5] = (byte)setTime.Minute;
timeToSend[6] = (byte)setTime.Second;
QuattroProtocol.sendCommand(COMM_COMMAND_LIST.COMM_CMD_WRITE_TIME, timeToSend, ref err, 300);
if (err == ERROR_LIST.ERROR_NONE)
{
tTxt_Memo1.AppendText("Successfully wrote the datetime");
}
else
{
tTxt_Memo1.AppendText("ERROR - WRITE TIME");
tTxt_Memo1.AppendText(Environment.NewLine);
tTxt_Memo1.AppendText(err.ToString());
}
tTxt_Memo1.AppendText(Environment.NewLine);
}));
Thread.Sleep(500);
Dispatcher.BeginInvoke(new Action(() =>
{
tBtn_ReadTime.IsEnabled = true;
tBtn_SetTime.IsEnabled = true;
}));
}
private void clearAllLatchedTable()
{
/*
* Clear Latch tables
*/
byte[] payload = new byte[1];
payload[0] = (byte)(tCmb_LatchedType.SelectedIndex + 1);
byte[] result = QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_CLR_LATCHED_TABLES, payload, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
tTxt_Logs.AppendText("ERROR - Clear Latch Tables");
tTxt_Logs.AppendText(Environment.NewLine);
return;
}
tTxt_Logs.AppendText("Cleared Latch Table : " + result[(int)PACKET_CONF.COMM_POS_PAYLOAD + 2].ToString());
tTxt_Logs.AppendText(Environment.NewLine);
}
private void readTime()
{
/*
* Read Time
*/
byte[] u8RXbuffer = QuattroProtocol.sendCommand(COMM_COMMAND_LIST.COMM_CMD_READ_TIME, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
tTxt_Memo1.AppendText("ERROR - READ TIME");
tTxt_Memo1.AppendText(Environment.NewLine);
return;
}
try
{
int year = (int)u8RXbuffer[(int)PACKET_CONF.COMM_POS_PAYLOAD + 3] << 8 | (int)(u8RXbuffer[(int)PACKET_CONF.COMM_POS_PAYLOAD + 4]);
int month = u8RXbuffer[(int)PACKET_CONF.COMM_POS_PAYLOAD + 5];
int day = u8RXbuffer[(int)PACKET_CONF.COMM_POS_PAYLOAD + 6];
int hour = u8RXbuffer[(int)PACKET_CONF.COMM_POS_PAYLOAD + 7];
int minute = u8RXbuffer[(int)PACKET_CONF.COMM_POS_PAYLOAD + 8];
int second = u8RXbuffer[(int)PACKET_CONF.COMM_POS_PAYLOAD + 9];
if (!Utility.isTimeCheck(year, month, day, hour, minute, second))
{
tTxt_Memo1.AppendText("ERROR - READ TIME");
tTxt_Memo1.AppendText(Environment.NewLine);
return;
}
DateTime readingTime = new DateTime(year, month, day, hour, minute, second);
tDate_DatePicker.SelectedDate = readingTime;
tTime_TimePicker.Value = readingTime;
}
catch (IndexOutOfRangeException)
{
tTxt_Memo1.AppendText("ERROR - READ TIME - INDEX OUT RANGE");
tTxt_Memo1.AppendText(Environment.NewLine);
return;
}
}
private void readDeviceSatus()
{
/*
* Read Device Status
*/
byte[] u8RXbuffer = QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_READ_DEVICE_STATUS, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
tTxt_Memo1.AppendText("ERROR - READ INCOM STATUS");
tTxt_Memo1.AppendText(Environment.NewLine);
return;
}
updateDataGrid(u8RXbuffer, instrument_status_grid_data, instrument_status_grid_data_list, InstrumentStatus);
/*
* Read Warning Status
*/
byte[] cmd_ReadFaultOption = { 0x01 };
u8RXbuffer = QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_READ_FAULT_DETAILS, cmd_ReadFaultOption, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
tTxt_Memo1.AppendText("ERROR : READ WARNING DETAILS");
tTxt_Memo1.AppendText(Environment.NewLine);
return;
}
updateDataGrid(u8RXbuffer, warning_status_grid_data, warning_status_grid_data_list, WarningStatus);
/*
* Read Fault Status
*/
cmd_ReadFaultOption[0] = 0x02;
u8RXbuffer = QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_READ_FAULT_DETAILS, cmd_ReadFaultOption, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
tTxt_Memo1.AppendText("ERROR : READ FAULT DETAILS");
tTxt_Memo1.AppendText(Environment.NewLine);
return;
}
updateDataGrid(u8RXbuffer, fault_status_grid_data, fault_status_grid_data_list, FaultStatus);
}
private void writeDeviceSN()
{
/*
* Write Device SN
*/
byte[] serialNumber = Encoding.Default.GetBytes(tTxt_DeviceSerialNumber.Text);
if (serialNumber.Length < 16)
{
byte[] ret = new byte[16 - serialNumber.Length];
serialNumber = Utility.mergeByteArray(serialNumber, ret);
}
QuattroProtocol.sendCommand(COMM_COMMAND_LIST.COMM_CMD_WRITE_DEVICE_SN, serialNumber, ref err, 300);
if (err != ERROR_LIST.ERROR_NONE)
{
tTxt_Logs.AppendText("ERROR - Write Device SN");
tTxt_Logs.AppendText(Environment.NewLine);
return;
}
tTxt_Logs.AppendText("Wrote Device SN Successfully");
tTxt_Logs.AppendText(Environment.NewLine);
}
public void zeroCalibrationStop()
{
if (zeroCal != null)
{
zeroCalibrationRunning = false;
zeroCal.Join();
QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_STOP_ZERO_CAL, ref err);
releaseOutput();
if (err == ERROR_LIST.ERROR_PORT_NOT_OPEN)
{
return;
}
if (err != ERROR_LIST.ERROR_NONE)
{
MessageBox.Show("ERROR - STOP ZERO CLIBRATION");
return;
}
}
tTabitem_CalType.IsEnabled = true;
tTabitem_TargetSpanGas.IsEnabled = true;
tTabitem_SpanCalibration.IsEnabled = true;
tTab_GasCalibration.SelectedIndex = 0;
}
public void getBLEInfo()
{
/*
* Read BLE Name
*/
byte[] result = QuattroProtocol.sendCommand(COMM_COMMAND_LIST.COMM_CMD_GET_BLE_DEVICE_NAME, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
tTxt_BLEInfo.AppendText("ERROR - Read BLE Name");
tTxt_BLEInfo.AppendText(Environment.NewLine);
return;
}
string BLEname = Encoding.Default.GetString(QuattroProtocol.getResponseValueData(result)).Trim('\0');
tTxt_BLEInfo.AppendText("BLE Device Name : " + BLEname);
tTxt_BLEInfo.AppendText(Environment.NewLine);
tTxt_BLEDeviceName.Text = BLEname;
/*
* Read BLE Mac Address
*/
result = QuattroProtocol.sendCommand(COMM_COMMAND_LIST.COMM_CMD_GET_BLE_MAC_ADDR, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
tTxt_BLEInfo.AppendText("ERROR - Read BLE Mac Addreess");
tTxt_BLEInfo.AppendText(Environment.NewLine);
return;
}
string BLEMacAddr = BitConverter.ToString(QuattroProtocol.getResponseValueData(result)).Replace("-", ":");
tTxt_BLEInfo.AppendText("BLE MAC Address : " + BLEMacAddr);
tTxt_BLEInfo.AppendText(Environment.NewLine);
tTxt_BLEMacAddress.Text = BLEMacAddr;
/*
* Read BLE SW Version
*/
result = QuattroProtocol.sendCommand(COMM_COMMAND_LIST.COMM_CMD_GET_BLE_SW_VER, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
tTxt_BLEInfo.AppendText("ERROR - Read BLE SW Version");
tTxt_BLEInfo.AppendText(Environment.NewLine);
return;
}
string BLESWVersion = Encoding.Default.GetString(QuattroProtocol.getResponseValueData(result)).Trim('\0');
tTxt_BLEInfo.AppendText("BLE SW Version : " + BLESWVersion);
tTxt_BLEInfo.AppendText(Environment.NewLine);
tTxt_BLESWVersion.Text = BLESWVersion;
/*
* Read BLE TX Power
*/
result = QuattroProtocol.sendCommand(COMM_COMMAND_LIST.COMM_CMD_GET_BLE_TX_POWER, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
tTxt_BLEInfo.AppendText("ERROR - Read BLE TW Power");
tTxt_BLEInfo.AppendText(Environment.NewLine);
return;
}
byte BLETXPower = result[(int)PACKET_CONF.COMM_POS_PAYLOAD + 3];
tTxt_BLEInfo.AppendText("BLE TX Power : " + BLETXPower);
tTxt_BLEInfo.AppendText(Environment.NewLine);
tTxt_BLETXPower.Text = BLETXPower.ToString();
/*
* Read BLE Instrument ID
*/
result = QuattroProtocol.sendCommand(COMM_COMMAND_LIST.COMM_CMD_GET_BLE_INST_ID, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
tTxt_BLEInfo.AppendText("ERROR - Read Instrument ID");
tTxt_BLEInfo.AppendText(Environment.NewLine);
return;
}
string BLEInstID = BitConverter.ToString(QuattroProtocol.getResponseValueData(result)).Replace("-", ":");
tTxt_BLEInfo.AppendText("BLE Instrument Id : " + BLEInstID);
tTxt_BLEInfo.AppendText(Environment.NewLine);
tTxt_BLEInstID.Text = BLEInstID;
}
private void tabSelectControl()
{
if (tTabItem_Zero == null)
{
return;
}
if (tTabitem_TargetSpanGas == null)
{
return;
}
if (tTabItem_Zero.IsSelected)
{
if (zeroCalibrationRunning)
{
zeroCal = new Thread(zeroCalibrate);
zeroCal.Start();
}
}
if (tTabitem_TargetSpanGas.IsSelected)
{
/*
* Read Sensor Info
*/
byte[] result = QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_READ_SENSOR_INFO, ref err);
if (err == ERROR_LIST.ERROR_PORT_NOT_OPEN)
{
return;
}
if (err != ERROR_LIST.ERROR_NONE)
{
MessageBox.Show("ERROR - Read Span Gas Sensor");
return;
}
byte gasType = result[offset + 1];
/*
* read target span gas
*/
byte[] payload = Utility.getBytesFromU16((ushort)INNCOM_CONF_LIST.CAL_PARAM_CAL_CONC);
result = QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_READ_CONFIG, payload, ref err, 200);
if (err != ERROR_LIST.ERROR_NONE)
{
MessageBox.Show("ERROR - Read Span Gas Data");
return;
}
float CalCon = Utility.getF32FromByteA(result, offset + (int)INNCOM_CONF.SZ_PARAM_INDEX);
tTxt_TargetSpanConc.Text = CalCon.ToString("N1");
payload = Utility.getBytesFromU16((ushort)INNCOM_CONF_LIST.GAS_PARAM_MEASURING_RANGE);
result = QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_READ_CONFIG, payload, ref err, 200);
if (err != ERROR_LIST.ERROR_NONE)
{
MessageBox.Show("ERROR - Read Span Gas Data");
return;
}
float measuringRange = Utility.getF32FromByteA(result, offset + (int)INNCOM_CONF.SZ_PARAM_INDEX);
string str = "";
if (gasType == (int)GAS_TYPE.O2)
{
str = " Configuralbe Target Calibration Conc. : " + (0.7 * measuringRange).ToString("N1") + " ~ " + (0.9 * measuringRange).ToString("N1");
}
else
{
str = " Configuralbe Target Calibration Conc. : " + (0.3 * measuringRange).ToString("N1") + " ~ " + (0.7 * measuringRange).ToString("N1");
}
tTxt_TargetSpanRange.Text = str;
}
}
private string getDeviceVersion()
{
string str = "";
/*
* Read Device SN
*/
byte[] result = QuattroProtocol.sendCommand(COMM_COMMAND_LIST.COMM_CMD_READ_DEVICE_SN, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
MessageBox.Show("ERROR - Read Device SN");
return(null);
}
string DeviceSN = Encoding.Default.GetString(QuattroProtocol.getResponseValueData(result)).Trim('\0');
str += "DeviceSN : " + DeviceSN + ",";
/*
* Read SW Version
*/
result = QuattroProtocol.sendCommand(COMM_COMMAND_LIST.COMM_CMD_READ_SW_VERSION, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
MessageBox.Show("ERROR - Read SW Version");
return(null);
}
int offset = (int)PACKET_CONF.COMM_POS_PAYLOAD + 3;
int major = result[offset];
int minor = result[offset + 1];
int built = Utility.getU16FromByteA(result, offset + 2);
tTxt_FirmVersion.Text = major.ToString() + "." + minor.ToString() + "." + built.ToString();
str += "SW Version : " + major.ToString() + "." + minor.ToString() + "." + built.ToString() + ",";
/*
* Read EEPROM Version
*/
result = QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_READ_EEPROM_VER, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
MessageBox.Show("ERROR - Read EERPOM Version");;
return(null);
}
byte E2PVer = result[(int)PACKET_CONF.COMM_POS_PAYLOAD + 3];
tTxt_SensorDataVersion.Text = E2PVer.ToString();
str += "EEPROM : " + E2PVer.ToString() + ",";
/*
* Read Output Type
*/
result = QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_READ_OUTPUT_DEVICE_TYPE, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
MessageBox.Show("ERROR - Read Board SN");
return(null);
}
offset = (int)PACKET_CONF.COMM_POS_PAYLOAD + (int)PACKET_CONF.COMM_RESPONSE_SZ;
int OutputType = result[offset];
int Relay = result[offset + 1];
int BLEModule = result[offset + 2];
if (OutputType == 0)
{
str += "OutPut Type : mA Output,";
}
else
{
str += "OutPut Type : Modbus,";
}
if (Relay == 0)
{
str += "Relay : Not Fitted,";
}
else
{
str += "Relay : Fitted,";
}
if (BLEModule == 0)
{
str += "BLE : Not Fitted";
}
else
{
str += "BLE : Not Fitted";
}
return(str);
}
private string getGasData()
{
DateTime curr_Time = DateTime.Now;
string date_time_str = curr_Time.ToString("yyyy/MM/dd HH:mm:ss");
string time_str = curr_Time.ToString("HH:mm:ss");
/*
* read Raw data
*/
byte[] gas_raw_data_buffer = QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_READ_RAW_GAS_DATA, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
return(null);
}
int raw_adc = Utility.getS32FromByteA(gas_raw_data_buffer, offset + 0);
float cell_output = Utility.getF32FromByteA(gas_raw_data_buffer, offset + 4);
float primary_conc = Utility.getF32FromByteA(gas_raw_data_buffer, offset + 8);
float linear_conc = Utility.getF32FromByteA(gas_raw_data_buffer, offset + 12);
float deadband_conc = Utility.getF32FromByteA(gas_raw_data_buffer, offset + 16);
float display_conc = Utility.getF32FromByteA(gas_raw_data_buffer, offset + 20);
int raw_temp = Utility.getS32FromByteA(gas_raw_data_buffer, offset + 24);
int temp = Utility.getS32FromByteA(gas_raw_data_buffer, offset + 28);
uint fault_state = Utility.getU32FromByteA(gas_raw_data_buffer, offset + 32);
uint warning_state = Utility.getU32FromByteA(gas_raw_data_buffer, offset + 36);
byte alarm_state = gas_raw_data_buffer[offset + 40];
/*
* Read Voltage Output Data
*/
byte[] gas_voltage_output_buffer = QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_READ_VOLTAGE_OUTPUT, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
return(null);
}
float target_analouge_output = Utility.getF32FromByteA(gas_voltage_output_buffer, offset);
float measured_lop_back_current = Utility.getF32FromByteA(gas_voltage_output_buffer, offset + 4);
/*
* Read Analogue Output Data
*/
byte[] gas_analouge_output_buffer = QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_READ_ANALOGUE_OUTPUT, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
return(null);
}
byte ma_output_type = gas_analouge_output_buffer[offset];
float target_output = Utility.getF32FromByteA(gas_analouge_output_buffer, offset + 1);
float loop_back = Utility.getF32FromByteA(gas_analouge_output_buffer, offset + 5);
Dispatcher.BeginInvoke(new Action(() =>
{
gas_data_update(tGrid_GasData, gridGasDataList, m_chart1, time_str, raw_adc, cell_output, primary_conc, linear_conc, deadband_conc,
display_conc, raw_temp, temp, fault_state, warning_state, alarm_state, target_analouge_output, measured_lop_back_current, target_output, loop_back);
if (fault_state != 0)
{
tTxt_FaultStatus.Content = "Fault";
tTxt_FaultStatus.Foreground = Brushes.Red;
}
if (warning_state != 0)
{
tTxt_WarningStatus.Content = "Fault";
tTxt_WarningStatus.Foreground = Brushes.Red;
}
if (alarm_state != 0)
{
tTxt_AlarmStatus.Content = "Fault";
tTxt_AlarmStatus.Foreground = Brushes.Red;
}
}
));
string gas_data = date_time_str + string.Format(",{0},{1:0.000},{2:0.000},{3:0.000}," +
"{4:0.000},{5:0.000},{6},{7}," +
"{8},{9},{10},{11:0.000}," +
"{12:0.000},{13:0.000},{14:0.000}", raw_adc, cell_output, primary_conc, linear_conc, deadband_conc,
display_conc, raw_temp, temp, fault_state, warning_state, alarm_state, target_analouge_output,
measured_lop_back_current, target_output, loop_back
);
return(gas_data);
}
private void readConfiguartion()
{
/*
* Read Configuration
*/
INNCOM_CONF_LIST param = (INNCOM_CONF_LIST)tCmb_Param.SelectedItem;
byte[] result = QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_READ_CONFIG, DeviceConfiguration.configurationToByteArray(param), ref err, 300);
if (err != ERROR_LIST.ERROR_NONE)
{
tTxt_Logs.AppendText("ERROR - Read Configurations");
tTxt_Logs.AppendText(Environment.NewLine);
return;
}
int offset = (int)PACKET_CONF.COMM_POS_PAYLOAD + 3;
byte[] value = QuattroProtocol.getResponseValueData(result);
int type = result[offset];
byte[] IDA = new byte[2];
Array.Copy(value, 0, IDA, 0, 2);
string ID = BitConverter.ToString(IDA).Replace("-", string.Empty);
byte[] ParamValue = new byte[value.Length - IDA.Length];
Array.Copy(value, IDA.Length, ParamValue, 0, value.Length - IDA.Length);
string str = "";
switch (type)
{
case (int)PARAMETER_TYPE.PARAM_TYPE_STR:
{
str = Encoding.Default.GetString(ParamValue).Trim('\0');
break;
};
case (int)PARAMETER_TYPE.PARAM_TYPE_U8:
{
str = (ParamValue, 0).ToString();
break;
}
case (int)PARAMETER_TYPE.PARAM_TYPE_U8A:
{
str = Encoding.Default.GetString(ParamValue).Trim('\0');
break;
}
case (int)PARAMETER_TYPE.PARAM_TYPE_S8:
{
str = Convert.ToSByte(ParamValue[0]).ToString();
break;
}
case (int)PARAMETER_TYPE.PARAM_TYPE_U32:
{
if (ParamValue.Length < 4)
{
byte[] temp = new byte[4 - ParamValue.Length];
ParamValue = Utility.mergeByteArray(temp, ParamValue);
}
str = Utility.getU32FromByteA(ParamValue, 0).ToString();
break;
}
case (int)PARAMETER_TYPE.PARAM_TYPE_U16:
{
if (ParamValue.Length == 1)
{
byte[] temp = new byte[1];
ParamValue = Utility.mergeByteArray(temp, ParamValue);
}
str = Utility.getU16FromByteA(ParamValue, 0).ToString();
break;
}
case (int)PARAMETER_TYPE.PARAM_TYPE_F32:
{
if (ParamValue.Length < 4)
{
byte[] temp = new byte[4 - ParamValue.Length];
ParamValue = Utility.mergeByteArray(temp, ParamValue);
}
str = Utility.getF32FromByteA(ParamValue, 0).ToString();
break;
}
default:
{
str = BitConverter.ToString(ParamValue).Replace("-", string.Empty);
break;
}
}
tTxt_Logs.AppendText("Parameter ID : 0x" + ID + " , Value : " + str);
tTxt_Logs.AppendText(Environment.NewLine);
}
public void readDeviceInfo()
{
/*
* Read SW Version
*/
byte[] result = QuattroProtocol.sendCommand(COMM_COMMAND_LIST.COMM_CMD_READ_SW_VERSION, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
tTxt_Logs.AppendText("ERROR - Read SW Version");
tTxt_Logs.AppendText(Environment.NewLine);
return;
}
int offset = (int)PACKET_CONF.COMM_POS_PAYLOAD + (int)PACKET_CONF.COMM_RESPONSE_SZ;
int major = result[offset];
int minor = result[offset + 1];
int built = Utility.getU16FromByteA(result, offset + 2);
string SWVersion = major.ToString() + "." + minor.ToString() + "." + built.ToString();
tTxt_Logs.AppendText("Device SW Version : " + SWVersion);
tTxt_Logs.AppendText(Environment.NewLine);
tTxt_DeviceSWVersion.Text = SWVersion;
/*
* Read EEPROM Version
*/
result = QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_READ_EEPROM_VER, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
tTxt_Logs.AppendText("ERROR - Read EERPOM Version");
tTxt_Logs.AppendText(Environment.NewLine);
return;
}
byte E2PVer = result[(int)PACKET_CONF.COMM_POS_PAYLOAD + 3];
tTxt_Logs.AppendText("SENSOR EEPROM : " + E2PVer);
tTxt_Logs.AppendText(Environment.NewLine);
tTxt_SensorEEPROM.Text = E2PVer.ToString();
/*
* Read Device SN
*/
result = QuattroProtocol.sendCommand(COMM_COMMAND_LIST.COMM_CMD_READ_DEVICE_SN, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
tTxt_Logs.AppendText("ERROR - Read Device SN");
tTxt_Logs.AppendText(Environment.NewLine);
return;
}
string DeviceSN = Encoding.Default.GetString(QuattroProtocol.getResponseValueData(result)).Trim('\0');
tTxt_Logs.AppendText("Device SN : " + DeviceSN);
tTxt_Logs.AppendText(Environment.NewLine);
tTxt_DeviceSerialNumber.Text = DeviceSN;
/*
* Read Output Type
*/
result = QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_READ_OUTPUT_DEVICE_TYPE, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
tTxt_Logs.AppendText("ERROR - Read Board SN");
tTxt_Logs.AppendText(Environment.NewLine);
return;
}
offset = (int)PACKET_CONF.COMM_POS_PAYLOAD + (int)PACKET_CONF.COMM_RESPONSE_SZ;
int OutputType = result[offset];
int Relay = result[offset + 1];
int BLEModule = result[offset + 2];
tTxt_Logs.AppendText("Output Type : " + OutputType);
tTxt_Logs.AppendText(Environment.NewLine);
tTxt_Logs.AppendText("Relay Type: " + Relay);
tTxt_Logs.AppendText(Environment.NewLine);
tTxt_Logs.AppendText("BLE Fitted : " + BLEModule);
tTxt_Logs.AppendText(Environment.NewLine);
if (OutputType == 0)
{
tTxt_OutputDeviceType.Text = "mA Output";
}
else
{
tTxt_OutputDeviceType.Text = "Modbus";
}
if (Relay == 0)
{
tTxt_RealyOption.Text = "Not Fitted";
}
else
{
tTxt_RealyOption.Text = "Fitted";
}
if (BLEModule == 0)
{
tTxt_BLEModule.Text = "Not Fitted";
}
else
{
tTxt_BLEModule.Text = "Fitted";
}
/*
* Read Sensor Info
*/
result = QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_READ_SENSOR_INFO, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
tTxt_Logs.AppendText("ERROR - Read Sensor Information");
tTxt_Logs.AppendText(Environment.NewLine);
return;
}
offset = (int)PACKET_CONF.COMM_POS_PAYLOAD + (int)PACKET_CONF.COMM_RESPONSE_SZ;
int sensorType = result[offset];
int gasType = result[offset + 1];
int cellID = result[offset + 2];
switch (sensorType)
{
case (int)SENSOR_TPYE.ECC:
{
tTxt_SensorType.Text = "ECC";
break;
}
case (int)SENSOR_TPYE.FL_CAT:
{
tTxt_SensorType.Text = "FLM CAT";
break;
}
case (int)SENSOR_TPYE.IR:
{
tTxt_SensorType.Text = "IR";
break;
}
case (int)SENSOR_TPYE.PID:
{
tTxt_SensorType.Text = "PID";
break;
}
case (int)SENSOR_TPYE.MOS:
{
tTxt_SensorType.Text = "MOS";
break;
}
default:
{
tTxt_SensorType.Text = "N/A";
break;
}
}
switch (gasType)
{
case (int)GAS_TYPE.FLAMMABLE:
{
tTxt_GasType.Text = "Flammable";
break;
}
case (int)GAS_TYPE.TOXIC:
{
tTxt_GasType.Text = "Toxic";
break;
}
case (int)GAS_TYPE.O2:
{
tTxt_GasType.Text = "O2";
break;
}
case (int)GAS_TYPE.VOC:
{
tTxt_GasType.Text = "VOC";
break;
}
default:
{
tTxt_GasType.Text = "N/A";
break;
}
}
tCmb_CellID.SelectedIndex = cellID;
tTxt_Logs.AppendText("Sensor Type : " + sensorType);
tTxt_Logs.AppendText(Environment.NewLine);
tTxt_Logs.AppendText("Gas Type: " + gasType);
tTxt_Logs.AppendText(Environment.NewLine);
tTxt_Logs.AppendText("Cell ID : " + cellID);
tTxt_Logs.AppendText(Environment.NewLine);
/*
* Read Gas Info
*/
byte[] channelByte = { 0x00 };
result = QuattroProtocol.sendCommand(COMM_COMMAND_LIST.COMM_CMD_READ_GAS_INFO, channelByte, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
tTxt_Logs.AppendText("ERROR - Read Gas Information");
tTxt_Logs.AppendText(Environment.NewLine);
return;
}
offset = (int)PACKET_CONF.COMM_POS_PAYLOAD + (int)PACKET_CONF.COMM_RESPONSE_SZ;
int channel = result[offset];
int measurementUnit = result[offset + 1];
int resolution = result[offset + 2];
float fullScale = Utility.getF32FromByteA(result, offset + 3);
tTxt_Channel.Text = channel.ToString();
switch (measurementUnit)
{
case 0:
{
tTxt_MeasuremetUnits.Text = "blank";
break;
}
case 1:
{
tTxt_MeasuremetUnits.Text = "%LEL";
break;
}
case 2:
{
tTxt_MeasuremetUnits.Text = "mA";
break;
}
case 3:
{
tTxt_MeasuremetUnits.Text = "mg/m3";
break;
}
case 4:
{
tTxt_MeasuremetUnits.Text = "g/m3";
break;
}
case 5:
{
tTxt_MeasuremetUnits.Text = "%Vol";
break;
}
case 6:
{
tTxt_MeasuremetUnits.Text = "ppm";
break;
}
case 7:
{
tTxt_MeasuremetUnits.Text = "kppm";
break;
}
case 8:
{
tTxt_MeasuremetUnits.Text = "LEL.m";
break;
}
case 9:
{
tTxt_MeasuremetUnits.Text = "A";
break;
}
case 10:
{
tTxt_MeasuremetUnits.Text = "dB";
break;
}
case 11:
{
tTxt_MeasuremetUnits.Text = "dBA";
break;
}
case 12:
{
tTxt_MeasuremetUnits.Text = "ppm.m";
break;
}
default:
{
tTxt_MeasuremetUnits.Text = "";
break;
}
}
switch (resolution)
{
case 0:
{
tTxt_DecimalPlace.Text = "1 " + tTxt_MeasuremetUnits.Text;
break;
}
case 1:
{
tTxt_DecimalPlace.Text = "0.1 " + tTxt_MeasuremetUnits.Text;
break;
}
case 2:
{
tTxt_DecimalPlace.Text = "0.01 " + tTxt_MeasuremetUnits.Text;
break;
}
case 3:
{
tTxt_DecimalPlace.Text = "0.001 " + tTxt_MeasuremetUnits.Text;
break;
}
default:
{
tTxt_DecimalPlace.Text = "1 " + tTxt_MeasuremetUnits.Text;
resolution = 0;
break;
}
}
double DfullScale = Math.Round(fullScale, resolution);
tTxt_FullScaleRange.Text = DfullScale.ToString() + " " + tTxt_MeasuremetUnits.Text;
tTxt_Logs.AppendText("Channel : " + channel);
tTxt_Logs.AppendText(Environment.NewLine);
tTxt_Logs.AppendText("Measurement Unit: " + measurementUnit);
tTxt_Logs.AppendText(Environment.NewLine);
tTxt_Logs.AppendText("Decimal Point : " + resolution);
tTxt_Logs.AppendText(Environment.NewLine);
tTxt_Logs.AppendText("Full Scale : " + DfullScale);
tTxt_Logs.AppendText(Environment.NewLine);
}
private void readSwitchStatus()
{
/*
* Read Switch Status
*/
byte[] u8RXbuffer = QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_READ_SWITCH_STATUS, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
tTxt_Memo1.AppendText("ERROR - READ SWITCH STATUS");
tTxt_Memo1.AppendText(Environment.NewLine);
return;
}
switch (u8RXbuffer[(int)PACKET_CONF.COMM_POS_PAYLOAD + (int)PACKET_CONF.COMM_RESPONSE_SZ])
{
case (int)SWITCH_PRESSED.ALL_NOT_PRESSED:
{
tCmb_UpButton.SelectedIndex = 0;
tCmb_DownButton.SelectedIndex = 0;
break;
}
case (int)SWITCH_PRESSED.UP_PRESSED:
{
tCmb_UpButton.SelectedIndex = 0;
tCmb_DownButton.SelectedIndex = 1;
break;
}
case (int)SWITCH_PRESSED.DOWN_PRESSED:
{
tCmb_UpButton.SelectedIndex = 1;
tCmb_DownButton.SelectedIndex = 0;
break;
}
case (int)SWITCH_PRESSED.ALL_PRESSED:
{
tCmb_UpButton.SelectedIndex = 1;
tCmb_DownButton.SelectedIndex = 1;
break;
}
default:
{
break;
}
}
/*
* Read Inhibit Switch
*/
u8RXbuffer = QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_READ_INHIBIT_SWITCH, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
tTxt_Memo1.AppendText("ERROR - READ INHIBIT SWITCH STATUS");
tTxt_Memo1.AppendText(Environment.NewLine);
return;
}
if (u8RXbuffer[(int)PACKET_CONF.COMM_POS_PAYLOAD + 3] < 2)
{
tCmb_InhibitSwitch.SelectedIndex = u8RXbuffer[u8RXbuffer.Length - 4];
}
/*
* Read SInk/Source Switch
*/
u8RXbuffer = QuattroProtocol.sendCommand(INNCOM_COMMAND_LIST.COMM_CMD_READ_ANALOGUE_OUTPUT, ref err);
if (err != ERROR_LIST.ERROR_NONE)
{
tTxt_Memo1.AppendText("ERROR - READ ANLOGUE TYPE");
tTxt_Memo1.AppendText(Environment.NewLine);
return;
}
tCmb_SinkSourceSwitchs.SelectedIndex = u8RXbuffer[(int)PACKET_CONF.COMM_POS_PAYLOAD + 3];
}
