700 lines
27 KiB
C#
700 lines
27 KiB
C#
using File_Watcher.Models;
|
|
using System.Diagnostics;
|
|
using System.Net.Sockets;
|
|
|
|
namespace File_Watcher.Helpers;
|
|
|
|
#pragma warning disable IDE0300
|
|
|
|
internal static partial class LabJackT7Helper
|
|
{
|
|
|
|
private static ModbusTransmissionControlProtocolClient? _ModbusTransmissionControlProtocolClient;
|
|
|
|
private class ModbusTransmissionControlProtocolClient : IDisposable
|
|
{
|
|
|
|
private ushort _TransactionID;
|
|
private NetworkStream? _NetworkStream;
|
|
private TcpClient? _TransmissionControlProtocolClient;
|
|
|
|
public ModbusTransmissionControlProtocolClient(string hostname, int port) =>
|
|
Connect(hostname, port);
|
|
|
|
public void Connect(string hostname, int port)
|
|
{
|
|
if (_TransmissionControlProtocolClient is not null)
|
|
Close();
|
|
|
|
_TransmissionControlProtocolClient = new TcpClient(hostname, port);
|
|
_NetworkStream = _TransmissionControlProtocolClient.GetStream();
|
|
_TransactionID = 0;
|
|
}
|
|
|
|
public void Close()
|
|
{
|
|
_NetworkStream?.Close();
|
|
_NetworkStream = null;
|
|
|
|
_TransmissionControlProtocolClient?.Close();
|
|
_TransmissionControlProtocolClient = null;
|
|
}
|
|
|
|
public bool IsConnected()
|
|
{
|
|
if (_TransmissionControlProtocolClient is not null)
|
|
return _TransmissionControlProtocolClient.Connected;
|
|
return false;
|
|
}
|
|
|
|
public void SetTimeouts(int sendTimeout, int receiveTimeout)
|
|
{
|
|
if (_TransmissionControlProtocolClient == null)
|
|
throw new Exception("Not connected.");
|
|
_TransmissionControlProtocolClient.ReceiveTimeout = receiveTimeout;
|
|
_TransmissionControlProtocolClient.SendTimeout = sendTimeout;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write a byte array of data to the Modbus device.
|
|
/// </summary>
|
|
/// <param name="address">The starting register address.</param>
|
|
/// <param name="data">The byte array of data to write.</param>
|
|
public void Write(ushort address, byte[] data)
|
|
{
|
|
if (_NetworkStream is null)
|
|
throw new Exception("Not connected.");
|
|
|
|
//Using Modbus function 16
|
|
|
|
//Create Modbus Command
|
|
if (data.Length > 254)
|
|
throw new Exception("Too many bytes. The maximum is 254.");
|
|
|
|
if (data.Length % 2 != 0)
|
|
throw new Exception("The number of bytes needs to be a multiple of 2.");
|
|
|
|
byte[] com = new byte[13 + data.Length];
|
|
com[7] = 16;
|
|
com[8] = (byte)(address >> 8);
|
|
com[9] = (byte)(address & 0xFF);
|
|
com[10] = 0;
|
|
com[11] = (byte)(data.Length / 2);
|
|
com[12] = (byte)data.Length;
|
|
Array.Copy(data, 0, com, 13, data.Length);
|
|
SetHeader(com);
|
|
_NetworkStream.Write(com, 0, com.Length);
|
|
|
|
byte[] res = new byte[12];
|
|
int expectedSize = res.Length;
|
|
int size = _NetworkStream.Read(res, 0, res.Length);
|
|
|
|
Array.Resize(ref res, size);
|
|
ResponseErrorChecks(res, expectedSize, com);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read a byte array of data from the Modbus device.
|
|
/// </summary>
|
|
/// <param name="address">The starting register address.</param>
|
|
/// <param name="data">The read byte array of data. The array length is
|
|
/// the amount of bytes to read.</param>
|
|
public void Read(ushort address, byte[] data)
|
|
{
|
|
if (_NetworkStream is null)
|
|
throw new Exception("Not connected.");
|
|
|
|
//Using Modbus function 3
|
|
|
|
//Create Modbus Command
|
|
if (data.Length > 254)
|
|
throw new Exception("Too many bytes. The maximum is 254.");
|
|
|
|
if (data.Length % 2 != 0)
|
|
throw new Exception("The number of bytes needs to be a multiple of 2.");
|
|
|
|
byte[] com = new byte[12];
|
|
com[7] = 3;
|
|
com[8] = (byte)(address >> 8);
|
|
com[9] = (byte)(address & 0xFF);
|
|
com[10] = 0;
|
|
com[11] = (byte)(data.Length / 2);
|
|
SetHeader(com);
|
|
_NetworkStream.Write(com, 0, com.Length);
|
|
|
|
byte[] res = new byte[9 + data.Length];
|
|
int expectedSize = res.Length;
|
|
int size = _NetworkStream.Read(res, 0, res.Length);
|
|
Array.Resize(ref res, size);
|
|
ResponseErrorChecks(res, expectedSize, com);
|
|
|
|
Array.Copy(res, 9, data, 0, data.Length);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write an ushort array of data to the Modbus device.
|
|
/// </summary>
|
|
/// <param name="address">The starting register address.</param>
|
|
/// <param name="data">The ushort array of data to write.</param>
|
|
public void Write(ushort address, ushort[] data)
|
|
{
|
|
if (data.Length > 127)
|
|
throw new Exception("Too many shorts. The maximum is 127.");
|
|
|
|
byte[] bytes = new byte[data.Length * 2];
|
|
for (int i = 0; i < data.Length; i++)
|
|
{
|
|
BitConverter.GetBytes(data[i]).CopyTo(bytes, i * 2);
|
|
if (BitConverter.IsLittleEndian)
|
|
Array.Reverse(bytes, i * 2, 2);
|
|
}
|
|
Write(address, bytes);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read an ushort array of data from the Modbus device.
|
|
/// </summary>
|
|
/// <param name="address">The starting register address.</param>
|
|
/// <param name="data">The read ushort array of data. The array length
|
|
/// is the amount of shorts to read.</param>
|
|
public void Read(ushort address, ushort[] data)
|
|
{
|
|
if (data.Length > 127)
|
|
throw new Exception("Too many shorts. The maximum is 127.");
|
|
|
|
byte[] bytes = new byte[data.Length * 2];
|
|
Read(address, bytes);
|
|
for (int i = 0; i < data.Length; i++)
|
|
{
|
|
if (BitConverter.IsLittleEndian)
|
|
Array.Reverse(bytes, i * 2, 2);
|
|
data[i] = BitConverter.ToUInt16(bytes, i * 2);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write an uint array of data to the Modbus device.
|
|
/// </summary>
|
|
/// <param name="address">The starting register address.</param>
|
|
/// <param name="data">The uint array of data to write.</param>
|
|
public void Write(ushort address, uint[] data)
|
|
{
|
|
if (data.Length > 63)
|
|
throw new Exception("Too many uint. The maximum is 63.");
|
|
|
|
byte[] bytes = new byte[data.Length * 4];
|
|
for (int i = 0; i < data.Length; i++)
|
|
{
|
|
BitConverter.GetBytes(data[i]).CopyTo(bytes, i * 4);
|
|
if (BitConverter.IsLittleEndian)
|
|
Array.Reverse(bytes, i * 4, 4);
|
|
}
|
|
Write(address, bytes);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read an uint array of data from the Modbus device.
|
|
/// </summary>
|
|
/// <param name="address">The starting register address.</param>
|
|
/// <param name="data">The read uint array of data. The array length is
|
|
/// the amount of ints to read.</param>
|
|
public void Read(ushort address, uint[] data)
|
|
{
|
|
if (data.Length > 63)
|
|
throw new Exception("Too many ints. The maximum is 63.");
|
|
|
|
byte[] bytes = new byte[data.Length * 4];
|
|
Read(address, bytes);
|
|
for (int i = 0; i < data.Length; i++)
|
|
{
|
|
if (BitConverter.IsLittleEndian)
|
|
Array.Reverse(bytes, i * 4, 4);
|
|
data[i] = BitConverter.ToUInt32(bytes, i * 4);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write an int array of data to the Modbus device.
|
|
/// </summary>
|
|
/// <param name="address">The starting register address.</param>
|
|
/// <param name="data">The int array of data to write.</param>
|
|
public void Write(ushort address, int[] data)
|
|
{
|
|
if (data.Length > 63)
|
|
throw new Exception("Too many ints. The maximum is 63.");
|
|
|
|
byte[] bytes = new byte[data.Length * 4];
|
|
for (int i = 0; i < data.Length; i++)
|
|
{
|
|
BitConverter.GetBytes(data[i]).CopyTo(bytes, i * 4);
|
|
if (BitConverter.IsLittleEndian)
|
|
Array.Reverse(bytes, i * 4, 4);
|
|
}
|
|
Write(address, bytes);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read an int array of data from the Modbus device.
|
|
/// </summary>
|
|
/// <param name="address">The starting register address.</param>
|
|
/// <param name="data">The read int array of data. The array length is
|
|
/// the amount of ints to read.</param>
|
|
public void Read(ushort address, int[] data)
|
|
{
|
|
if (data.Length > 63)
|
|
throw new Exception("Too many ints. The maximum is 63.");
|
|
|
|
byte[] bytes = new byte[data.Length * 4];
|
|
Read(address, bytes);
|
|
for (int i = 0; i < data.Length; i++)
|
|
{
|
|
if (BitConverter.IsLittleEndian)
|
|
Array.Reverse(bytes, i * 4, 4);
|
|
data[i] = BitConverter.ToInt32(bytes, i * 4);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write a float array of data to the Modbus device.
|
|
/// </summary>
|
|
/// <param name="address">The starting register address.</param>
|
|
/// <param name="data">The float array of data to write.</param>
|
|
public void Write(ushort address, float[] data)
|
|
{
|
|
if (data.Length > 63)
|
|
throw new Exception("Too many floats. The maximum is 63.");
|
|
|
|
byte[] bytes = new byte[data.Length * 4];
|
|
for (int i = 0; i < data.Length; i++)
|
|
{
|
|
BitConverter.GetBytes(data[i]).CopyTo(bytes, i * 4);
|
|
if (BitConverter.IsLittleEndian)
|
|
Array.Reverse(bytes, i * 4, 4);
|
|
}
|
|
Write(address, bytes);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reads a float array of data from the Modbus device.
|
|
/// </summary>
|
|
/// <param name="address">The starting register address.</param>
|
|
/// <param name="data">The read float array of data. The array length is
|
|
/// the amount of floats to read.</param>
|
|
public void Read(ushort address, float[] data)
|
|
{
|
|
if (data.Length > 63)
|
|
throw new Exception("Too many floats. The maximum is 63.");
|
|
|
|
byte[] bytes = new byte[data.Length * 4];
|
|
Read(address, bytes);
|
|
for (int i = 0; i < data.Length; i++)
|
|
{
|
|
if (BitConverter.IsLittleEndian)
|
|
Array.Reverse(bytes, i * 4, 4);
|
|
data[i] = BitConverter.ToSingle(bytes, i * 4);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write a single ushort of data to the Modbus device.
|
|
/// </summary>
|
|
/// <param name="address">The register address.</param>
|
|
/// <param name="data">The ushort data to write.</param>
|
|
public void Write(ushort address, ushort data)
|
|
{
|
|
ushort[] dataArray = new ushort[1];
|
|
dataArray[0] = data;
|
|
Write(address, dataArray);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read a single ushort of data from the Modbus device.
|
|
/// </summary>
|
|
/// <param name="address">The register address.</param>
|
|
/// <param name="data">The read ushort data.</param>
|
|
public void Read(ushort address, ref ushort data)
|
|
{
|
|
ushort[] dataArray = new ushort[1];
|
|
Read(address, dataArray);
|
|
data = dataArray[0];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write a single uint of data to the Modbus device.
|
|
/// </summary>
|
|
/// <param name="address">The starting register address.</param>
|
|
/// <param name="data">The uint data to write.</param>
|
|
public void Write(ushort address, uint data)
|
|
{
|
|
uint[] dataArray = new uint[1];
|
|
dataArray[0] = data;
|
|
Write(address, dataArray);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read a single uint of data from the Modbus device.
|
|
/// </summary>
|
|
/// <param name="address">The starting register address.</param>
|
|
/// <param name="value">The read uint data.</param>
|
|
public void Read(ushort address, ref uint data)
|
|
{
|
|
uint[] dataArray = new uint[1];
|
|
Read(address, dataArray);
|
|
data = dataArray[0];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write a single int of data to the Modbus device.
|
|
/// </summary>
|
|
/// <param name="address">The starting register address.</param>
|
|
/// <param name="data">The int data to write.</param>
|
|
public void Write(ushort address, int data)
|
|
{
|
|
int[] dataArray = new int[1];
|
|
dataArray[0] = data;
|
|
Write(address, dataArray);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read a single int of data from the Modbus device.
|
|
/// </summary>
|
|
/// <param name="address">The starting register address.</param>
|
|
/// <param name="data">The read int data.</param>
|
|
public void Read(ushort address, ref int data)
|
|
{
|
|
int[] dataArray = new int[1];
|
|
Read(address, dataArray);
|
|
data = dataArray[0];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Write a single float of data to the Modbus device.
|
|
/// 1 uint = 2 registers.
|
|
/// </summary>
|
|
/// <param name="address">The starting register address.</param>
|
|
/// <param name="data">The float data to write.</param>
|
|
public void Write(ushort address, float data)
|
|
{
|
|
float[] dataArray = new float[1];
|
|
dataArray[0] = data;
|
|
Write(address, dataArray);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read a single float of data from the Modbus device.
|
|
/// </summary>
|
|
/// <param name="address">The starting register address.</param>
|
|
/// <param name="data">The read float data.</param>
|
|
public void Read(ushort address, ref float data)
|
|
{
|
|
float[] dataArray = new float[1];
|
|
Read(address, dataArray);
|
|
data = dataArray[0];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the MBAP header of the Modbus TCP command.
|
|
/// </summary>
|
|
/// <param name="command">The byte array for the Modbus TCP command.
|
|
/// The Modbus request bytes 7+ need to be set beforehand. The MBAP
|
|
/// header bytes 0 to 6 will be updated based on the request bytes.
|
|
/// </param>
|
|
private void SetHeader(byte[] command)
|
|
{
|
|
//Transaction ID
|
|
ushort transID = _TransactionID;
|
|
if (_TransactionID >= 65535)
|
|
{
|
|
//Rollover global transaction ID to 0.
|
|
_TransactionID = 0;
|
|
}
|
|
else
|
|
{
|
|
//Increment global transaction ID.
|
|
_TransactionID++;
|
|
}
|
|
command[0] = (byte)(transID >> 8);
|
|
command[1] = (byte)(transID & 0xFF);
|
|
|
|
//Protocol ID
|
|
command[2] = 0;
|
|
command[3] = 0;
|
|
|
|
//Length
|
|
ushort length = (ushort)(command.Length - 6);
|
|
command[4] = (byte)(length >> 8);
|
|
command[5] = (byte)(length & 0xFF);
|
|
|
|
//Unit ID
|
|
command[6] = 1;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks the Modbus response for errors.
|
|
/// </summary>
|
|
/// <param name="response">The Modbus response byte array.</param>
|
|
/// <param name="expectedSize">The expected response byte array length.</param>
|
|
/// <param name="command">The Modbus command byte array.</param>
|
|
private void ResponseErrorChecks(byte[] response, int expectedLength, byte[] command)
|
|
{
|
|
if (response.Length < expectedLength)
|
|
{
|
|
if (response.Length < 9)
|
|
{
|
|
throw new Exception("Invalid Modbus response.");
|
|
}
|
|
if ((response[7] & 0x80) > 0)
|
|
{
|
|
//Bit 7 set, indicating Modbus error
|
|
throw new Exception("Modbus exception code " + response[8] +
|
|
", " + GetExceptionCodeString(response[8]) + ".");
|
|
}
|
|
throw new Exception("Other Modbus response error.");
|
|
}
|
|
|
|
if (response[0] != command[0] || response[1] != command[1])
|
|
{
|
|
throw new Exception("Modbus transaction ID mismatch.");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the Modbus exception name.
|
|
/// </summary>
|
|
/// <param name="code">The exception code.</param>
|
|
/// <returns>The exception name.</returns>
|
|
private string GetExceptionCodeString(uint code) =>
|
|
code switch
|
|
{
|
|
1 => "Illegal Function",
|
|
2 => "Illegal Data Address",
|
|
3 => "Illegal Data Value",
|
|
4 => "Slave Device Failure",
|
|
5 => "Acknowledge",
|
|
6 => "Slave Device Busy",
|
|
7 => "Negative Acknowledge",
|
|
8 => "Memory Parity Error",
|
|
10 => "Gateway Path Unavailable",
|
|
11 => "Gateway Target Device Failed to Respond",
|
|
_ => ""
|
|
};
|
|
|
|
void IDisposable.Dispose() =>
|
|
Close();
|
|
|
|
}
|
|
|
|
internal static bool ReadAll(AppSettings appSettings, ILogger<Worker> logger)
|
|
{
|
|
LabJackT7Configuration configuration = appSettings.LabJackT7Configuration;
|
|
_ModbusTransmissionControlProtocolClient ??= new(configuration.InternetProtocolAddress, configuration.Port);
|
|
ReadAllAnalog(_ModbusTransmissionControlProtocolClient, logger);
|
|
ReadAllDigitalIO(_ModbusTransmissionControlProtocolClient, logger);
|
|
if (configuration.InternetProtocolAddress == "false")
|
|
ReadAllAnalogMux80(_ModbusTransmissionControlProtocolClient, logger);
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays "AINxx : Values" readings.
|
|
/// </summary>
|
|
/// <param name="startingAddress">Starting Modbus address of
|
|
/// readings.</param>
|
|
/// <param name="values">Float analog input (AIN) readings.</param>
|
|
private static void DisplayAnalogInputReadings(ILogger<Worker> logger, ushort startingAddress, float[] values)
|
|
{
|
|
for (int i = 0; i < values.Length; i++)
|
|
{
|
|
logger.LogInformation("AIN" + (startingAddress + i * 2) / 2 + " : " + values[i] + " V");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Displays all digital I/O readings.
|
|
/// </summary>
|
|
/// <param name="directions">Reading from T7 Modbus address
|
|
/// 2850 (DIO_DIRECTION).</param>
|
|
/// <param name="states">Reading from T7 Modbus address
|
|
/// 2800 (DIO_STATE).</param>
|
|
private static void DisplayDigitalIOReadings(ILogger<Worker> logger, uint directions, uint states)
|
|
{
|
|
string fioDirs = "";
|
|
string fioStates = "";
|
|
string eioDirs = "";
|
|
string eioStates = "";
|
|
string cioDirs = "";
|
|
string cioStates = "";
|
|
string mioDirs = "";
|
|
string mioStates = "";
|
|
|
|
for (int i = 0; i < 8; i++)
|
|
{
|
|
fioDirs += Convert.ToString((directions >> i) & 1);
|
|
fioStates += Convert.ToString((states >> i) & 1);
|
|
}
|
|
logger.LogInformation("FIO0-FIO7 directions = " + fioDirs + ", states = " + fioStates);
|
|
|
|
for (int i = 8; i < 16; i++)
|
|
{
|
|
eioDirs += Convert.ToString((directions >> i) & 1);
|
|
eioStates += Convert.ToString((states >> i) & 1);
|
|
}
|
|
logger.LogInformation("EIO0-EIO7 directions = " + eioDirs + ", states = " + eioStates);
|
|
|
|
for (int i = 16; i < 20; i++)
|
|
{
|
|
cioDirs += Convert.ToString((directions >> i) & 1);
|
|
cioStates += Convert.ToString((states >> i) & 1);
|
|
}
|
|
logger.LogInformation("CIO0-CIO3 directions = " + cioDirs + ", states = " + cioStates);
|
|
|
|
for (int i = 20; i < 23; i++)
|
|
{
|
|
mioDirs += Convert.ToString((directions >> i) & 1);
|
|
mioStates += Convert.ToString((states >> i) & 1);
|
|
}
|
|
logger.LogInformation("MIO0-MIO2 directions = " + mioDirs + ", states = " + mioStates);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Configures range, negative channel, resolution index and settling
|
|
/// time for all analog inputs.
|
|
/// AIN_ALL_RANGE, AIN_ALL_NEGATIVE_CH, AIN_ALL_RESOLUTION_INDEX, and
|
|
/// AIN_ALL_SETTLING_US registers/settings are documented here:
|
|
/// https://labjack.com/support/datasheets/t-series/ain
|
|
/// </summary>
|
|
/// <param name="mb">The ModbusTransmissionControlProtocolClient to the connected T7 </param>
|
|
/// <param name="range">AIN_ALL_RANGE setting.</param>
|
|
/// <param name="negativeChannel">AIN_ALL_NEGATIVE_CH setting.</param>
|
|
/// <param name="resolutionIndex">AIN_ALL_RESOLUTION_INDEX setting.</param>
|
|
/// <param name="settling">AIN_ALL_SETTLING_US setting.</param>
|
|
private static void ConfigureAllAnalog(ModbusTransmissionControlProtocolClient mb, float range, ushort negativeChannel, ushort resolutionIndex, float settling)
|
|
{
|
|
ushort address;
|
|
ushort uint16Value;
|
|
float float32Value;
|
|
|
|
// Configure all analog input ranges.
|
|
address = 43900; // 43900 = AIN_ALL_RANGE
|
|
float32Value = range;
|
|
mb.Write(address, float32Value);
|
|
|
|
// Configure all analog input negative channels.
|
|
address = 43902; // 43902 = AIN_ALL_NEGATIVE_CH
|
|
uint16Value = negativeChannel;
|
|
mb.Write(address, uint16Value);
|
|
|
|
// Configure all analog input resolution indexes.
|
|
address = 43903; // 43903 = AIN_ALL_RESOLUTION_INDEX
|
|
uint16Value = resolutionIndex;
|
|
mb.Write(address, uint16Value);
|
|
|
|
// Configure all analog input settling times.
|
|
address = 43904; // 43904 = AIN_ALL_SETTLING_US
|
|
float32Value = settling;
|
|
mb.Write(address, float32Value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Example that configures, reads and displays all the analog
|
|
/// inputs (AIN0-AIN13) on the T7.
|
|
/// Analog inputs (AIN) registers used are documented here:
|
|
/// https://labjack.com/support/datasheets/t-series/ain
|
|
/// </summary>
|
|
/// <param name="mb">The ModbusTransmissionControlProtocolClient to the connected T7.</param>
|
|
private static void ReadAllAnalog(ModbusTransmissionControlProtocolClient modbusTransmissionControlProtocolClient, ILogger<Worker> logger)
|
|
{
|
|
logger.LogInformation("Reading AIN0-AIN13.");
|
|
|
|
// Configure all analog inputs.
|
|
// Ranges = +/-10 to.
|
|
// Negative Channels = 199 (single-ended)
|
|
// Resolution Indexes = 8
|
|
// Settlings = 0 (auto)
|
|
ConfigureAllAnalog(modbusTransmissionControlProtocolClient, 10.0f, 199, 8, 0);
|
|
|
|
// Read all 14 analog inputs.
|
|
ushort startAddress = 0; // 0 = AIN0
|
|
float[] analogInputReadings = new float[14]; // 14 analog input readings
|
|
modbusTransmissionControlProtocolClient.Read(startAddress, analogInputReadings);
|
|
DisplayAnalogInputReadings(logger, startAddress, analogInputReadings);
|
|
|
|
logger.LogInformation("");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Example that reads and displays all the digital I/O (FIOs, EIOs,
|
|
/// CIOs, MIOs) on the T7.
|
|
/// Digital I/O registers used are documented here:
|
|
/// https://labjack.com/support/datasheets/t-series/digital-io
|
|
/// </summary>
|
|
/// <param name="modbusTransmissionControlProtocolClient">The ModbusTransmissionControlProtocolClient to the connected T7.</param>
|
|
private static void ReadAllDigitalIO(ModbusTransmissionControlProtocolClient modbusTransmissionControlProtocolClient, ILogger<Worker> logger)
|
|
{
|
|
logger.LogInformation("Reading FIOs, EIOs, CIOs and MIO directions and states.");
|
|
ushort address;
|
|
uint directions = 0;
|
|
uint states = 0;
|
|
|
|
// Read all digital I/O directions and states.
|
|
address = 2850; // 2850 = DIO_DIRECTION
|
|
modbusTransmissionControlProtocolClient.Read(address, ref directions);
|
|
address = 2800; // 2800 = DIO_STATE
|
|
modbusTransmissionControlProtocolClient.Read(address, ref states);
|
|
|
|
DisplayDigitalIOReadings(logger, directions, states);
|
|
|
|
logger.LogInformation("");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Example that configures, reads and displays all the analog
|
|
/// inputs on the T7 with a Mux80 (AIN0-AIN3, AIN48-AIN127).
|
|
/// Analog inputs (AIN) registers used are documented here:
|
|
/// https://labjack.com/support/datasheets/t-series/ain
|
|
/// Extended channels AIN48+ are further documented here:
|
|
/// https://labjack.com/support/datasheets/t-series/ain/extended-channels
|
|
/// Mux80 data sheet can be found here:
|
|
/// https://labjack.com/support/datasheets/accessories/mux80
|
|
/// </summary>
|
|
/// <param name="modbusTransmissionControlProtocolClient">The ModbusTransmissionControlProtocolClient to the connected T7.</param>
|
|
private static void ReadAllAnalogMux80(ModbusTransmissionControlProtocolClient modbusTransmissionControlProtocolClient, ILogger<Worker> logger)
|
|
{
|
|
|
|
// Many registers to channels are incorrect. Check with Steve.
|
|
|
|
logger.LogInformation("Reading AIN0-AIN3, AIN48-AIN127.");
|
|
|
|
// Configure all analog inputs.
|
|
// Ranges = +/-10 to.
|
|
// Negative Channels = 199 (single-ended)
|
|
// Resolution Indexes = 1
|
|
// Settlings = 0 (auto)
|
|
ConfigureAllAnalog(modbusTransmissionControlProtocolClient, 10.0f, 199, 1, 0);
|
|
|
|
//Reading from 84 analog inputs with the Mux80.
|
|
ushort startAddress;
|
|
float[] analogInputReadings;
|
|
|
|
// Read from AIN0-AIN3 on the T7 terminals.
|
|
startAddress = 0; // 0 = AIN0
|
|
analogInputReadings = new float[4]; // 4 analog input readings.
|
|
modbusTransmissionControlProtocolClient.Read(startAddress, analogInputReadings);
|
|
DisplayAnalogInputReadings(logger, startAddress, analogInputReadings);
|
|
|
|
// Read from AIN48-AIN87 on Mux80.
|
|
startAddress = 96; // 96 = AIN48
|
|
analogInputReadings = new float[40]; // 40 analog input readings
|
|
modbusTransmissionControlProtocolClient.Read(startAddress, analogInputReadings);
|
|
DisplayAnalogInputReadings(logger, startAddress, analogInputReadings);
|
|
|
|
// Read from AIN88-AIN127 on Mux80.
|
|
startAddress = 176; // 176 = AIN88
|
|
analogInputReadings = new float[40]; // 40 analog input readings
|
|
modbusTransmissionControlProtocolClient.Read(startAddress, analogInputReadings);
|
|
DisplayAnalogInputReadings(logger, startAddress, analogInputReadings);
|
|
|
|
logger.LogInformation("");
|
|
}
|
|
|
|
} |