private void writeStringVal(Tag tag, Libplctag client, String value, bool print)
{
for (int i = 0; i < tag.ElementCount; i++)
{
Console.WriteLine($"element count: {tag.ElementCount}");
Console.WriteLine($"write iteration {i}");
byte[] asciiBytes = new byte[tag.ElementSize];
byte[] byteArr = Encoding.ASCII.GetBytes(value);
for (int j = 0; j < value.Length; j++)
{
asciiBytes[j] = byteArr[j];
}
string bytes = "";
for (int m = 0; m < asciiBytes.Length; m++)
{
bytes += asciiBytes[m] + "\t";
}
MessageBox.Show($"asciibytes = {bytes}");
setStringLength(tag, client, (Int16)value.Length);
for (int k = 0; k < tag.ElementSize; k++)
{
client.SetUint8Value(tag, (i * tag.ElementSize) + k + 4, asciiBytes[k]);
}
if (print)
{
readStringVal(tag, client);
}
}
}
private void readFloat32Val(Tag tag, Libplctag client)
{
var sb = new StringBuilder();
for (int i = 0; i < tag.ElementCount; i++)
{
sb.Append($"{tag.Name} = {client.GetFloat32Value(tag, (i * tag.ElementSize))}\n");
}
MessageBox.Show(sb.ToString(), "Information", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
private void writeInt16Val(Tag tag, Libplctag client, Int16 value, bool print)
{
for (int i = 0; i < tag.ElementCount; i++)
{
client.SetInt16Value(tag, (i * tag.ElementSize), value);
}
if (print)
{
readInt16Val(tag, client);
}
}
private void writeFloat32Val(Tag tag, Libplctag client, float value, bool print)
{
var sb = new StringBuilder();
for (int i = 0; i < tag.ElementCount; i++)
{
client.SetFloat32Value(tag, (i * tag.ElementSize), value);
}
if (print)
{
readFloat32Val(tag, client);
}
}
static void writeToTag(String tagName, int value)
{
var tag = new Tag(PLC_IP, "1, 0", CpuType.LGX, tagName, DataType.Int32, 1);
var client = new Libplctag();
client.AddTag(tag);
while (client.GetStatus(tag) == Libplctag.PLCTAG_STATUS_PENDING)
{
Thread.Sleep(100);
}
if (client.GetStatus(tag) != Libplctag.PLCTAG_STATUS_OK)
{
Console.WriteLine($"Error setting up tag internal state. Error{ client.DecodeError(client.GetStatus(tag))}\n");
return;
}
client.SetInt32Value(tag, 0 * tag.ElementSize, value);
var result = client.WriteTag(tag, 2000);
if (result != Libplctag.PLCTAG_STATUS_OK)
{
if (retry < 2)
{
Console.WriteLine("ERROR!");
Console.WriteLine("Retrying....");
Thread.Sleep(500);
retry++;
writeToTag(tagName, value);
}
else
{
Console.WriteLine("Retry Failed! Start over!");
retry = 0;
return;
}
}
else
{
retry = 0;
}
if (value == 1 && tagName.Contains("SOL"))
{
writeToTag(tagName, 0);
}
}
private void readStringVal(Tag tag, Libplctag client)
{
for (int i = 0; i < tag.ElementCount; i++)
{
Console.WriteLine($"read element count: {tag.ElementCount}");
Console.WriteLine($"read iteration {i}");
byte[] asciiBytes = new byte[tag.ElementSize];
var sb = new StringBuilder();
for (int j = 0; j < tag.ElementSize; j++)
{
sb.Append((char)client.GetUint8Value(tag, (i * tag.ElementSize) + j));
}
string s = sb.ToString();
string pattern = "[^ -~]+";
Regex reg_exp = new Regex(pattern);
string output = reg_exp.Replace(s, " ");
MessageBox.Show($"string {i} = {output}");
}
}
static void Main(string[] args)
{
client = new Libplctag();
var tag1 = new Tag("192.168.0.100", CpuType.SLC, "F8:0", DataType.Float32, 1);
var tag2 = new Tag("192.168.0.100", CpuType.SLC, "N7:0", DataType.Int16, 20);
var tag3 = new Tag("192.168.0.100", CpuType.SLC, "B3:0", DataType.Int16, 10);
var tag4 = new Tag("192.168.0.100", CpuType.SLC, "O0:0.0", DataType.Int16, 5);
var tags = new List <Tag>()
{
tag1, tag2, tag3, tag4
};
foreach (var tag in tags)
{
client.AddTag(tag);
var status = client.GetStatus(tag);
if (status != Libplctag.PLCTAG_STATUS_OK)
{
LogError($"{tag.Name} Error setting up tag internal state. Error {status}");
return;
}
}
timer = new System.Timers.Timer();
timer.Interval = 1000;
timer.Elapsed += OnTimerTick;
timer.Enabled = true;
var noError = true;
while (noError)
{
Console.WriteLine(DateTime.Now);
noError = RefreshTags(tags, client);
Thread.Sleep(100);
}
Console.ReadKey();
}
static void Main(string[] args)
{
var client = new Libplctag();
var tag = new Tag("192.168.0.100", CpuType.SLC, "ST48:0", DataType.String, 1);
client.AddTag(tag);
if (client.GetStatus(tag) != Libplctag.PLCTAG_STATUS_OK)
{
LogError($"{tag.Name} Error setting up tag internal state. Error {client.DecodeError(client.GetStatus(tag))}\n");
return;
}
/* get the data */
var rc = client.ReadTag(tag, DataTimeout);
if (rc != Libplctag.PLCTAG_STATUS_OK)
{
LogError($"{tag.Name} ERROR: Unable to read the data! Got error code {rc}: {client.DecodeError(rc)}\n");
return;
}
/* print out the data */
for (int i = 0; i < tag.ElementCount; i++)
{
var sb = new StringBuilder();
for (int j = 0; j < tag.ElementSize; j++)
{
sb.Append((char)client.GetUint8Value(tag, (i * tag.ElementSize) + j));
}
Console.WriteLine($"string {i} ({82} chars) = {sb.ToString()}\n");
}
client.Dispose();
Console.ReadKey();
}
static int readFromTag(String tagName)
{
int val = 0;
var tag = new Tag(PLC_IP, "1, 0", CpuType.LGX, tagName, DataType.Int32, 1);
var client = new Libplctag();
client.AddTag(tag);
while (client.GetStatus(tag) == Libplctag.PLCTAG_STATUS_PENDING)
{
Thread.Sleep(100);
}
if (client.GetStatus(tag) != Libplctag.PLCTAG_STATUS_OK)
{
Console.WriteLine($"Error setting up tag internal state. Error{ client.DecodeError(client.GetStatus(tag))}\n");
return(-1);
}
var result = client.ReadTag(tag, 2000);
// Check the read operation result
if (result != Libplctag.PLCTAG_STATUS_OK)
{
Console.WriteLine($"ERROR: Unable to read the data! Got error code {result}: {client.DecodeError(result)}\n");
return(-1);
}
// Convert the data
val = client.GetInt32Value(tag, 0 * tag.ElementSize);
return(val);
}
// plc connect button
private void connectButton_Click(object sender, EventArgs e)
{
// set up tag and communication with plc
PLCommunication comm = new PLCommunication(IPAddTextBox.Text.Trim(), (PathComboBox.SelectedIndex + 1).ToString().Trim(),
SlotTextBox.Text.Trim(), CpuTypeComboBox.Text.Trim(), TagNameTextBox.Text.Trim(), DataTypeComboBox.Text,
Int32.Parse(ElementCountTextBox.Text), writeCheckBox.Checked, WriteValueTextBox.Text);
// create instance of plc client
var client = new Libplctag();
// create the tag
var tag = new Tag(comm.ipAddress, comm.path, comm.cput, comm.tagname, comm.dtInt, comm.elemCount);
if (comm.cput != CpuType.LGX)
{
tag = new Tag(comm.ipAddress, comm.cput, comm.tagname, comm.dtInt, comm.elemCount);
}
// add the tag
client.AddTag(tag);
// check that the tag has been added, if it returns pending then retry
while (client.GetStatus(tag) == Libplctag.PLCTAG_STATUS_PENDING)
{
Thread.Sleep(100);
}
// if the status is not ok, then handle error
if (client.GetStatus(tag) != Libplctag.PLCTAG_STATUS_OK)
{
MessageBox.Show($"ERROR: Unable to set up tag internal state.\n {client.DecodeError(client.GetStatus(tag))}\n", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
// determine if reading or writing to plc
if (writeCheckBox.Checked)
{
// writing to plc
switch (DataTypeComboBox.Text)
{
case "Int8":
writeInt8Val(tag, client, sbyte.Parse(comm.valToWrite), true);
break;
case "Int16":
writeInt16Val(tag, client, Convert.ToInt16(comm.valToWrite), true);
break;
case "Int32":
writeInt32Val(tag, client, Convert.ToInt32(comm.valToWrite), true);
break;
case "Float32":
writeFloat32Val(tag, client, float.Parse(comm.valToWrite), true);
break;
case "String":
writeStringVal(tag, client, comm.valToWrite, true);
break;
default:
MessageBox.Show("Invalid Data Type", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
break;
}
// write the values
var result = client.WriteTag(tag, DataTimeout);
if (result != Libplctag.PLCTAG_STATUS_OK)
{
MessageBox.Show($"Error: Unable to read the data. Got error code {result}: {client.DecodeError(result)}\n");
return;
}
}
else if (!writeCheckBox.Checked)
{
// reading from plc
var result = client.ReadTag(tag, DataTimeout);
if (result != Libplctag.PLCTAG_STATUS_OK)
{
MessageBox.Show($"Error: Unable to read the data. Got error code {result}: {client.DecodeError(result)}\n");
return;
}
switch (DataTypeComboBox.Text)
{
case "Int8":
readInt8Val(tag, client);
break;
case "Int16":
readInt16Val(tag, client);
break;
case "Int32":
readInt32Val(tag, client);
break;
case "Float32":
readFloat32Val(tag, client);
break;
case "String":
readStringVal(tag, client);
break;
default:
MessageBox.Show("Invalid Data Type", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
break;
}
}
else
{
// no defined action: reading/writing
MessageBox.Show("Error: No defined action.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
// close and cleanup resources
client.Dispose();
Console.Read();
}
static void Main(string[] args)
{
var client = new Libplctag();
const string PLC_IP = "192.168.10.10";
const string PLC_PATH = "1, 0";
const CpuType PLC_TYPE = CpuType.LGX;
var TAG_CONTROL_WORD = new Tag(PLC_IP, PLC_PATH, PLC_TYPE, "CONTROL_WORD", DataType.Int32, 1);
var TAG_SHELL_LENGTH = new Tag(PLC_IP, PLC_PATH, PLC_TYPE, "SHELL_LENGTH", DataType.Float32, 1);
var TAG_STATUS_WORD = new Tag(PLC_IP, PLC_PATH, PLC_TYPE, "STATUS_WORD", DataType.DINT, 1);
var TAG_PC_HEARTBEAT = new Tag(PLC_IP, PLC_PATH, PLC_TYPE, "PC_HEARTBEAT", DataType.Int8, 1);
var TAG_MOVE_HOME = new Tag(PLC_IP, PLC_PATH, PLC_TYPE, "MOVE_HOME", DataType.SINT, 1);
var TAG_LINTY = new Tag(PLC_IP, PLC_PATH, PLC_TYPE, "LINTY", DataType.LINT, 1);
var tags = new List <Tag> {
TAG_CONTROL_WORD,
TAG_SHELL_LENGTH,
TAG_STATUS_WORD,
TAG_PC_HEARTBEAT,
TAG_MOVE_HOME,
TAG_LINTY,
};
/* create the tag(s) */
foreach (var tag in tags)
{
client.AddTag(tag);
}
/* let the connect succeed we hope */
foreach (var tag in tags)
{
while (client.GetStatus(tag) == Libplctag.PLCTAG_STATUS_PENDING)
{
Thread.Sleep(100);
}
if (client.GetStatus(tag) != Libplctag.PLCTAG_STATUS_OK)
{
Console.WriteLine($"Error setting up '{tag.Name}' internal state. Error {client.DecodeError(client.GetStatus(tag))}\n");
return;
}
}
/* get the data */
int rc;
foreach (var tag in tags)
{
rc = client.ReadTag(tag, DataTimeout);
if (rc != Libplctag.PLCTAG_STATUS_OK)
{
Console.WriteLine($"ERROR: Unable to read the '{tag.Name}' data! Got error code {rc}: {client.DecodeError(client.GetStatus(tag))}\n");
return;
}
}
/* print out the data */
Console.WriteLine("\n\n{{{{{{{{{{{{{{{{{{{{{\n");
Console.WriteLine($"initial 'CONTROL_WORD' = { client.GetUint32Value(TAG_CONTROL_WORD, 0)}\n");
Console.WriteLine($"initial 'SHELL_LENGTH' = { client.GetFloat32Value(TAG_SHELL_LENGTH, 0)}\n");
Console.WriteLine($"initial 'STATUS_WORD' = { client.GetUint32Value(TAG_STATUS_WORD, 0)}\n");
Console.WriteLine($"initial 'PC_HEARTBEAT' = { client.GetUint8Value(TAG_PC_HEARTBEAT, 0)}\n");
Console.WriteLine($"initial 'MOVE_HOME' = { client.GetBitValue(TAG_MOVE_HOME, -1, DataTimeout)}\n");
Console.WriteLine($"initial 'LINTY' = { client.GetUint64Value(TAG_LINTY, 0)}\n");
Console.WriteLine($"initial 'CONTROL_WORD.2 (JOG_REV)' = { client.GetBitValue(TAG_CONTROL_WORD, 2, DataTimeout)}\n");
Console.WriteLine("---------------------\n");
/* now test a write */
/* TAG_CONTROL_WORD */
var controlVal = client.GetUint32Value(TAG_CONTROL_WORD, 0);
if (controlVal == 0)
{
controlVal = 1;
}
else
{
controlVal = controlVal * 2;
}
Console.WriteLine($"setting 'CONTROL_WORD' = {controlVal}\n");
client.SetUint32Value(TAG_CONTROL_WORD, 0, controlVal);
/* TAG_SHELL_LENGTH */
float shellLenVal = client.GetFloat32Value(TAG_SHELL_LENGTH, 0);
shellLenVal = shellLenVal + (float)0.25;
Console.WriteLine($"setting 'SHELL_LENGTH' = {shellLenVal}\n");
client.SetFloat32Value(TAG_SHELL_LENGTH, 0, shellLenVal);
/* TAG_STATUS_WORD */
var statusVal = client.GetUint32Value(TAG_STATUS_WORD, 0);
if (statusVal == 0)
{
statusVal = 1;
}
else
{
statusVal = statusVal * 2;
}
Console.WriteLine($"setting 'STATUS_WORD' = {statusVal}\n");
client.SetUint32Value(TAG_STATUS_WORD, 0, statusVal);
/* TAG_PC_HEARTBEAT */
byte pcHeartbeatByteVal = client.GetUint8Value(TAG_PC_HEARTBEAT, 0);
bool pcHeartbeatBitVal = Convert.ToBoolean(pcHeartbeatByteVal);
pcHeartbeatBitVal = !pcHeartbeatBitVal;
pcHeartbeatByteVal = Convert.ToByte(pcHeartbeatBitVal);
Console.WriteLine($"setting 'PC_HEARTBEAT' = {pcHeartbeatByteVal}\n");
client.SetUint8Value(TAG_PC_HEARTBEAT, 0, pcHeartbeatByteVal);
/* TAG_MOVE_HOME */
bool moveHomeVal = client.GetBitValue(TAG_MOVE_HOME, -1, DataTimeout);
moveHomeVal = !moveHomeVal;
Console.WriteLine($"setting 'MOVE_HOME' = {moveHomeVal}\n");
rc = client.SetBitValue(TAG_MOVE_HOME, -1, moveHomeVal, DataTimeout);
if (rc != Libplctag.PLCTAG_STATUS_OK)
{
LogError($"ERROR: Unable to write the 'MOVE_HOME' data! Got error code {rc}: {client.DecodeError(rc)}\n");
return;
}
/* TAG_LINTY */
var lintyVal = client.GetUint64Value(TAG_LINTY, 0);
if (lintyVal == 0)
{
lintyVal = 1;
}
else
{
lintyVal = lintyVal * 2;
}
Console.WriteLine($"setting 'LINTY' = {lintyVal}\n");
client.SetUint64Value(TAG_LINTY, 0, lintyVal);
/* TAG_CONTROL_WORD.2 (JOG_REV) */
bool jogRevVal = client.GetBitValue(TAG_CONTROL_WORD, 2, DataTimeout);
jogRevVal = !jogRevVal;
Console.WriteLine($"setting 'CONTROL_WORD.2 (JOG_REV)' = {jogRevVal}\n");
rc = client.SetBitValue(TAG_CONTROL_WORD, 2, jogRevVal, DataTimeout);
if (rc != Libplctag.PLCTAG_STATUS_OK)
{
LogError($"ERROR: Unable to write the 'CONTROL_WORD.2 (JOG_REV)' data! Got error code {rc}: {client.DecodeError(rc)}\n");
return;
}
foreach (var tag in tags)
{
rc = client.WriteTag(tag, DataTimeout);
if (rc != Libplctag.PLCTAG_STATUS_OK)
{
if (rc == Libplctag.PLCTAG_ERR_NOT_ALLOWED)
{
Console.WriteLine($"READ-ONLY TAG: Unable to write the '{tag.Name}' data! Got error code {rc}: {client.DecodeError(rc)}\n");
continue;
}
LogError($"ERROR: Unable to write the '{tag.Name}' data! Got error code {rc}: {client.DecodeError(rc)}\n");
return;
}
}
Console.WriteLine("=====================\n");
/* get the data again */
foreach (var tag in tags)
{
rc = client.ReadTag(tag, DataTimeout);
if (rc != Libplctag.PLCTAG_STATUS_OK)
{
LogError($"ERROR: Unable to read the '{tag.Name}' data! Got error code {rc}: {client.DecodeError(rc)}\n");
return;
}
}
/* print out the data */
Console.WriteLine($"latest 'CONTROL_WORD' = { client.GetUint32Value(TAG_CONTROL_WORD, 0) }\n");
Console.WriteLine($"latest 'SHELL_LENGTH' = { client.GetFloat32Value(TAG_SHELL_LENGTH, 0) }\n");
Console.WriteLine($"latest 'STATUS_WORD' = { client.GetUint32Value(TAG_STATUS_WORD, 0) }\n");
Console.WriteLine($"latest 'PC_HEARTBEAT' = { client.GetUint8Value(TAG_PC_HEARTBEAT, 0) }\n");
Console.WriteLine($"latest 'MOVE_HOME' = { client.GetBitValue(TAG_MOVE_HOME, -1, DataTimeout) }\n");
Console.WriteLine($"latest 'LINTY' = { client.GetUint64Value(TAG_LINTY, 0) }\n");
Console.WriteLine($"latest 'CONTROL_WORD.2 (JOG_REV)' = { client.GetBitValue(TAG_CONTROL_WORD, 2, DataTimeout) }\n");
Console.WriteLine("}}}}}}}}}}}}}}}}}}}}}\n");
client.Dispose();
//Console.ReadKey();
}
public void readdata()
{
//var watch = new System.Diagnostics.Stopwatch();
//watch.Start();
try
{
// creates a tag to read B3:0, 1 item, from LGX ip address 192.168.0.100
// The last entry in this new tag is the element count. It is currently
// set to 1
//public Tag(string ipAddress, string path, CpuType cpuType, string name, int elementSize, int elementCount, int debugLevel = 0)
//string name is the textual name of the tag in plc
//elementSize is the size of the element in bytes
//elementCount elements count: 1- single, n-array
//public Tag(string ipAddress, string path, CpuType cpuType, string name, int elementSize, int elementCount, int debugLevel = 0)
var tag = new Tag("10.14.6.100", "1, 0", CpuType.LGX, "REPORT_INT[0]", 2, 15, 0);
var tag1 = new Tag("10.14.6.100", "1, 0", CpuType.LGX, "REPORT_FLOAT[0]", 4, 14, 0);
using (var client = new Libplctag())
{
// add the tag
client.AddTag(tag);
client.AddTag(tag1);
//client.AddTag(tag2);
// check that the tag has been added, if it returns pending we have to retry
while (client.GetStatus(tag) == Libplctag.PLCTAG_STATUS_PENDING)
{
Thread.Sleep(100);
}
// check that the tag has been added, if it returns pending we have to retry
while (client.GetStatus(tag1) == Libplctag.PLCTAG_STATUS_PENDING)
{
Thread.Sleep(100);
}
// if the status is not ok, we have to handle the error
if (client.GetStatus(tag) != Libplctag.PLCTAG_STATUS_OK)
{
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\Users\KE_PLCData\Documents\ReportErrorLogging\ErrorLog.txt", true))
{
file.WriteLine("Error occured at: " + DateTime.Now + Convert.ToString((client.GetStatus(tag))) + ("\n" + $"Five Minute Data tag 5 Read Error setting up tag internal state. Error{ client.DecodeError(client.GetStatus(tag))}\n"));
}
return;
}
// if the status is not ok, we have to handle the error
if (client.GetStatus(tag1) != Libplctag.PLCTAG_STATUS_OK)
{
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\Users\KE_PLCData\Documents\ReportErrorLogging\ErrorLog.txt", true))
{
file.WriteLine("Error occured at: " + DateTime.Now + Convert.ToString((client.GetStatus(tag1))) + ("\n" + $"Five Minute Data tag 5 Read Error setting up tag internal state. Error{ client.DecodeError(client.GetStatus(tag1))}\n"));
}
return;
}
// Execute the read
var result = client.ReadTag(tag, DataTimeout);
// Execute the read
var result1 = client.ReadTag(tag1, DataTimeout);
// Execute the read
//var result2 = client.ReadTag(tag2, DataTimeout);
// Check the read operation result
if (result != Libplctag.PLCTAG_STATUS_OK)
{
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\Users\KE_PLCData\Documents\ReportErrorLogging\ErrorLog.txt", true))
{
file.WriteLine("Error occured at: " + DateTime.Now + Convert.ToString(($"Five Minute Data Read ERROR: Unable to read the data! Got error code {result}: {client.DecodeError(result)}\n")));
}
return;
}
if (result1 != Libplctag.PLCTAG_STATUS_OK)
{
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\Users\KE_PLCData\Documents\ReportErrorLogging\ErrorLog.txt", true))
{
file.WriteLine("Error occured at: " + DateTime.Now + Convert.ToString(($"Five Minute Data Read ERROR: Unable to read the data! Got error code {result1}: {client.DecodeError(result1)}\n")));
}
return;
}
dh = new SQLDataHandler();
//dr = dh.getReader("Select schrunmins, shiftstarttime FROM ConfigurationSettings Where plantname = 'Kanawha Eagle';");
//dr.Read();
//int schrunmins = (int)dr["schrunmins"];
// Convert the data
var plantairpressure = client.GetInt16Value(tag, 0 * tag.ElementSize);
var thickenerunderflowpsi = client.GetInt16Value(tag, 1 * tag.ElementSize);
var thickenerrotationtorque = client.GetInt16Value(tag, 2 * tag.ElementSize);
var thickenerunderflowgpm = client.GetInt16Value(tag, 3 * tag.ElementSize);
var screenbowl1amps = client.GetInt16Value(tag, 4 * tag.ElementSize);
var screenbowl1torque = client.GetInt16Value(tag, 5 * tag.ElementSize);
var screenbowl2amps = client.GetInt16Value(tag, 6 * tag.ElementSize);
var screenbowl2torque = client.GetInt16Value(tag, 7 * tag.ElementSize);
var plantfeedtph = client.GetInt16Value(tag, 8 * tag.ElementSize);
var cleancoaltph = client.GetInt16Value(tag, 9 * tag.ElementSize);
var stokertph = client.GetInt16Value(tag, 10 * tag.ElementSize);
var bypasstph = client.GetInt16Value(tag, 11 * tag.ElementSize);
var refusetph = client.GetInt16Value(tag, 12 * tag.ElementSize);
var scalpedtph = client.GetInt16Value(tag, 13 * tag.ElementSize);
var slurrytph = client.GetInt16Value(tag, 14 * tag.ElementSize);
var thickenerunderflowsg = client.GetFloat32Value(tag1, 0 * tag1.ElementSize);
var thickenerrotationamps = client.GetFloat32Value(tag1, 1 * tag1.ElementSize);
//var hmvsg = client.GetFloat32Value(tag1, 2 * tag1.ElementSize);
//var hmvsgsetpoint = client.GetFloat32Value(tag1, 3 * tag1.ElementSize);
var hmcyclonesg = client.GetFloat32Value(tag1, 4 * tag1.ElementSize);
var hmcyclone1sgsetpoint = client.GetFloat32Value(tag1, 5 * tag1.ElementSize);
var yield = client.GetFloat32Value(tag1, 6 * tag1.ElementSize);
var hmcyclone1psi = client.GetFloat32Value(tag1, 7 * tag1.ElementSize);
var hmcyclone2psi = client.GetFloat32Value(tag1, 8 * tag1.ElementSize);
var deslimecyclonepsi = client.GetFloat32Value(tag1, 9 * tag1.ElementSize);
var ccclasscyclonepsi = client.GetFloat32Value(tag1, 10 * tag1.ElementSize);
var rawcoalcyclonepsi = client.GetFloat32Value(tag1, 11 * tag1.ElementSize);
var magscrewtotalrunmins = client.GetFloat32Value(tag1, 12 * tag1.ElementSize);
var plantfeedtotalrunmins = client.GetFloat32Value(tag1, 13 * tag1.ElementSize);
try
{
dh.executeSql("Insert INTO TrendingData(created_at, plantair, thickenerunderpsi, thickenertorque, thickenerunderflow, thickenergravity, thickeneramps, screenbowl1amps, " +
"screenbowl1torque, screenbowl2amps, screenbowl2torque, hmcyclonesg1, hmcyclone1sgsetpoint, hmcyclone1psi, " +
"hmcyclone2psi, deslimecyclonepsi, ccclasscyclonepsi, rawcoalcyclonepsi, yield, plantfeedtph, cleantph, stokertph, bypasstph, reftph, scalpedtph, " +
"slurrytph) VALUES (GETDATE(), '" + plantairpressure + "', '" + thickenerunderflowpsi + "', '" + thickenerrotationtorque + "', '" + thickenerunderflowgpm + "', '" + thickenerunderflowsg + "', '" + thickenerrotationamps +
"', '" + screenbowl1amps + "', '" + screenbowl1torque + "', '" + screenbowl2amps + "', '" + screenbowl2torque + "', '" + hmcyclonesg + "', '" + hmcyclone1sgsetpoint +
"', '" + hmcyclone1psi + "', '" + hmcyclone2psi + "', '" + deslimecyclonepsi + "', '" + ccclasscyclonepsi + "', '" + rawcoalcyclonepsi + "', '" + yield +
"', '" + plantfeedtph + "', '" + cleancoaltph + "', '" + stokertph + "', '" + bypasstph + "', '" + refusetph + "', '" + scalpedtph + "', '" + slurrytph + "')");
}
catch (SqlException se)
{
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\Users\KE_PLCData\Documents\ReportErrorLogging\ErrorLog.txt", true))
{
file.WriteLine("Error occurred at one minute data insert to database on: " + DateTime.Now + " \r\n" + se + "\r\n");
}
return;
}
client.RemoveTag(tag);
client.RemoveTag(tag1);
}
}
catch (Exception ex)
{
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\Users\KE_PLCData\Documents\ReportErrorLogging\ErrorLog.txt", true))
{
file.WriteLine("Error occurred at one minute data plc connection on: " + DateTime.Now + " \r\n" + ex + "\r\n");
}
return;
}
}
public void readData()
{
detail = new DetailedReport();
con = new PLCConnection();
setTimeRanges();
try
{
// creates a tag to read B3:0, 1 item, from LGX ip address 192.168.0.100
// The last entry in this new tag is the element count. It is currently
// set to 1
//public Tag(string ipAddress, string path, CpuType cpuType, string name, int elementSize, int elementCount, int debugLevel = 0)
//string name is the textual name of the tag in plc
//elementSize is the size of the element in bytes
//elementCount elements count: 1- single, n-array
//public Tag(string ipAddress, string path, CpuType cpuType, string name, int elementSize, int elementCount, int debugLevel = 0)
var tag5 = new Tag("10.14.6.100", "1, 0", CpuType.LGX, "REPORT_DINT[0]", 4, 6, 0);
var tag6 = new Tag("10.14.6.100", "1, 0", CpuType.LGX, "REPORT_FLOAT[12]", 4, 3, 0);
var tag12 = new Tag("10.14.6.100", "1, 0", CpuType.LGX, "REPORT_INT[8]", 2, 2, 0);
using (var client = new Libplctag())
{
// add the tag
client.AddTag(tag5);
client.AddTag(tag6);
client.AddTag(tag12);
//client.AddTag(tag2);
// check that the tag has been added, if it returns pending we have to retry
while (client.GetStatus(tag5) == Libplctag.PLCTAG_STATUS_PENDING)
{
Thread.Sleep(100);
}
// check that the tag has been added, if it returns pending we have to retry
while (client.GetStatus(tag6) == Libplctag.PLCTAG_STATUS_PENDING)
{
Thread.Sleep(100);
}
// check that the tag has been added, if it returns pending we have to retry
while (client.GetStatus(tag12) == Libplctag.PLCTAG_STATUS_PENDING)
{
Thread.Sleep(100);
}
// if the status is not ok, we have to handle the error
if (client.GetStatus(tag5) != Libplctag.PLCTAG_STATUS_OK)
{
con.setDownbit(-5);
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\Users\KE_PLCData\Documents\ReportErrorLogging\ErrorLog.txt", true))
{
file.WriteLine("Error occured at: " + DateTime.Now + Convert.ToString((client.GetStatus(tag5))) + ("\n" + $"Five Minute Data tag 5 Read Error setting up tag internal state. Error{ client.DecodeError(client.GetStatus(tag5))}\n"));
}
return;
}
// if the status is not ok, we have to handle the error
if (client.GetStatus(tag6) != Libplctag.PLCTAG_STATUS_OK)
{
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\Users\KE_PLCData\Documents\ReportErrorLogging\ErrorLog.txt", true))
{
file.WriteLine("Error occured at: " + DateTime.Now + Convert.ToString((client.GetStatus(tag6))) + ("\n" + $"Five Minute Data tag 6 Read Error setting up tag internal state. Error{ client.DecodeError(client.GetStatus(tag6))}\n"));
}
return;
}
// if the status is not ok, we have to handle the error
if (client.GetStatus(tag12) != Libplctag.PLCTAG_STATUS_OK)
{
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\Users\KE_PLCData\Documents\ReportErrorLogging\ErrorLog.txt", true))
{
file.WriteLine("Error occured at: " + DateTime.Now + Convert.ToString((client.GetStatus(tag12))) + ("\n" + $"Five Minute Data tag 6 Read Error setting up tag internal state. Error{ client.DecodeError(client.GetStatus(tag12))}\n"));
}
return;
}
// Execute the read
var result = client.ReadTag(tag5, DataTimeout);
// Execute the read
var result1 = client.ReadTag(tag6, DataTimeout);
// Execute the read
var result2 = client.ReadTag(tag12, DataTimeout);
// Check the read operation result
if (result != Libplctag.PLCTAG_STATUS_OK)
{
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\Users\KE_PLCData\Documents\ReportErrorLogging\ErrorLog.txt", true))
{
file.WriteLine("Error occured at: " + DateTime.Now + Convert.ToString(($"Five Minute Data Read ERROR: Unable to read the data! Got error code {result}: {client.DecodeError(result)}\n")));
}
return;
}
if (result1 != Libplctag.PLCTAG_STATUS_OK)
{
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\Users\KE_PLCData\Documents\ReportErrorLogging\ErrorLog.txt", true))
{
file.WriteLine("Error occured at: " + DateTime.Now + Convert.ToString(($"Five Minute Data Read ERROR: Unable to read the data! Got error code {result1}: {client.DecodeError(result1)}\n")));
}
return;
}
if (result2 != Libplctag.PLCTAG_STATUS_OK)
{
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\Users\KE_PLCData\Documents\ReportErrorLogging\ErrorLog.txt", true))
{
file.WriteLine("Error occured at: " + DateTime.Now + Convert.ToString(($"Five Minute Data Read ERROR: Unable to read the data! Got error code {result2}: {client.DecodeError(result2)}\n")));
}
return;
}
// read the data from the array that was retrieved from the PLC
//double integer values
var plantfeedtotaltons = client.GetInt32Value(tag5, 0 * tag5.ElementSize);
var cleancoaltotaltons = client.GetInt32Value(tag5, 1 * tag5.ElementSize);
var stokercoaltotaltons = client.GetInt32Value(tag5, 2 * tag5.ElementSize);
var bypasstotaltons = client.GetInt32Value(tag5, 3 * tag5.ElementSize);
var refusetotaltons = client.GetInt32Value(tag5, 4 * tag5.ElementSize);
var scalpedtotaltons = client.GetInt32Value(tag5, 5 * tag5.ElementSize);
//float values
//var yield = client.GetFloat32Value(tag6, 0 * tag6.ElementSize);
//mag minutes float 12 needs added to the desktop reporting
//grand total number like the coal values
var magmins = client.GetFloat32Value(tag6, 0 * tag6.ElementSize);
var plantfeedrunmins = client.GetFloat32Value(tag6, 1 * tag6.ElementSize);
var downminstotal = client.GetFloat32Value(tag6, 2 * tag6.ElementSize);
//int 16 values
var plantfeedtph = client.GetInt16Value(tag12, 0 * tag12.ElementSize);
var cleancoaltph = client.GetInt16Value(tag12, 1 * tag12.ElementSize);
//code about this needs to be here and this data from the PLC needs used for updating DetailedReport table
//it is at the top for hard code testing
detail = new DetailedReport();
detail.createDetailedReport(plantfeedtotaltons, cleancoaltotaltons, plantfeedtph, cleancoaltph, downminstotal, plantfeedrunmins, magmins);
try
{
//Insert data from PLC into FiveMinuteData table every five minute read
dh.executeSql("Insert INTO FiveMinuteData(created_at, plantname, plantfeedtons, cleantons, stokertons, bypasstons, refusetons, scalpedtons) VALUES " +
"(GETDATE(), 'Kanawha Eagle', '" + plantfeedtotaltons + "', '" + cleancoaltotaltons + "', '" + stokercoaltotaltons + "', '" + bypasstotaltons + "', '" +
refusetotaltons + "', '" + scalpedtotaltons + "')");
}catch (SqlException se)
{
//writing data to a text file to observe errors for troubleshooting
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\Users\KE_PLCData\Documents\ReportErrorLogging\ErrorLog.txt", true))
{
file.WriteLine("Error occurred at Five Minute Data insert to database: " + DateTime.Now + " \r\n" + se + "\r\n");
}
return;
}
client.RemoveTag(tag5);
client.RemoveTag(tag6);
}
}
catch (Exception ex)
{
//writing errors to text file for troubleshooting
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"C:\Users\KE_PLCData\Documents\ReportErrorLogging\ErrorLog.txt", true))
{
file.WriteLine("Error occurred at Five Minute Data insert to database: " + DateTime.Now + " \r\n" + ex + "\r\n");
}
return;
}
}
public void createConnection(string tagname, int bytesize, int numretrieved)
{
//var watch = new System.Diagnostics.Stopwatch();
//watch.Start();
try
{
dm = new DownTimeMonitoring();
// creates a tag to read B3:0, 1 item, from LGX ip address 192.168.0.100
// The last entry in this new tag is the element count. It is currently
// set to 1
//public Tag(string ipAddress, string path, CpuType cpuType, string name, int elementSize, int elementCount, int debugLevel = 0)
//string name is the textual name of the tag in plc
//elementSize is the size of the element in bytes
//elementCount elements count: 1- single, n-array
//public Tag(string ipAddress, string path, CpuType cpuType, string name, int elementSize, int elementCount, int debugLevel = 0)
var tagstatus = new Tag("10.14.6.100", "1, 0", CpuType.LGX, tagname, bytesize, numretrieved);
using (var client = new Libplctag())
{
// add the tag
client.AddTag(tagstatus);
// check that the tag has been added, if it returns pending we have to retry
while (client.GetStatus(tagstatus) == Libplctag.PLCTAG_STATUS_PENDING)
{
Thread.Sleep(100);
}
// if the status is not ok, we have to handle the error
if (client.GetStatus(tagstatus) != Libplctag.PLCTAG_STATUS_OK)
{
setDownbit(-5);
return;
}
// Execute the read
var result = client.ReadTag(tagstatus, DataTimeout);
Int16 checkError;
// Check the read operation result
if (result != Libplctag.PLCTAG_STATUS_OK)
{
setDownbit(-5);
return;
}
else
{
checkError = client.GetInt16Value(tagstatus, 0 * tagstatus.ElementSize);
setDownbit(checkError);
}
client.RemoveTag(tagstatus);
}
}
catch (Exception ex)
{
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@"c:\Users\KE_PLCData\Report Error Logging\ErrorLog.txt", true))
{
file.WriteLine("Error occurred with plc connection: " + DateTime.Now + " \r\n" + ex + "\r\n");
}
return;
}
}
private static bool RefreshTags(List <Tag> tags, Libplctag client)
{
foreach (var tag in tags)
{
if (tag.Name.StartsWith("F"))
{
/* get the data */
var rc = client.ReadTag(tag, DataTimeout);
if (rc != Libplctag.PLCTAG_STATUS_OK)
{
LogError(
$"{tag.Name} ERROR: Unable to read the data! Got error code {rc}: {client.DecodeError(rc)}");
return(false);
}
/* print out the data */
for (int i = 0; i < tag.ElementCount; i++)
{
Console.WriteLine($"{tag.Name} data[{i}]={client.GetFloat32Value(tag, (i*tag.ElementSize))}");
}
/* now test a write */
for (int i = 0; i < tag.ElementCount; i++)
{
var val = client.GetFloat32Value(tag, (i * tag.ElementSize));
val++;
if (val > 1000)
{
val = 0;
}
Console.WriteLine($"{tag.Name} Setting element {i} to {val}");
client.SetFloat32Value(tag, (i * tag.ElementSize), val);
}
rc = client.WriteTag(tag, DataTimeout);
if (rc != Libplctag.PLCTAG_STATUS_OK)
{
LogError(
$"{tag.Name} ERROR: Unable to read the data! Got error code {rc}: {client.DecodeError(rc)}");
return(false);
}
/* get the data again*/
rc = client.ReadTag(tag, DataTimeout);
if (rc != Libplctag.PLCTAG_STATUS_OK)
{
LogError(
$"{tag.Name} ERROR: Unable to read the data! Got error code {rc}: {client.DecodeError(rc)}");
return(false);
}
/* print out the data */
for (int i = 0; i < tag.ElementCount; i++)
{
Console.WriteLine($"{tag.Name} data[{i}]={client.GetFloat32Value(tag, (i*tag.ElementSize))}");
}
}
else
{
/* get the data */
var rc = client.ReadTag(tag, DataTimeout);
if (rc != Libplctag.PLCTAG_STATUS_OK)
{
LogError(
$"{tag.Name} ERROR: Unable to read the data! Got error code {rc}: {client.DecodeError(rc)}");
return(false);
}
/* print out the data */
for (int i = 0; i < tag.ElementCount; i++)
{
Console.WriteLine($"{tag.Name} data[{i}]={client.GetInt16Value(tag, (i*tag.ElementSize))}");
}
if (!tag.Name.Contains("O") && !tag.Name.Contains("I")) // we can't write on I/O
{
/* now test a write */
for (int i = 0; i < tag.ElementCount; i++)
{
var val = client.GetInt16Value(tag, (i * tag.ElementSize));
val++;
if (val > 1000)
{
val = 0;
}
Console.WriteLine($"{tag.Name} Setting element {i} to {val}");
client.SetInt16Value(tag, (i * tag.ElementSize), val);
}
rc = client.WriteTag(tag, DataTimeout);
if (rc != Libplctag.PLCTAG_STATUS_OK)
{
LogError(
$"{tag.Name} ERROR: Unable to write the data! Got error code {rc}: {client.DecodeError(rc)}");
return(false);
}
/* get the data again*/
rc = client.ReadTag(tag, DataTimeout);
if (rc != Libplctag.PLCTAG_STATUS_OK)
{
LogError(
$"{tag.Name} ERROR: Unable to read the data! Got error code {rc}: {client.DecodeError(rc)}");
return(false);
}
/* print out the data */
for (int i = 0; i < tag.ElementCount; i++)
{
Console.WriteLine($"{tag.Name} data[{i}]={client.GetInt16Value(tag, (i*tag.ElementSize))}");
}
}
}
}
return(true);
}
static void Main(string[] args)
{
var client = new Libplctag();
var tag = new Tag("192.168.0.100", CpuType.SLC, "B3:0", DataType.Int16, 1);
client.AddTag(tag);
var status = client.GetStatus(tag);
if (status != Libplctag.PLCTAG_STATUS_OK)
{
LogError($"Error setting up tag internal state. Error {status}");
return;
}
/* get the data */
var rc = client.ReadTag(tag, DataTimeout);
if (rc != Libplctag.PLCTAG_STATUS_OK)
{
LogError($"ERROR: Unable to read the data! Got error code {rc}: {client.DecodeError(rc)}");
return;
}
/* print out the data */
for (int i = 0; i < tag.ElementCount; i++)
{
Console.WriteLine($"data[{i}]={client.GetFloat32Value(tag, (i * tag.ElementSize))}");
}
/* now test a write */
for (int i = 0; i < tag.ElementCount; i++)
{
var val = client.GetFloat32Value(tag, (i * tag.ElementSize));
val++;
Console.WriteLine($"Setting element {i} to {val}");
client.SetFloat32Value(tag, (i * tag.ElementSize), val);
}
rc = client.WriteTag(tag, DataTimeout);
if (rc != Libplctag.PLCTAG_STATUS_OK)
{
LogError($"ERROR: Unable to read the data! Got error code {rc}: {client.DecodeError(rc)}");
return;
}
/* get the data again*/
rc = client.ReadTag(tag, DataTimeout);
if (rc != Libplctag.PLCTAG_STATUS_OK)
{
LogError($"ERROR: Unable to read the data! Got error code {rc}: {client.DecodeError(rc)}");
return;
}
/* print out the data */
for (int i = 0; i < tag.ElementCount; i++)
{
Console.WriteLine($"data[{i}]={client.GetFloat32Value(tag, (i * tag.ElementSize))}");
}
client.Dispose();
Console.ReadKey();
}
private void setStringLength(Tag tag, Libplctag client, Int16 valLength)
{
client.SetInt16Value(tag, (0 * tag.ElementSize), valLength);
}
static void Main(string[] args)
{
var client = new Libplctag();
var tag = new Tag("10.206.1.39", "1, 0", CpuType.LGX, "TestDINTArray[0]", DataType.Int32, 10);
/* create the tag */
client.AddTag(tag);
/* let the connect succeed we hope */
while (client.GetStatus(tag) == Libplctag.PLCTAG_STATUS_PENDING)
{
Thread.Sleep(100);
}
if (client.GetStatus(tag) != Libplctag.PLCTAG_STATUS_OK)
{
Console.WriteLine($"Error setting up tag internal state. Error {client.DecodeError(client.GetStatus(tag))}\n");
return;
}
/* get the data */
var rc = client.ReadTag(tag, DataTimeout);
if (rc != Libplctag.PLCTAG_STATUS_OK)
{
Console.WriteLine($"ERROR: Unable to read the data! Got error code {rc}: {client.DecodeError(client.GetStatus(tag))}\n");
return;
}
/* print out the data */
for (int i = 0; i < tag.ElementCount; i++)
{
Console.WriteLine($"data[{i}]={ client.GetInt32Value(tag, (i * tag.ElementSize))}\n");
}
/* now test a write */
for (int i = 0; i < tag.ElementCount; i++)
{
var val = client.GetInt32Value(tag, (i * tag.ElementSize));
val = val + 1;
Console.WriteLine($"Setting element {i} to {val}\n");
client.SetInt32Value(tag, (i * tag.ElementSize), val);
}
rc = client.WriteTag(tag, DataTimeout);
if (rc != Libplctag.PLCTAG_STATUS_OK)
{
LogError($"ERROR: Unable to read the data! Got error code {rc}: {client.DecodeError(rc)}\n");
return;
}
/* get the data again*/
rc = client.ReadTag(tag, DataTimeout);
if (rc != Libplctag.PLCTAG_STATUS_OK)
{
LogError($"ERROR: Unable to read the data! Got error code {rc}: {client.DecodeError(rc)}\n");
return;
}
/* print out the data */
for (int i = 0; i < tag.ElementCount; i++)
{
Console.WriteLine($"data[{0}]={1}\n", i, client.GetInt32Value(tag, (i * tag.ElementSize)));
}
client.Dispose();
Console.ReadKey();
}
