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]; }