656 lines
26 KiB
C#
656 lines
26 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Data;
|
|
using System.Drawing;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using System.Threading;
|
|
using System.Text.RegularExpressions;
|
|
using Maser.Palantir.Model;
|
|
using System.IO;
|
|
|
|
namespace HTOLHAST
|
|
{
|
|
public partial class Form1 : Form
|
|
{
|
|
public int PositionIncrement
|
|
{
|
|
get
|
|
{
|
|
int result;
|
|
if (int.TryParse(tbPositionIncrement.Text, out result))
|
|
{
|
|
return result;
|
|
}
|
|
else
|
|
{
|
|
// Handle the case where the conversion fails
|
|
throw new FormatException("Invalid input for PAMMaxCurrent.");
|
|
}
|
|
}
|
|
set
|
|
{
|
|
tbPositionIncrement.Text = value.ToString();
|
|
}
|
|
}
|
|
public int CurrentPosition
|
|
{
|
|
get
|
|
{
|
|
int result;
|
|
if (int.TryParse(tbCurrentPosition.Text, out result))
|
|
{
|
|
return result;
|
|
}
|
|
else
|
|
{
|
|
// Handle the case where the conversion fails
|
|
throw new FormatException("Invalid input for PAMMaxCurrent.");
|
|
}
|
|
}
|
|
set
|
|
{
|
|
tbCurrentPosition.Text = value.ToString();
|
|
}
|
|
}
|
|
|
|
HMP4040 PSU1;
|
|
HMP4040 PSU2;
|
|
Keithley6485 PAM;
|
|
Agilent34970a DAQ;
|
|
Project Project;
|
|
List<SwitchMatrix> switchMatrix;
|
|
List<PowerUpSequence> powerUpSequences;
|
|
List<PowerUpSequence> powerDownSequences;
|
|
|
|
BindingList<Measurement> measurements;
|
|
BindingSource bindingSourceMeasurements = new BindingSource();
|
|
|
|
List<HeaderSetting> headerSettings = new List<HeaderSetting>();
|
|
|
|
DataTable dataTablePowersupplySettings = new DataTable();
|
|
List<PowerSupplySetting> powerSupplySettings = new List<PowerSupplySetting>();
|
|
|
|
|
|
List<int> voltageChannels = new List<int>() { 201, 202, 203, 204, 205, 206, 207, 208, 209, 210,
|
|
214, 215, 216, 217, 218, 219 };
|
|
public double PAMMaxCurrent
|
|
{
|
|
get
|
|
{
|
|
double result;
|
|
if (double.TryParse(tbPamMaxCurrent.Text, out result))
|
|
{
|
|
return result;
|
|
}
|
|
else
|
|
{
|
|
// Handle the case where the conversion fails
|
|
throw new FormatException("Invalid input for PAMMaxCurrent.");
|
|
}
|
|
}
|
|
}
|
|
public Form1()
|
|
{
|
|
InitializeComponent();
|
|
|
|
InitializeEvents();
|
|
//InitializeDataTablePowerSupplySettings();
|
|
//InitializeDgvPowerSupplySettings();
|
|
//KeithleyValidationOfMethods();
|
|
InitializeButtons();
|
|
InitDgvPowersupply();
|
|
InitDgvHeaderSetting();
|
|
InitDgvMeasurements();
|
|
InitSwitchMatrix();
|
|
InitializePowerupSequence();
|
|
|
|
}
|
|
#region INITIALIZATION
|
|
private void InitializeButtons()
|
|
{
|
|
btnClear.Enabled = false;
|
|
btnMeasure.Enabled = false;
|
|
btnNextPosition.Enabled = false;
|
|
|
|
btnSendPsuSettings.Enabled = false;
|
|
}
|
|
private void InitDgvMeasurements()
|
|
{
|
|
measurements = new BindingList<Measurement>();
|
|
bindingSourceMeasurements.DataSource = measurements;
|
|
dgvMeasurements.DataSource = bindingSourceMeasurements;
|
|
}
|
|
private void InitBeginPositionOfSwitches()
|
|
{
|
|
foreach (var sw in switchMatrix)
|
|
{
|
|
DAQ.CloseChannel(sw.SW1);
|
|
DAQ.OpenChannel(sw.SW2);
|
|
DAQ.CloseChannel(sw.SW3);
|
|
}
|
|
}
|
|
private void InitSwitchMatrix()
|
|
{
|
|
switchMatrix = new List<SwitchMatrix>()
|
|
{
|
|
//00926 20 Channel Actuator / GP Switch Module SLOT1
|
|
new SwitchMatrix { Channel = 1, SW1 = 102, SW2 = 103, SW3 = 104 },
|
|
new SwitchMatrix { Channel = 2, SW1 = 105, SW2 = 106, SW3 = 107 },
|
|
new SwitchMatrix { Channel = 3, SW1 = 108, SW2 = 109, SW3 = 110 },
|
|
new SwitchMatrix { Channel = 4, SW1 = 111, SW2 = 112, SW3 = 113 },
|
|
new SwitchMatrix { Channel = 5, SW1 = 114, SW2 = 115, SW3 = 116 },
|
|
new SwitchMatrix { Channel = 6, SW1 = 117, SW2 = 118, SW3 = 119 }
|
|
};
|
|
}
|
|
public void InitDgvHeaderSetting()
|
|
{
|
|
for (int headerpin = 1; headerpin <= 10; headerpin++)
|
|
{
|
|
HeaderSetting headerSetting = new HeaderSetting() { HeaderPin = headerpin.ToString(), Channel = voltageChannels[headerpin -1], Description = "-", Setpoint = 0.0, Tolerance = 0.0 };
|
|
headerSettings.Add(headerSetting);
|
|
}
|
|
dgvHeaderSettings.DataSource = headerSettings;
|
|
dgvHeaderSettings.Update();
|
|
}
|
|
public void InitDgvPowersupply ()
|
|
{
|
|
|
|
for (int channel = 1; channel <= 6; channel++)
|
|
{
|
|
PowerSupplySetting powerSupplySetting = new PowerSupplySetting() { Channel = channel, Description = "-", Voltage = 0.0, Tolerance = 1, CurrentLimit = 0.1, Enabled = false };
|
|
powerSupplySettings.Add(powerSupplySetting);
|
|
}
|
|
dgvPowerSupplies.DataSource = powerSupplySettings;
|
|
dgvPowerSupplies.Update();
|
|
|
|
}
|
|
public void InitializeDataTablePowerSupplySettings()
|
|
{
|
|
dataTablePowersupplySettings.Columns.Add("Channel", typeof(int));
|
|
dataTablePowersupplySettings.Columns.Add("Description", typeof(string));
|
|
dataTablePowersupplySettings.Columns.Add("Voltage", typeof(double));
|
|
dataTablePowersupplySettings.Columns.Add("Tolerance", typeof(double));
|
|
dataTablePowersupplySettings.Columns.Add("CurrentLimit", typeof(double));
|
|
dataTablePowersupplySettings.Columns.Add("Enabled", typeof(bool));
|
|
}
|
|
public void InitializeDgvPowerSupplySettings()
|
|
{
|
|
dgvPowerSupplies.DataSource = dataTablePowersupplySettings;
|
|
for (int channel = 1; channel <= 6; channel++)
|
|
{
|
|
PowerSupplySetting powerSupplySetting = new PowerSupplySetting() { Channel = channel, Description = "-", Voltage = 0.0, Tolerance = 1, CurrentLimit = 0.1, Enabled = false };
|
|
dataTablePowersupplySettings.Rows.Add(powerSupplySetting.Channel, powerSupplySetting.Description, powerSupplySetting.Voltage,
|
|
powerSupplySetting.Tolerance, powerSupplySetting.CurrentLimit, powerSupplySetting.Enabled);
|
|
}
|
|
dgvPowerSupplies.Update();
|
|
|
|
}
|
|
private void InitializeEvents ()
|
|
{
|
|
cbCH1.CheckedChanged += OnPowerSupplyCheckboxClicked;
|
|
cbCH2.CheckedChanged += OnPowerSupplyCheckboxClicked;
|
|
cbCH3.CheckedChanged += OnPowerSupplyCheckboxClicked;
|
|
cbCH4.CheckedChanged += OnPowerSupplyCheckboxClicked;
|
|
cbCH5.CheckedChanged += OnPowerSupplyCheckboxClicked;
|
|
cbCH6.CheckedChanged += OnPowerSupplyCheckboxClicked;
|
|
cbCH7.Enabled = false;
|
|
cbCH8.Enabled = false;
|
|
}
|
|
private void InitializePowerupSequence()
|
|
{
|
|
powerUpSequences = new List<PowerUpSequence>()
|
|
{ new PowerUpSequence { Channel = 1, Delay = 100},
|
|
new PowerUpSequence { Channel = 2, Delay = 100},
|
|
new PowerUpSequence { Channel = 3, Delay = 100},
|
|
new PowerUpSequence { Channel = 4, Delay = 100}
|
|
};
|
|
}
|
|
private void InitializePowerDownSequence()
|
|
{
|
|
powerDownSequences = new List<PowerUpSequence>()
|
|
{ new PowerUpSequence { Channel = 1, Delay = 1},
|
|
new PowerUpSequence { Channel = 2, Delay = 1},
|
|
new PowerUpSequence { Channel = 3, Delay = 1},
|
|
new PowerUpSequence { Channel = 4, Delay = 1}
|
|
};
|
|
}
|
|
public void InitializeInstruments()
|
|
{
|
|
|
|
// Mandatory instruments:
|
|
Task.Run(() => InitializePSU1(tbResourceStringPSU1.Text));
|
|
Task.Run(() => InitializeDAQ(tbResourceStringDAQ.Text));
|
|
|
|
// Optional Instruments check if to be used
|
|
if (cbPSU2Enabled.Checked)
|
|
{
|
|
Task.Run(() => InitializePSU2(tbResourceStringPSU2.Text));
|
|
}
|
|
|
|
if (cbPAMEnabled.Checked)
|
|
{
|
|
Task.Run(() => InitializePAM(tbResourceStringPAM.Text));
|
|
}
|
|
}
|
|
public void InitializePSU1(string resourceString)
|
|
{
|
|
try
|
|
{
|
|
PSU1 = new HMP4040(resourceString);
|
|
foreach (var setting in powerSupplySettings)
|
|
{
|
|
if (setting.Channel <=4)
|
|
{
|
|
setting.Voltage = PSU1.ReadSetpoint(setting.Channel);
|
|
}
|
|
}
|
|
tbResourceStringPSU1.BackColor = Color.Green;
|
|
dgvPowerSupplies.Refresh();
|
|
}
|
|
catch (Exception)
|
|
{
|
|
tbResourceStringPSU1.BackColor = Color.Red;
|
|
MessageBox.Show("Unable to Connect to HAMEG 1 PowerSupply");
|
|
throw;
|
|
}
|
|
|
|
}
|
|
public void InitializePSU2(string resourceString)
|
|
{
|
|
try
|
|
{
|
|
PSU2 = new HMP4040(resourceString);
|
|
tbResourceStringPSU2.BackColor = Color.Green;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
tbResourceStringPSU2.BackColor = Color.Red;
|
|
MessageBox.Show("Unable to Connect to HAMEG 2 PowerSupply");
|
|
throw;
|
|
}
|
|
|
|
}
|
|
public void InitializePAM(string resourceString)
|
|
{
|
|
try
|
|
{
|
|
PAM = new Keithley6485(resourceString);
|
|
// Query the instrument ID
|
|
PAM.Reset();
|
|
string idnResponse = PAM.GetID();
|
|
Console.WriteLine($"Instrument ID: {idnResponse}");
|
|
|
|
// Measure DC current
|
|
PAM.PerformZeroCheck();
|
|
tbResourceStringPAM.BackColor = Color.Green;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
tbResourceStringPAM.BackColor = Color.Red;
|
|
MessageBox.Show("Unable to Connect to PicoAmmeter");
|
|
throw;
|
|
}
|
|
|
|
}
|
|
public void InitializeDAQ(string resourceString)
|
|
{
|
|
try
|
|
{
|
|
DAQ = new Agilent34970a(resourceString);
|
|
tbResourceStringDAQ.BackColor = Color.Green;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
tbResourceStringDAQ.BackColor = Color.Red;
|
|
MessageBox.Show("Unable to Connect to DAQ");
|
|
throw;
|
|
}
|
|
|
|
}
|
|
#endregion
|
|
|
|
#region INSTRUMENTVALIDATION
|
|
public void HamegValidationOfMethods()
|
|
{
|
|
string resourceString = "ASRL4::INSTR"; // Replace with your instrument's resource string
|
|
HMP4040 hameg = new HMP4040(resourceString);
|
|
hameg.GetID();
|
|
HMP4040Sample voltageResponse = (HMP4040Sample)hameg.MeasureVolt(1);
|
|
Console.WriteLine($"Measured Voltage: {voltageResponse.Value} V");
|
|
|
|
HMP4040Sample currentResponse = (HMP4040Sample)hameg.MeasureCurrent(1);
|
|
Console.WriteLine($"Measured Current: {currentResponse.Value} A");
|
|
|
|
|
|
string voltageSetpoint = hameg.SetVoltage(1.1, 1);
|
|
Console.WriteLine($"Voltage Setpoint: {currentResponse} V");
|
|
|
|
string currentSetpoint = hameg.SetCurrent(0.1, 1);
|
|
Console.WriteLine($"Current Setpoint: {currentResponse} A");
|
|
|
|
hameg.PowerUpSequence(hameg.GenerateSimulationPowerUpSequence());
|
|
hameg.PowerDownSequence(hameg.GenerateSimulationPowerUpSequence());
|
|
}
|
|
public void KeithleyValidationOfMethods()
|
|
{
|
|
// Example usage
|
|
string resourceString = "ASRL3::INSTR"; // Replace with your instrument's resource string
|
|
Keithley6485 keithley = new Keithley6485(resourceString);
|
|
|
|
// Query the instrument ID
|
|
keithley.Reset();
|
|
string idnResponse = keithley.GetID();
|
|
Console.WriteLine($"Instrument ID: {idnResponse}");
|
|
|
|
// Measure DC current
|
|
keithley.PerformZeroCheck();
|
|
Keithley6485Sample currentResponse = (Keithley6485Sample) keithley.MeasureDCCurrent();
|
|
Console.WriteLine($"Measured Current: {currentResponse.Value}");
|
|
|
|
// Close the instrument connection
|
|
keithley.Close();
|
|
|
|
}
|
|
public void AgilentValidationOfMethods()
|
|
{
|
|
// Example usage
|
|
string resourceString = "ASRL9::INSTR"; // Replace with your instrument's resource string
|
|
Agilent34970a agilent = new Agilent34970a(resourceString);
|
|
|
|
// Query the instrument ID
|
|
agilent.Reset();
|
|
string idnResponse = agilent.GetID();
|
|
Console.WriteLine($"Instrument ID: {idnResponse}");
|
|
|
|
//Measure DC Voltage
|
|
foreach (var channel in voltageChannels)
|
|
{
|
|
agilent.ConfigVoltageChannel(channel);
|
|
Agilent34970aSample sample =(Agilent34970aSample) agilent.MeasureVolt(channel);
|
|
Console.WriteLine($"Measured voltage CH{channel} : {sample.Value}");
|
|
}
|
|
|
|
// Close the instrument connection
|
|
agilent.Close();
|
|
|
|
}
|
|
private void btnInitializeInstruments_Click(object sender, EventArgs e)
|
|
{
|
|
InitializeInstruments();
|
|
}
|
|
#endregion
|
|
|
|
private void btnSelectProject_Click(object sender, EventArgs e)
|
|
{
|
|
// Create new Form and show in showdialog window.
|
|
FormSelectProject formSelectProject = new FormSelectProject();
|
|
if (formSelectProject.ShowDialog() == DialogResult.OK)
|
|
{
|
|
// Get Project information from formSelectProject Form.
|
|
Project = formSelectProject.Project;
|
|
// Update Project information
|
|
UpdateProjectInfoTextboxes(Project);
|
|
}
|
|
}
|
|
private void UpdateProjectInfoTextboxes(Project project)
|
|
{
|
|
// Fill in project information textboxes.
|
|
tbProject.Text = $"Project: P{project.MIDSProject} Sub: {project.MIDSSubProject} Step: {project.MIDSStep}";
|
|
tbProjectDescription.Text = project.MIDSProjectDescription;
|
|
tbSubProjectDescription.Text = project.MIDSSubProjectDescription;
|
|
tbStepDescription.Text = project.MIDSStepDescription;
|
|
}
|
|
public void OnPowerSupplyCheckboxClicked (object sender, EventArgs e)
|
|
{
|
|
CheckBox SelectedChannel = (CheckBox)sender;
|
|
Console.WriteLine(SelectedChannel.Name);
|
|
int.TryParse(SelectedChannel.Name[4].ToString(), out int channel);
|
|
//DataRow row = dataTablePowersupplySettings.Rows[channel-1];
|
|
//row["Enabled"] = SelectedChannel.Checked;
|
|
foreach (var setting in powerSupplySettings)
|
|
{
|
|
if (setting.Channel == channel)
|
|
{
|
|
setting.Enabled = SelectedChannel.Checked;
|
|
dgvPowerSupplies.Refresh();
|
|
}
|
|
}
|
|
}
|
|
private void btnMeasure_Click(object sender, EventArgs e)
|
|
{
|
|
InitBeginPositionOfSwitches();
|
|
PowerUpPSU(powerUpSequences);
|
|
MeasurePSUVoltage();
|
|
MeasureHeaderVoltage();
|
|
MeasureCurrent();
|
|
PowerDownPSU(powerUpSequences);
|
|
|
|
// Timestamp, Position, Device, Measurement, Voltage, Current
|
|
// 2025-01-09, 1, HAMEG1, CH1, 1.0, 0.1
|
|
// 2025-01-09, 1, HAMEG2, CH5, 1.0, 0.1
|
|
// 2025-01-09, 1, KEITHLEY, CH1, -, 1.0
|
|
// 2025-01-09, 1, AGILENT, HEADER1, 1.0, -
|
|
}
|
|
|
|
private void PowerUpPSU(List<PowerUpSequence> powerUpsequences)
|
|
{
|
|
PSU1.PowerUpSequence(powerUpsequences);
|
|
PSU1.SetGeneralOutputState(true);
|
|
}
|
|
private void PowerDownPSU(List<PowerUpSequence> powerUpsequences)
|
|
{
|
|
PSU1.PowerDownSequence(powerUpsequences);
|
|
PSU1.SetGeneralOutputState(false);
|
|
}
|
|
private void MeasureHeaderVoltage()
|
|
{
|
|
//02700 20 Channel Multiplexer Module (BLR) SLOT2
|
|
foreach (var header in headerSettings)
|
|
{
|
|
DAQ.ConfigVoltageChannel(header.Channel);
|
|
Agilent34970aSample sample =(Agilent34970aSample)DAQ.MeasureVolt(header.Channel);
|
|
this.measurements.Add(new Measurement
|
|
{
|
|
Description = $"Headerpin : {header.HeaderPin}",
|
|
Device = "Agilent34970A",
|
|
Position = CurrentPosition,
|
|
Timestamp = sample.TimeStamp,
|
|
Value = sample.Value,
|
|
Unit = sample.Unit
|
|
});
|
|
|
|
Console.WriteLine($"Measured voltage CH{header.Channel} : {sample.Value}");
|
|
}
|
|
|
|
}
|
|
private void MeasurePSUVoltage()
|
|
{
|
|
var powerSupplies = GetEnabledPowerSupplies();
|
|
foreach (var powersupply in powerSupplies)
|
|
{
|
|
if (powersupply.Channel <= 4)
|
|
{
|
|
HMP4040Sample sample = (HMP4040Sample)PSU1.MeasureVolt(powersupply.Channel);
|
|
this.measurements.Add(new Measurement
|
|
{
|
|
Description = $"PSU1_CH{powersupply.Channel}",
|
|
Device = "HAMEG4040",
|
|
Position = CurrentPosition,
|
|
Timestamp = sample.TimeStamp,
|
|
Value = sample.Value,
|
|
Unit = sample.Unit
|
|
});
|
|
sample = (HMP4040Sample)PSU1.MeasureCurrent(powersupply.Channel);
|
|
this.measurements.Add(new Measurement
|
|
{
|
|
Description = $"PSU1_CH{powersupply.Channel}",
|
|
Device = "HAMEG4040",
|
|
Position = CurrentPosition,
|
|
Timestamp = sample.TimeStamp,
|
|
Value = sample.Value,
|
|
Unit = sample.Unit
|
|
});
|
|
|
|
}
|
|
else
|
|
{
|
|
HMP4040Sample sample = (HMP4040Sample)PSU2.MeasureVolt(powersupply.Channel);
|
|
this.measurements.Add(new Measurement
|
|
{
|
|
Description = $"PSU2_CH{powersupply.Channel}",
|
|
Device = "HAMEG4040",
|
|
Position = CurrentPosition,
|
|
Timestamp = sample.TimeStamp,
|
|
Value = sample.Value,
|
|
Unit = sample.Unit
|
|
});
|
|
sample = (HMP4040Sample)PSU2.MeasureCurrent(powersupply.Channel);
|
|
this.measurements.Add(new Measurement
|
|
{
|
|
Description = $"PSU1_CH{powersupply.Channel}",
|
|
Device = "HAMEG4040",
|
|
Position = CurrentPosition,
|
|
Timestamp = sample.TimeStamp,
|
|
Value = sample.Value,
|
|
Unit = sample.Unit
|
|
});
|
|
}
|
|
}
|
|
|
|
}
|
|
private void MeasureCurrent()
|
|
{
|
|
var enabledPowersupplies = GetEnabledPowerSupplies();
|
|
|
|
foreach (var powersupply in enabledPowersupplies)
|
|
{
|
|
if (powersupply.Channel <= 4)
|
|
{
|
|
HMP4040Sample current = (HMP4040Sample) PSU1.MeasureCurrent(powersupply.Channel);
|
|
|
|
if (PAM == null) { return; }
|
|
|
|
if (current.Value < PAMMaxCurrent )
|
|
{
|
|
DAQ.CloseChannel(101); // Switch relay for PAM measurement
|
|
SetSwitchesBeforeCurrentMeasurement(powersupply.Channel);
|
|
Keithley6485Sample sample = (Keithley6485Sample) PAM.MeasureDCCurrent();
|
|
this.measurements.Add(new Measurement
|
|
{
|
|
Description = $"PSU1_CH{powersupply.Channel}",
|
|
Device = "Keithley6485",
|
|
Position = CurrentPosition,
|
|
Timestamp = sample.TimeStamp,
|
|
Value = sample.Value,
|
|
Unit = sample.Unit
|
|
});
|
|
SetSwitchesAfterCurrentMeasurement(powersupply.Channel);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
DAQ.CloseChannel(101); // Switch relay for PAM measurement
|
|
HMP4040Sample current = (HMP4040Sample)PSU2.MeasureCurrent(powersupply.Channel);
|
|
if (PAM == null) { return; }
|
|
|
|
if (current.Value < PAMMaxCurrent)
|
|
{
|
|
SetSwitchesBeforeCurrentMeasurement(powersupply.Channel);
|
|
PAM.MeasureDCCurrent();
|
|
Keithley6485Sample sample = (Keithley6485Sample)PAM.MeasureDCCurrent();
|
|
this.measurements.Add(new Measurement
|
|
{
|
|
Description = $"PSU2_CH{powersupply.Channel}",
|
|
Device = "Keithley6485",
|
|
Position = CurrentPosition,
|
|
Timestamp = sample.TimeStamp,
|
|
Value = sample.Value,
|
|
Unit = sample.Unit
|
|
});
|
|
SetSwitchesAfterCurrentMeasurement(powersupply.Channel);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
private void SetSwitchesBeforeCurrentMeasurement(int channel)
|
|
{
|
|
SwitchMatrix switches = switchMatrix.Where(x => x.Channel == channel).First();
|
|
DAQ.CloseChannel(switches.SW1);
|
|
DAQ.CloseChannel(switches.SW2);
|
|
DAQ.CloseChannel(switches.SW3);
|
|
DAQ.OpenChannel(switches.SW1);
|
|
|
|
}
|
|
private void SetSwitchesAfterCurrentMeasurement(int channel)
|
|
{
|
|
SwitchMatrix switches = switchMatrix.Where(x => x.Channel == channel).First();
|
|
DAQ.CloseChannel(switches.SW1);
|
|
DAQ.OpenChannel(switches.SW2);
|
|
DAQ.OpenChannel(switches.SW3);
|
|
|
|
|
|
}
|
|
private List<PowerSupplySetting> GetEnabledPowerSupplies()
|
|
{
|
|
var enabledPowerSupplies = powerSupplySettings.Where(x => x.Enabled == true).ToList();
|
|
return enabledPowerSupplies;
|
|
}
|
|
private void btnSendPsuSettings_Click(object sender, EventArgs e)
|
|
{
|
|
foreach (PowerSupplySetting powerSupplySetting in powerSupplySettings)
|
|
{
|
|
PSU1.SetVoltage(powerSupplySetting.Voltage, powerSupplySetting.Channel);
|
|
PSU1.SetCurrent(powerSupplySetting.CurrentLimit, powerSupplySetting.Channel);
|
|
}
|
|
}
|
|
|
|
private void WriteBindingListToCsv(BindingList<Measurement> list, string filePath)
|
|
{
|
|
StringBuilder csvContent = new StringBuilder();
|
|
|
|
// Add header
|
|
csvContent.AppendLine("Timestamp,Position,Device,Description,Value,Unit");
|
|
|
|
// Add data
|
|
foreach (var measurement in list)
|
|
{
|
|
csvContent.AppendLine($"{measurement.Timestamp:yyyy-MM-dd},{measurement.Position},{measurement.Device},{measurement.Description},{measurement.Value},{measurement.Unit}");
|
|
}
|
|
|
|
// Write to file
|
|
File.WriteAllText(filePath, csvContent.ToString());
|
|
MessageBox.Show("Data exported successfully!", "Export", MessageBoxButtons.OK, MessageBoxIcon.Information);
|
|
}
|
|
|
|
private void btnNextPosition_Click(object sender, EventArgs e)
|
|
{
|
|
CurrentPosition += PositionIncrement;
|
|
}
|
|
|
|
private void btnClear_Click(object sender, EventArgs e)
|
|
{
|
|
measurements.Clear(); // Clear the list
|
|
}
|
|
|
|
private void btnExport_Click(object sender, EventArgs e)
|
|
{
|
|
using (SaveFileDialog saveFileDialog = new SaveFileDialog())
|
|
{
|
|
saveFileDialog.Filter = "CSV files (*.csv)|*.csv|All files (*.*)|*.*";
|
|
saveFileDialog.Title = "Save a CSV File";
|
|
if (saveFileDialog.ShowDialog() == DialogResult.OK)
|
|
{
|
|
WriteBindingListToCsv(measurements, saveFileDialog.FileName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|