public static void Tcp()
{
var slaveClient = new TcpListener(new IPAddress(new byte[] { 127, 0, 0, 1 }), 502);
using (var slave = ModbusTcpSlave.CreateTcp((byte)1, slaveClient))
{
StartSlave(slave);
IPAddress address = new IPAddress(new byte[] { 127, 0, 0, 1 });
var masterClient = new TcpClient(address.ToString(), 502);
using (var master = ModbusIpMaster.CreateIp(masterClient))
ReadRegisters(master);
}
}
/// <summary>
/// Simple Modbus UDP master write coils example.
/// </summary>
public static void ModbusUdpMasterWriteCoils()
{
using (UdpClient client = new UdpClient())
{
IPEndPoint endPoint = new IPEndPoint(new IPAddress(new byte[] { 127, 0, 0, 1 }), 502);
client.Connect(endPoint);
ModbusIpMaster master = ModbusIpMaster.CreateIp(client);
ushort startAddress = 1;
// write three coils
master.WriteMultipleCoils(startAddress, new bool[] { true, false, true });
}
}
private static void mainThreadFunc()
{
while (true)
{
if (MainThread.exitEvent.WaitOne(1000))
{
break;
}
#region 启动Dbus
//启动监听进程
if (SyncState.Dbus == false)
{
dbusThread = new ExThread(Syncdbus);
dbusThread.Start();
MyConsole.Add("监听Dbus线程已启动!", Color.Green);
SyncState.Dbus = true;
}
#endregion
#region 启动ModbusTcp
if (SyncState.ModbusTcp == false)
{
try
{
MyConsole.Add(string.Format("开始连接ModbusTcp客户端,IP地址:{0},Port:{1}", Profinet.ModbusTcpSeverIPAddress, Profinet.ModbusTcpSeverPort));
//连接超时1000ms
TcpClient tcpClient = new ExTcpClient(Profinet.ModbusTcpSeverIPAddress, Profinet.ModbusTcpSeverPort, 1000).Connect();
modbusMaster = ModbusIpMaster.CreateIp(tcpClient);
modbusMaster.Transport.WriteTimeout = Profinet.Timeout; //写超时
modbusMaster.Transport.ReadTimeout = Profinet.Timeout; //读超时
modbusMaster.Transport.WaitToRetryMilliseconds = Profinet.WaitToRetryTime; //重试等待时间
modbusMaster.Transport.Retries = Profinet.RetryNum; //重试次数
//启动监听进程
modbusThread = new ExThread(SyncModbus);
modbusThread.Start();
SyncState.ModbusTcp = true;
MyConsole.Add("监听ModbusTCP线程启动成功!", Color.Green);
}
catch
{
MyConsole.Add("监听ModbusTCP线程启动失败!", Color.Red);
}
}
#endregion
}
}
public MeasureForm(int _devno, SerialPort _sp, TcpClient _tc, Sensor _ts)
{
InitializeComponent();
SettingButton.Click += SettingButton_Click;
ExecButton.Click += ExecButton_Click;
UpdateButton.Click += UpdateButton_Click;
CoilsButton.Click += CoilsButton_Click;
DescriteButton.Click += DescriteButton_Click;
UptimeButton.Click += UptimeButton_Click;
RawButton.Click += RawButton_Click;
CyclicPeriod.Minimum = 100m;
CyclicPeriod.Maximum = 10000m;
CyclicPeriod.Value = 1000m;
fs = null;
sw = null;
DataGridView dataGridView = dataGridView1;
dataGridView.AutoSize = true;
dataGridView.Anchor = (AnchorStyles.Top | AnchorStyles.Left);
dataGridView.RowHeadersVisible = false;
dataGridView.AllowUserToAddRows = false;
dataGridView.MultiSelect = false;
dataGridView.SelectionMode = DataGridViewSelectionMode.CellSelect;
dataGridView.ColumnCount = 2;
dataGridView.Columns[0].HeaderText = "Item";
dataGridView.Columns[0].SortMode = DataGridViewColumnSortMode.NotSortable;
dataGridView.Columns[1].HeaderText = "Value";
dataGridView.Columns[1].SortMode = DataGridViewColumnSortMode.NotSortable;
TargetSensor = _ts;
TargetSensor.SensorComponent(dataGridView);
devno = _devno;
if (_sp != null)
{
Tc = null;
Sp = _sp;
Sp.Open();
Master = ModbusSerialMaster.CreateRtu(_sp);
}
else
{
Sp = null;
Tc = _tc;
Master = ModbusIpMaster.CreateIp(Tc);
}
Master.Transport.ReadTimeout = 300;
dataGridView.CurrentCell = dataGridView[1, 0];
dataGridView.AllowUserToResizeRows = false;
}
public static void Write_MultipleCoils(ushort write_start_addr, bool[] coils_value)
{
coils_value = _writemultiplecoils_Value;
write_start_addr = _writestartAddress;
Start_MBServer();
Start_MBCLient();
ModbusSlave slave = ModbusTcpSlave.CreateTcp(_slaveID, slaveTCP);
var listener = slave.ListenAsync();
ModbusIpMaster master = ModbusIpMaster.CreateIp(masterTCP);
master.WriteMultipleCoils(write_start_addr, coils_value);
Stop_MBClient();
Stop_MBServer();
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public static void Write_SingleCoil(ushort write_coil_addr, bool coil_value)
{
write_coil_addr = _writecoil_Address;
coil_value = _writecoil_Value;
Start_MBServer();
Start_MBCLient();
ModbusSlave slave = ModbusTcpSlave.CreateTcp(_slaveID, slaveTCP);
var listener = slave.ListenAsync();
ModbusIpMaster master = ModbusIpMaster.CreateIp(masterTCP);
master.WriteSingleCoil(_writecoil_Address, _writecoil_Value);
Stop_MBClient();
Stop_MBServer();
}
public static void Write_MultipleRegisters(ushort write_register_addr, ushort[] register_data)
{
write_register_addr = _register_Address;
register_data = _register_Data;
Start_MBServer();
Start_MBCLient();
ModbusSlave slave = ModbusTcpSlave.CreateTcp(_slaveID, slaveTCP);
var listener = slave.ListenAsync();
ModbusIpMaster master = ModbusIpMaster.CreateIp(masterTCP);
master.WriteMultipleRegisters(write_register_addr, register_data);
Stop_MBClient();
Stop_MBServer();
}
public static void Udp()
{
var slaveClient = new UdpClient(502);
using (var slave = ModbusUdpSlave.CreateUdp(slaveClient))
{
StartSlave(slave);
var masterClient = new UdpClient();
IPEndPoint endPoint = new IPEndPoint(new IPAddress(new byte[] { 127, 0, 0, 1 }), 502);
masterClient.Connect(endPoint);
using (var master = ModbusIpMaster.CreateIp(masterClient))
ReadRegisters(master);
}
}
public static void Write_SingleRegister(ushort write_register_addr, ushort register_value)
{
write_register_addr = _register_Address;
register_value = _register_Value;
Start_MBServer();
Start_MBCLient();
ModbusSlave slave = ModbusTcpSlave.CreateTcp(_slaveID, slaveTCP);
var listener = slave.ListenAsync();
ModbusIpMaster master = ModbusIpMaster.CreateIp(masterTCP);
master.WriteSingleRegister(write_register_addr, register_value);
Stop_MBClient();
Stop_MBServer();
}
private static void ReadAndDisplay()
{
if (CheckConnection(IpAddress, 100))
{
ushort[] regData;
bool[] coilData;
while (true)
{
using (TcpClient client = new TcpClient(IpAddress, 502)) {
ModbusIpMaster master = ModbusIpMaster.CreateIp(client);
regData = master.ReadHoldingRegisters(0, 16);
coilData = master.ReadCoils(0, 48);
client.Close();
master.Dispose();
}
Console.WriteLine("Analog");
for (int i = 0; i < regData.Length; i++)
{
//double x = regData[i];
//x = (x / 1000);
//double y = SlopeValues[i] * x + OffsetValues[i];
//double current = (RValues[i] != 0) ? (y / RValues[i]) * 1000 : 0.00;
Console.WriteLine(" A{0}: Voltage: {1} Current: {2}", i, regData[i]);
}
Console.WriteLine();
Console.WriteLine("Digitals Pull-up: ");
for (int i = 0; i < 22; i++)
{
Console.WriteLine(" D{0}: {1}", i, coilData[i]);
}
Console.WriteLine();
Console.WriteLine("Press C to continue");
var key = Console.ReadKey();
if (key.Key != ConsoleKey.C)
{
break;
}
}
}
else
{
Console.WriteLine("Connection Failed");
}
Console.ReadKey();
}
private Task <bool> ConnectTask()
{
return(Task.Run(() =>
{
if (master != null)
{
master.Dispose();
}
if (client != null)
{
client.Close();
}
if (CheckInternet())
{
try
{
client = new TcpClient();
IAsyncResult asyncResult = client.BeginConnect(cGenel.conDXM_IP, 502, null, null);
asyncResult.AsyncWaitHandle.WaitOne(1000, true); //wait for 3 sec
if (!asyncResult.IsCompleted)
{
client.Close();
cGenel.haberlesmeMesaj = (DateTime.Now.ToString() + ":DXM Cannot connect to server.(task)");
error_kayit.error_log_kayit(cGenel.haberlesmeMesaj);
return false;
}
// create Modbus TCP Master by the tcpclient
master = ModbusIpMaster.CreateIp(client);
master.Transport.Retries = 3; //don't have to do retries
master.Transport.ReadTimeout = 1500;
master.Transport.WaitToRetryMilliseconds = 50;
cGenel.haberlesmeMesaj = (DateTime.Now.ToString() + ":DXM Connect to server.(task)");
error_kayit.error_log_kayit(cGenel.haberlesmeMesaj);
return true;
}
catch (Exception ex)
{
cGenel.haberlesmeMesaj = (DateTime.Now.ToString() + ":DXM Connect process (task) " + ex.StackTrace +
"==>" + ex.Message);
error_kayit.error_log_kayit(cGenel.haberlesmeMesaj);
return false;
}
}
return false;
}));
}
static void Main(string[] args)
{
Console.WriteLine("Input IP address of modbus slave");
var ip = Console.ReadLine();
Console.WriteLine("Input port");
int port;
var t = int.TryParse(Console.ReadLine(), out port);
byte slaveId;
Console.WriteLine("Input slaveId");
t = byte.TryParse(Console.ReadLine(), out slaveId);
while (true)
{
try
{
using (TcpClient client = new TcpClient(ip, port))
{
ModbusIpMaster master = ModbusIpMaster.CreateIp(client);
// read five input values
ushort startAddress = 0;
ushort numHoldings = 10;
while (true)
{
ushort[] inputs = master.ReadHoldingRegisters(slaveId, startAddress, numHoldings);
//bool[] inputs = master.ReadCoils(slaveId, startAddress, numHoldings);
Console.Write(startAddress + "::");
for (int i = 0; i < inputs.Length; i++)
{
Console.Write(" " + (inputs[i]));
}
Console.WriteLine();
startAddress += 10;
Thread.Sleep(500);
}
Console.Read();
}
}
catch (Exception ex)
{
var tmp = (SlaveException)ex;
Console.WriteLine(tmp.Message + tmp.SlaveExceptionCode);
Console.Read();
}
}
}
private async Task GetDataFromBlockAsync()
{
using (var tcpClient = new TcpClient())
{
tcpClient.Connect(_remoteEP);
int len = _sensorInstance.SampleMaps.Sum(i => i.Len);
using (var modbusMaster = ModbusIpMaster.CreateIp(tcpClient))
{
//modbusMaster.Transport.ReadTimeout = 300;
while (_isRunning)
{
int idx = 0;
byte[] frame = Utils.FrameToByte(await modbusMaster.ReadInputRegistersAsync((byte)0, (ushort)_sensorInstance.SamplingAddress, (ushort)(len / 2)));
List <string> lstData = new List <string>();
foreach (typeBase sampleMap in _sensorInstance.SampleMaps)
{
if (!sampleMap.Title.ToUpper().StartsWith("CH"))
{
continue;
}
sampleMap.FrameTo(frame, idx);
idx += sampleMap.Len;
lstData.Add(sampleMap.ToString());
}
if (HandleWhenReceiveDataFromBlock != null)
{
HandleWhenReceiveDataFromBlock(this, lstData.ToArray());
}
Thread.Sleep(95);
}
if (HandleWhenReceiveDataEndFromBlock != null)
{
HandleWhenReceiveDataEndFromBlock(this, new EventArgs());
}
}
}
_threadReceiveDataFromBlock = null;
}
private static void Read(object state)
{
TcpClient?masterClient = new(ModbusMasterFixture.TcpHost.ToString(), ModbusMasterFixture.Port);
using ModbusIpMaster? master = ModbusIpMaster.CreateIp(masterClient);
master.Transport.Retries = 0;
Random?random = new();
for (int i = 0; i < 5; i++)
{
bool[] coils = master.ReadCoils(1, 1);
Assert.Equal(1, coils.Length);
Debug.WriteLine($"{Thread.CurrentThread.ManagedThreadId}: Reading coil value");
Thread.Sleep(random.Next(100));
}
}
public GSBase(TcpClient MotTcp, TcpClient DetTcp, MainView main)
{
if (null == MotTcp)
{
throw new Exception("电机未连接");
}
Mot = ModbusIpMaster.CreateIp(MotTcp);
if (null == DetTcp)
{
throw new Exception("探测器未连接");
}
Det = ModbusIpMaster.CreateIp(DetTcp);
pMain = main;
listDet = new List <DetPara>();
}
// This method establishs a connection to the device. Therefore an IP address and the port number
// for the TcpClient is need. The client itself is used for the implementation of the ModbusIpMaster.
public void Connect()
{
try
{
_client = new TcpClient(_iPAddress, _port);
_master = ModbusIpMaster.CreateIp(_client);
_connected = true;
BusActivityDetection?.Invoke(this, new LogEvent("Connection has been established successfully"));
}
catch (Exception)
{
_connected = false; // If the connection establishment has not been successful - connected=false.
BusActivityDetection?.Invoke(this, new LogEvent("Connection has NOT been established successfully"));
}
}
private static void ReadOnOwnThread(object state)
{
using (TcpClient masterClient = new TcpClient(ModbusMasterFixture.TcpHost.ToString(), ModbusMasterFixture.Port))
{
ModbusIpMaster master = ModbusIpMaster.CreateIp(masterClient);
master.Transport.Retries = 0;
var random = new Random();
for (int i = 0; i < 5; i++)
{
bool[] coils = master.ReadCoils(1, 1);
Assert.AreEqual(1, coils.Length);
Debug.WriteLine(String.Format("{0}: Reading coil value", Thread.CurrentThread.ManagedThreadId));
Thread.Sleep(random.Next(100));
}
}
}
public static void Setpoint(ushort _setpoint)
{
try
{
TcpClient tcpClient = new TcpClient(Properties.Settings.Default.VRF_Ip, Properties.Settings.Default.VRF_Port);
ModbusIpMaster ipMaster = ModbusIpMaster.CreateIp(tcpClient);
byte address = Properties.Settings.Default.slaveAddress;
ushort addr = 3;
ipMaster.WriteSingleRegister(address, addr, _setpoint);
Thread.Sleep(2000);
setpoint = _setpoint;
ipMaster.Dispose();
tcpClient.GetStream().Close();
tcpClient.Close();
}
catch { }
}
public static bool[] Read_Coils(ushort read_start_addr, ushort num_coils)
{
num_coils = _numOfCoils;
read_start_addr = _readstartAddress;
Start_MBServer();
Start_MBCLient();
ModbusSlave slave = ModbusTcpSlave.CreateTcp(_slaveID, slaveTCP);
var listener = slave.ListenAsync();
ModbusIpMaster master = ModbusIpMaster.CreateIp(masterTCP);
bool[] read_result = master.ReadCoils(read_start_addr, num_coils);
Stop_MBClient();
Stop_MBServer();
return(read_result);
}
public static ushort[] Read_InputRegisters(ushort read_start_addr, ushort num_register)
{
num_register = _numOfInputRegister;
read_start_addr = _readstartAddress;
Start_MBServer();
Start_MBCLient();
ModbusSlave slave = ModbusTcpSlave.CreateTcp(_slaveID, slaveTCP);
var listener = slave.ListenAsync();
ModbusIpMaster master = ModbusIpMaster.CreateIp(masterTCP);
ushort[] read_result = master.ReadInputRegisters(read_start_addr, num_register);
Stop_MBClient();
Stop_MBServer();
return(read_result);
}
/// <summary>
/// Simple Modbus TCP master write holding registers example.
/// </summary>
public async void ModbusTcpWriteSingleRegister()
{
ushort inputValue = ushort.Parse(InputTextBox.Text);
using (TcpClient client = new TcpClient())
{
client.ReceiveTimeout = 3000;
client.SendTimeout = 3000;
await client.ConnectAsync(IpAddressInputBox.Text, int.Parse(TcpPortInputBox.Text));
ModbusIpMaster master = ModbusIpMaster.CreateIp(client);
ushort address = ushort.Parse(writeRegisterInputBox.Text);
master.WriteSingleRegister(address, inputValue);
}
}
public void OverrideTimeoutOnNetworkStream()
{
TcpListener?listener = new(ModbusMasterFixture.TcpHost, ModbusMasterFixture.Port);
using ModbusTcpSlave? slave = ModbusTcpSlave.CreateTcp(ModbusMasterFixture.SlaveAddress, listener);
Thread?slaveThread = new(async() => await slave.ListenAsync());
slaveThread.Start();
TcpClient?client = new(ModbusMasterFixture.TcpHost.ToString(), ModbusMasterFixture.Port);
client.GetStream().ReadTimeout = 1500;
client.GetStream().WriteTimeout = 3000;
using ModbusIpMaster? master = ModbusIpMaster.CreateIp(client);
Assert.Equal(1500, client.GetStream().ReadTimeout);
Assert.Equal(3000, client.GetStream().WriteTimeout);
}
/// <summary>
/// Modbus TCP master and slave Configuration for OmniID application.
/// </summary>
public static void ModbusTcpMasterSlaveConfigOmniID(IPAddress ModBusSlaveIP, byte SlaveId, int Port)
{
byte slaveId = SlaveId; //1
int port = Port; // 502;
// create and start the TCP slave
TcpListener slaveTcpListener = new TcpListener(ModBusSlaveIP, port);
slaveTcpListener.Start();
ModbusSlave slave = ModbusTcpSlave.CreateTcp(slaveId, slaveTcpListener);
Thread slaveThread = new Thread(slave.Listen);
slaveThread.Start();
// create the master
TcpClient masterTcpClient = new TcpClient(ModBusSlaveIP.ToString(), port);
ModbusIpMaster OmniMaster = ModbusIpMaster.CreateIp(masterTcpClient);
ushort numFlagInputs = 1;
ushort pollingAddressStart = 4000;
ushort dataAddressStart = 4001;
int numInputsTagID = 5;
int numInputsWeight = 5;
ushort numInputs = (ushort)(numInputsTagID + numInputsWeight);
Thread pollingThreadOmni = new Thread(() => PollSlaveOmniId(OmniMaster, pollingAddressStart, numFlagInputs, dataAddressStart, numInputs));
pollingThreadOmni.Start();
Console.ReadKey();
// clean up
_shouldpoll = false;
pollingThreadOmni.Join();
masterTcpClient.Close();
slaveTcpListener.Stop();
// output
// Register 100=0
// Register 101=0
// Register 102=0
// Register 103=0
// Register 104=0
}
private void Analysis()
{
while (myWorkState)
{
TimeSpan timeSpan = DateTime.Now.Subtract(ReadTime);
if (timeSpan.TotalSeconds >= 1)
{
try
{
using (TcpClient tcp = new TcpClient(GateWaySetting.Gateways[0].Location, GateWaySetting.Gateways[0].Rate))
{
ModbusMaster ModbusMaster = ModbusIpMaster.CreateIp(tcp);
ModbusMaster.Transport.Retries = 3;
ModbusMaster.Transport.ReadTimeout = 1000;
ModbusMaster.Transport.WriteTimeout = 1000;
foreach (var item in AbsProtocols)
{
item.ReadData(GateWaySetting.Gateways[0].Devices, ModbusMaster);
Thread.Sleep(10);
}
if (AbsProtocols[0].ConnectionFlag)
{
AI64Module = ((AiProtocol)AbsProtocols[0]).AI64Module;
}
else
{
AI64Module = null;
}
StateModules = ((StateProtocol)AbsProtocols[1]).StateModules;
ReadTime = DateTime.Now;
}
}
catch (ThreadAbortException) { }
catch (Exception ex)
{
ReadTime = DateTime.Now;
Log.Error(ex, $"通訊失敗 IP:{GateWaySetting.Gateways[0].Location} Port:{GateWaySetting.Gateways[0].Rate} ");
}
}
else
{
Thread.Sleep(80);
}
}
}
public static void ModbusTcpMasterReadInputRegisters()
{
//byte slaveId = 1;
int port = 502;
IPAddress address = new IPAddress(new byte[] { 127, 0, 0, 1 });
// create and start the TCP slave
//TcpListener slaveTcpListener = new TcpListener(address, port);
//slaveTcpListener.Start();
//ModbusSlave slave = ModbusTcpSlave.CreateTcp(slaveId, slaveTcpListener);
//Thread slaveThread = new Thread(slave.Listen);
//slaveThread.Start();
// create the master
TcpClient masterTcpClient = new TcpClient(address.ToString(), port);
ModbusIpMaster master = ModbusIpMaster.CreateIp(masterTcpClient);
ushort numInputs = 10;
ushort startAddress = 0;
// read five register values
while (true)
{
ushort[] inputs = master.ReadInputRegisters(startAddress, numInputs);
for (int i = 0; i < numInputs; i++)
{
Console.WriteLine($"Register {(startAddress + i)}={(inputs[i])}");
}
Thread.Sleep(1000);
}
// clean up
//masterTcpClient.Close();
//slaveTcpListener.Stop();
// output
// Register 100=0
// Register 101=0
// Register 102=0
// Register 103=0
// Register 104=0
}
ThreePhaseMeasure IThreePhaseInputService.Get()
{
using (var client = new TcpClient(hostname, port))
using (var master = ModbusIpMaster.CreateIp(client))
{
ushort[] inputs = master.ReadHoldingRegisters(slaveId, startAddress, numRegisters);
var measure = new ThreePhaseMeasure
{
Frequency = Converter.ConvertToFloat(inputs, 56),
L1 = GetPhase(inputs, 1),
L2 = GetPhase(inputs, 2),
L3 = GetPhase(inputs, 3),
};
return(measure);
}
}
/// <summary>
/// Wrire registers using Modbus TCP.
/// </summary>
/// <param name="slaveAddress">Slave device address.</param>
/// <param name="startAddress">Start address for writing.</param>
/// <param name="registers">Values of registers.</param>
public static void WriteRegisters(byte slaveAddress, ushort startAddress, params ushort[] registers)
{
if (_client.Connected)
{
try
{
var master = ModbusIpMaster.CreateIp(_client);
master.Transport.WriteTimeout = WriteTimeout;
master.Transport.Retries = AttemptsModbus;
master.WriteMultipleRegisters(slaveAddress, startAddress, registers);
}
catch
{
++WriteErrors;
}
}
}
public ReadThread(string hostname, int port)
{
NReg = (ushort)Sett.Instance.rdCoilSize;
coilCount = RB.R.Length / NReg + 1;
for (int i = 0; i < 2; i++)
{
tcp[i] = new TcpClient(hostname, port);
mbMasterR[i] = ModbusIpMaster.CreateIp(tcp[i]);
/*
* if (i==0)
* thread[i] = new Thread(new ThreadStart(ThreadJob1));
* else
* thread[i] = new Thread(new ThreadStart(ThreadJob2));
*/
// thread[i].Start();
}
}
public static void TurnOFF()
{
try
{
TcpClient tcpClient = new TcpClient(Properties.Settings.Default.VRF_Ip, Properties.Settings.Default.VRF_Port);
ModbusIpMaster ipMaster = ModbusIpMaster.CreateIp(tcpClient);
byte address = Properties.Settings.Default.slaveAddress;
ushort addr = 0;
ushort val = 0;
ipMaster.WriteSingleRegister(address, addr, val);
Thread.Sleep(2000);
status = "OFF";
ipMaster.Dispose();
tcpClient.GetStream().Close();
tcpClient.Close();
}
catch { }
}
static void Main(string[] args)
{
using (TcpClient client = new TcpClient("192.168.5.178", 502))
{
ModbusIpMaster master = ModbusIpMaster.CreateIp(client);
// read five input values
ushort startAddress = 3200;
ushort numInputs = 25;
//bool[] inputs = master.ReadInputs(startAddress, numInputs);
ushort[] outHolding = master.ReadHoldingRegisters(startAddress, numInputs);
for (int i = 0; i < numInputs; i++)
{
Console.WriteLine($"Input {(startAddress + i)}={"NULL"}");
}
}
}