Samuele Locatelli
802 lines
30 KiB
C#
802 lines
30 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 S7.Net;
|
|
using System.Net.NetworkInformation;
|
|
using System.Net;
|
|
using NLog;
|
|
using System.Diagnostics;
|
|
|
|
namespace Test_S7
|
|
{
|
|
public partial class TestMainForm : Form
|
|
{
|
|
#region Private Fields
|
|
|
|
/// <summary>
|
|
/// indica se serva refresh parametri e quindi PLC...
|
|
/// </summary>
|
|
private bool needRefresh = true;
|
|
|
|
#endregion Private Fields
|
|
|
|
#region Protected Fields
|
|
|
|
/// <summary>
|
|
/// contenuto x log/debug
|
|
/// </summary>
|
|
protected string contenuto = "";
|
|
|
|
/// <summary>
|
|
/// Oggetto PLC da ri-utilizzare...
|
|
/// </summary>
|
|
protected Plc currPLC;
|
|
|
|
/// <summary>
|
|
/// Lungh massima stringhe
|
|
/// </summary>
|
|
protected int maxStrChar = 20;
|
|
|
|
/// <summary>
|
|
/// parametri di connessione
|
|
/// </summary>
|
|
protected connParam parametri;
|
|
|
|
/// <summary>
|
|
/// Oggetto cronometro x test vari...
|
|
/// </summary>
|
|
protected Stopwatch sw = new Stopwatch();
|
|
|
|
/// <summary>
|
|
/// titolo x log/debug
|
|
/// </summary>
|
|
protected string titolo = "";
|
|
|
|
#endregion Protected Fields
|
|
|
|
#region Public Fields
|
|
|
|
/// <summary>
|
|
/// oggetto logging
|
|
/// </summary>
|
|
public static Logger lg;
|
|
|
|
/// <summary>
|
|
/// Configurazione valori da LEGGERE dal PLC
|
|
/// </summary>
|
|
public otherData[] memMapR;
|
|
|
|
/// <summary>
|
|
/// Configurazione valori da SCRIVERE nel PLC
|
|
/// </summary>
|
|
public otherData[] memMapW;
|
|
|
|
/// <summary>
|
|
/// Byte dimensione buffer dati memoria (da file map)
|
|
/// </summary>
|
|
public int numByte = 0;
|
|
|
|
#endregion Public Fields
|
|
|
|
#region Public Constructors
|
|
|
|
public TestMainForm()
|
|
{
|
|
InitializeComponent();
|
|
|
|
myInit();
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Private Methods
|
|
|
|
private void btnCharWrite_Click(object sender, EventArgs e)
|
|
{
|
|
setParamPlc();
|
|
eseguiScritturaCharArray();
|
|
}
|
|
|
|
private void btnNumWriteB_Click(object sender, EventArgs e)
|
|
{
|
|
setParamPlc();
|
|
eseguiScritturaByte();
|
|
}
|
|
|
|
private void btnNumWriteDW_Click(object sender, EventArgs e)
|
|
{
|
|
setParamPlc();
|
|
eseguiScritturaDWord();
|
|
}
|
|
|
|
private void btnNumWriteReal_Click(object sender, EventArgs e)
|
|
{
|
|
setParamPlc();
|
|
eseguiScritturaReal();
|
|
}
|
|
|
|
private void btnNumWriteW_Click(object sender, EventArgs e)
|
|
{
|
|
setParamPlc();
|
|
eseguiScritturaWord();
|
|
}
|
|
|
|
private void btnReadByte_Click(object sender, EventArgs e)
|
|
{
|
|
setParamPlc();
|
|
eseguiLetturaByte();
|
|
}
|
|
|
|
private void btnReadChar_Click(object sender, EventArgs e)
|
|
{
|
|
setParamPlc();
|
|
eseguiLetturaCharArray();
|
|
}
|
|
|
|
private void btnReadDWord_Click(object sender, EventArgs e)
|
|
{
|
|
setParamPlc();
|
|
eseguiLetturaDWord();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Lettura real
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void btnReadReal_Click(object sender, EventArgs e)
|
|
{
|
|
setParamPlc();
|
|
eseguiLetturaReal();
|
|
}
|
|
|
|
private void btnReadString_Click(object sender, EventArgs e)
|
|
{
|
|
setParamPlc();
|
|
eseguiLetturaString();
|
|
}
|
|
|
|
private void btnReadWord_Click(object sender, EventArgs e)
|
|
{
|
|
setParamPlc();
|
|
eseguiLetturaWord();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Scrivo memoria tipo STRING
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
private void btnStrWrite_Click(object sender, EventArgs e)
|
|
{
|
|
setParamPlc();
|
|
eseguiScritturaString();
|
|
}
|
|
|
|
private void cbCpuType_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
needRefresh = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Esecuzione lettura!
|
|
/// </summary>
|
|
private void eseguiLetturaByte()
|
|
{
|
|
sw.Restart();
|
|
if (testCncConn())
|
|
{
|
|
// decodifico memoria...
|
|
memAddress memoria = new memAddress(txtMemArea.Text);
|
|
int numByte = 1;
|
|
int.TryParse(txtMemSize.Text, out numByte);
|
|
Byte[] memByteRead = currPLC.ReadBytes(DataType.DataBlock, memoria.DbNum, memoria.indiceMem, numByte);
|
|
titolo = string.Format("READ BLOCK MEM BYTE: {0} --> {1} byte", txtMemArea.Text, numByte);
|
|
contenuto = "";
|
|
string byteVal = "";
|
|
for (int i = 0; i < memByteRead.Length; i++)
|
|
{
|
|
byteVal = Convert.ToString(memByteRead[i], 2).PadLeft(8, '0');
|
|
contenuto += string.Format("B{0:000}: {1} | {2}{3}", i, byteVal, memByteRead[i], Environment.NewLine);
|
|
}
|
|
showOut(titolo, contenuto);
|
|
}
|
|
sw.Stop();
|
|
tslRTime.Text = string.Format("{0}", sw.Elapsed);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Esecuzione lettura tipo Char Array!
|
|
/// </summary>
|
|
private void eseguiLetturaCharArray()
|
|
{
|
|
sw.Restart();
|
|
if (testCncConn())
|
|
{
|
|
// decodifico memoria...
|
|
memAddress memoria = new memAddress(txtMemArea.Text);
|
|
int numByte = 1;
|
|
int.TryParse(txtMemSize.Text, out numByte);
|
|
Byte[] memByteRead = currPLC.ReadBytes(DataType.DataBlock, memoria.DbNum, memoria.indiceMem, numByte);
|
|
titolo = string.Format("READ BLOCK MEM CHAR[]: {0} --> {1} byte", txtMemArea.Text, numByte);
|
|
contenuto = "";
|
|
// poi prendo la stringa...
|
|
string outVal = "";
|
|
for (int i = 0; i < numByte; i++)
|
|
{
|
|
outVal += Char.ConvertFromUtf32(memByteRead[i]);
|
|
}
|
|
contenuto += string.Format("{0}{1}", outVal, Environment.NewLine);
|
|
showOut(titolo, contenuto);
|
|
}
|
|
sw.Stop();
|
|
tslRTime.Text = string.Format("{0}", sw.Elapsed);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Esecuzione lettura DWORD!
|
|
/// </summary>
|
|
private void eseguiLetturaDWord()
|
|
{
|
|
sw.Restart();
|
|
if (testCncConn())
|
|
{
|
|
// decodifico memoria...
|
|
memAddress memoria = new memAddress(txtMemArea.Text);
|
|
int numByte = 1;
|
|
int.TryParse(txtMemSize.Text, out numByte);
|
|
Byte[] memByteRead = currPLC.ReadBytes(DataType.DataBlock, memoria.DbNum, memoria.indiceMem, numByte);
|
|
titolo = string.Format("READ BLOCK MEM WORD: {0} --> {1} byte", txtMemArea.Text, numByte);
|
|
contenuto = "";
|
|
uint intVal = 0;
|
|
string byteValA = "";
|
|
string byteValB = "";
|
|
string byteValC = "";
|
|
string byteValD = "";
|
|
for (int i = 0; i < memByteRead.Length / 4; i++)
|
|
{
|
|
byteValA = Convert.ToString(memByteRead[i * 4], 2).PadLeft(8, '0');
|
|
byteValB = Convert.ToString(memByteRead[i * 4 + 1], 2).PadLeft(8, '0');
|
|
byteValC = Convert.ToString(memByteRead[i * 4 + 2], 2).PadLeft(8, '0');
|
|
byteValD = Convert.ToString(memByteRead[i * 4 + 3], 2).PadLeft(8, '0');
|
|
intVal = S7.Net.Types.DWord.FromByteArray(memByteRead.Skip(4 * i).Take(4).ToArray());
|
|
contenuto += string.Format("W{0:000}: {1} | {2}-{3}-{4}-{5}{6}", i, intVal, byteValA, byteValB, byteValC, byteValD, Environment.NewLine);
|
|
}
|
|
showOut(titolo, contenuto);
|
|
}
|
|
sw.Stop();
|
|
tslRTime.Text = string.Format("{0}", sw.Elapsed);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Esecuzione lettura Real!
|
|
/// </summary>
|
|
private void eseguiLetturaReal()
|
|
{
|
|
sw.Restart();
|
|
if (testCncConn())
|
|
{
|
|
// decodifico memoria...
|
|
memAddress memoria = new memAddress(txtMemArea.Text);
|
|
int numByte = 1;
|
|
int.TryParse(txtMemSize.Text, out numByte);
|
|
Byte[] memByteRead = currPLC.ReadBytes(DataType.DataBlock, memoria.DbNum, memoria.indiceMem, numByte);
|
|
titolo = string.Format("READ BLOCK MEM WORD: {0} --> {1} byte", txtMemArea.Text, numByte);
|
|
contenuto = "";
|
|
double realVal = 0;
|
|
string byteValA = "";
|
|
string byteValB = "";
|
|
string byteValC = "";
|
|
string byteValD = "";
|
|
for (int i = 0; i < memByteRead.Length / 4; i++)
|
|
{
|
|
byteValA = Convert.ToString(memByteRead[i * 4], 2).PadLeft(8, '0');
|
|
byteValB = Convert.ToString(memByteRead[i * 4 + 1], 2).PadLeft(8, '0');
|
|
byteValC = Convert.ToString(memByteRead[i * 4 + 2], 2).PadLeft(8, '0');
|
|
byteValD = Convert.ToString(memByteRead[i * 4 + 3], 2).PadLeft(8, '0');
|
|
realVal = S7.Net.Types.Double.FromByteArray(memByteRead.Skip(4 * i).Take(4).ToArray());
|
|
contenuto += string.Format("W{0:000}: {1} | {2}-{3}-{4}-{5}{6}", i, realVal, byteValA, byteValB, byteValC, byteValD, Environment.NewLine);
|
|
}
|
|
showOut(titolo, contenuto);
|
|
}
|
|
sw.Stop();
|
|
tslRTime.Text = string.Format("{0}", sw.Elapsed);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Esecuzione lettura tipo STRING!
|
|
/// </summary>
|
|
private void eseguiLetturaString()
|
|
{
|
|
sw.Restart();
|
|
if (testCncConn())
|
|
{
|
|
// decodifico memoria...
|
|
memAddress memoria = new memAddress(txtMemArea.Text);
|
|
int numByte = 1;
|
|
int.TryParse(txtMemSize.Text, out numByte);
|
|
Byte[] memByteRead = currPLC.ReadBytes(DataType.DataBlock, memoria.DbNum, memoria.indiceMem, numByte);
|
|
titolo = string.Format("READ BLOCK MEM STRING: {0} --> {1} byte", txtMemArea.Text, numByte);
|
|
contenuto = "";
|
|
string byteVal = "";
|
|
// i primi 2 byte sono LUNGHEZZA MAX e lungh effettiva quindi setto il NUM BYTE....
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
byteVal = Convert.ToString(memByteRead[i], 2).PadLeft(8, '0');
|
|
contenuto += string.Format("B{0:000}: {1} | {2}{3}", i, byteVal, memByteRead[i], Environment.NewLine);
|
|
}
|
|
// prendo 2° valore (num max valori)
|
|
numByte = memByteRead[1];
|
|
// poi prendo la stringa...
|
|
string outVal = "";
|
|
for (int i = 2; i < numByte + 2; i++)
|
|
{
|
|
outVal += Char.ConvertFromUtf32(memByteRead[i]);
|
|
}
|
|
contenuto += string.Format("{0}{1}", outVal, Environment.NewLine);
|
|
showOut(titolo, contenuto);
|
|
}
|
|
sw.Stop();
|
|
tslRTime.Text = string.Format("{0}", sw.Elapsed);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Esecuzione lettura WORD!
|
|
/// </summary>
|
|
private void eseguiLetturaWord()
|
|
{
|
|
sw.Restart();
|
|
if (testCncConn())
|
|
{
|
|
// decodifico memoria...
|
|
memAddress memoria = new memAddress(txtMemArea.Text);
|
|
int numByte = 1;
|
|
int.TryParse(txtMemSize.Text, out numByte);
|
|
Byte[] memByteRead = currPLC.ReadBytes(DataType.DataBlock, memoria.DbNum, memoria.indiceMem, numByte);
|
|
titolo = string.Format("READ BLOCK MEM WORD: {0} --> {1} byte", txtMemArea.Text, numByte);
|
|
contenuto = "";
|
|
ushort shortVal = 0;
|
|
string byteValA = "";
|
|
string byteValB = "";
|
|
for (int i = 0; i < memByteRead.Length / 2; i++)
|
|
{
|
|
byteValA = Convert.ToString(memByteRead[i * 2], 2).PadLeft(8, '0');
|
|
byteValB = Convert.ToString(memByteRead[i * 2 + 1], 2).PadLeft(8, '0');
|
|
shortVal = S7.Net.Types.Word.FromByteArray(memByteRead.Skip(2 * i).Take(2).ToArray());
|
|
contenuto += string.Format("W{0:000}: {1} | {2}-{3}{4}", i, shortVal, byteValA, byteValB, Environment.NewLine);
|
|
}
|
|
showOut(titolo, contenuto);
|
|
}
|
|
sw.Stop();
|
|
tslRTime.Text = string.Format("{0}", sw.Elapsed);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Esecuzione SCRITTURA Byte!
|
|
/// </summary>
|
|
private void eseguiScritturaByte()
|
|
{
|
|
sw.Restart();
|
|
if (testCncConn())
|
|
{
|
|
// decodifico memoria...
|
|
memAddress memoria = new memAddress(txtWriteAddr1.Text);
|
|
byte num2write = 0;
|
|
string val2write = txtWriteVal2.Text;
|
|
byte.TryParse(txtWriteVal1.Text, out num2write);
|
|
byte[] DB_Byte = new byte[1];
|
|
DB_Byte[0] = num2write;
|
|
currPLC.WriteBytes(DataType.DataBlock, memoria.DbNum, memoria.indiceMem, DB_Byte);
|
|
titolo = string.Format("WRITE BLOCK MEM: {0}", txtWriteAddr1.Text);
|
|
contenuto = "";
|
|
contenuto += string.Format("DT: {0} | DbNum: {1} | indiceMem: {2} | num2write: {3}{4}{4}", DataType.DataBlock, memoria.DbNum, memoria.indiceMem, num2write, Environment.NewLine);
|
|
string byteVal = "";
|
|
for (int i = 0; i < DB_Byte.Length; i++)
|
|
{
|
|
byteVal = Convert.ToString(DB_Byte[i], 2).PadLeft(8, '0');
|
|
contenuto += string.Format("B{0:000}: {1} | {2}{3}", i, byteVal, DB_Byte[i], Environment.NewLine);
|
|
}
|
|
showOut(titolo, contenuto);
|
|
}
|
|
sw.Stop();
|
|
tslRTime.Text = string.Format("{0}", sw.Elapsed);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Esecuzione SCRITTURA Char Array!
|
|
/// </summary>
|
|
private void eseguiScritturaCharArray()
|
|
{
|
|
sw.Restart();
|
|
if (testCncConn())
|
|
{
|
|
// decodifico memoria...
|
|
memAddress memoria = new memAddress(txtWriteAddr2.Text);
|
|
int num2write = 0;
|
|
// verifico di no sforare con lunghezza
|
|
string val2write = txtWriteVal2.Text;
|
|
// se è maggiore di maxStrChar TRIMMA:::
|
|
if (val2write.Length > maxStrChar)
|
|
{
|
|
val2write = val2write.Substring(0, 20);
|
|
}
|
|
// scambio spazi con underscore... e MAIUSCOLO!!!
|
|
val2write = val2write.Replace(' ', '_').ToUpper();
|
|
num2write = val2write.Length;
|
|
byte[] DB_Byte = new byte[maxStrChar];
|
|
// converto 1-1 i char in byte...
|
|
for (int i = 0; i < num2write; i++)
|
|
{
|
|
DB_Byte[i] = (byte)(val2write[i]);
|
|
}
|
|
currPLC.WriteBytes(DataType.DataBlock, memoria.DbNum, memoria.indiceMem, DB_Byte);
|
|
titolo = string.Format("WRITE BLOCK MEM: {0}", txtWriteAddr1.Text);
|
|
contenuto = "";
|
|
contenuto += string.Format("DT: {0} | DbNum: {1} | indiceMem: {2} | stringa: {3}{4}{4}", DataType.DataBlock, memoria.DbNum, memoria.indiceMem, num2write, Environment.NewLine);
|
|
showOut(titolo, contenuto);
|
|
}
|
|
sw.Stop();
|
|
tslRTime.Text = string.Format("{0}", sw.Elapsed);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Esecuzione SCRITTURA DWORD!
|
|
/// </summary>
|
|
private void eseguiScritturaDWord()
|
|
{
|
|
sw.Restart();
|
|
if (testCncConn())
|
|
{
|
|
// decodifico memoria...
|
|
memAddress memoria = new memAddress(txtWriteAddr1.Text);
|
|
uint num2write = 0;
|
|
string val2write = txtWriteVal2.Text;
|
|
uint.TryParse(txtWriteVal1.Text, out num2write);
|
|
byte[] DB_Byte = new byte[4];
|
|
S7.Net.Types.DWord.ToByteArray(num2write).CopyTo(DB_Byte, 0);
|
|
currPLC.WriteBytes(DataType.DataBlock, memoria.DbNum, memoria.indiceMem, DB_Byte);
|
|
titolo = string.Format("WRITE BLOCK MEM: {0}", txtWriteAddr1.Text);
|
|
contenuto = "";
|
|
contenuto += string.Format("DT: {0} | DbNum: {1} | indiceMem: {2} | num2write: {3}{4}{4}", DataType.DataBlock, memoria.DbNum, memoria.indiceMem, num2write, Environment.NewLine);
|
|
string byteVal = "";
|
|
for (int i = 0; i < DB_Byte.Length; i++)
|
|
{
|
|
byteVal = Convert.ToString(DB_Byte[i], 2).PadLeft(8, '0');
|
|
contenuto += string.Format("B{0:000}: {1} | {2}{3}", i, byteVal, DB_Byte[i], Environment.NewLine);
|
|
}
|
|
showOut(titolo, contenuto);
|
|
}
|
|
sw.Stop();
|
|
tslRTime.Text = string.Format("{0}", sw.Elapsed);
|
|
}
|
|
|
|
private void eseguiScritturaReal()
|
|
{
|
|
sw.Restart();
|
|
if (testCncConn())
|
|
{
|
|
// decodifico memoria...
|
|
memAddress memoria = new memAddress(txtWriteAddr1.Text);
|
|
double num2write = 0;
|
|
double.TryParse(txtWriteVal1.Text.Replace(".", ","), out num2write);
|
|
byte[] DB_Byte = new byte[4];
|
|
S7.Net.Types.Double.ToByteArray(num2write).CopyTo(DB_Byte, 0);
|
|
currPLC.WriteBytes(DataType.DataBlock, memoria.DbNum, memoria.indiceMem, DB_Byte);
|
|
titolo = string.Format("WRITE BLOCK MEM: {0}", txtWriteAddr1.Text);
|
|
contenuto = "";
|
|
contenuto += string.Format("DT: {0} | DbNum: {1} | indiceMem: {2} | num2write: {3}{4}{4}", DataType.DataBlock, memoria.DbNum, memoria.indiceMem, num2write, Environment.NewLine);
|
|
string byteVal = "";
|
|
for (int i = 0; i < DB_Byte.Length; i++)
|
|
{
|
|
byteVal = Convert.ToString(DB_Byte[i], 2).PadLeft(8, '0');
|
|
contenuto += string.Format("B{0:000}: {1} | {2}{3}", i, byteVal, DB_Byte[i], Environment.NewLine);
|
|
}
|
|
showOut(titolo, contenuto);
|
|
}
|
|
sw.Stop();
|
|
tslRTime.Text = string.Format("{0}", sw.Elapsed);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Esecuzione SCRITTURA String!
|
|
/// </summary>
|
|
private void eseguiScritturaString()
|
|
{
|
|
sw.Restart();
|
|
if (testCncConn())
|
|
{
|
|
// decodifico memoria...
|
|
memAddress memoria = new memAddress(txtWriteAddr2.Text);
|
|
int num2write = 0;
|
|
// verifico di non sforare con lunghezza
|
|
string val2write = txtWriteVal2.Text;
|
|
// se è maggiore di maxStrChar TRIMMA:::
|
|
if (val2write.Length > maxStrChar)
|
|
{
|
|
val2write = val2write.Substring(0, 20);
|
|
}
|
|
// scambio spazi con underscore... e MAIUSCOLO!!!
|
|
val2write = val2write.Replace(' ', '_').ToUpper();
|
|
num2write = val2write.Length;
|
|
byte[] DB_Byte = new byte[maxStrChar + 2];
|
|
// primi 2 byte sono 20 (fix) e lung effettiva...
|
|
DB_Byte[0] = 20;
|
|
DB_Byte[1] = (byte)num2write;
|
|
// converto 1-1 i char in byte...
|
|
for (int i = 0; i < num2write; i++)
|
|
{
|
|
DB_Byte[2 + i] = (byte)(val2write[i]);
|
|
}
|
|
currPLC.WriteBytes(DataType.DataBlock, memoria.DbNum, memoria.indiceMem, DB_Byte);
|
|
titolo = string.Format("WRITE BLOCK MEM: {0}", txtWriteAddr1.Text);
|
|
contenuto = "";
|
|
contenuto += string.Format("DT: {0} | DbNum: {1} | indiceMem: {2} | stringa: {3}{4}{4}", DataType.DataBlock, memoria.DbNum, memoria.indiceMem, num2write, Environment.NewLine);
|
|
showOut(titolo, contenuto);
|
|
}
|
|
sw.Stop();
|
|
tslRTime.Text = string.Format("{0}", sw.Elapsed);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Esecuzione SCRITTURA WORD!
|
|
/// </summary>
|
|
private void eseguiScritturaWord()
|
|
{
|
|
sw.Restart();
|
|
if (testCncConn())
|
|
{
|
|
// decodifico memoria...
|
|
memAddress memoria = new memAddress(txtWriteAddr1.Text);
|
|
UInt16 num2write = 0;
|
|
string val2write = txtWriteVal2.Text;
|
|
UInt16.TryParse(txtWriteVal1.Text, out num2write);
|
|
byte[] DB_Byte = new byte[2];
|
|
S7.Net.Types.Word.ToByteArray(num2write).CopyTo(DB_Byte, 0);
|
|
currPLC.WriteBytes(DataType.DataBlock, memoria.DbNum, memoria.indiceMem, DB_Byte);
|
|
titolo = string.Format("WRITE BLOCK MEM: {0}", txtWriteAddr1.Text);
|
|
contenuto = "";
|
|
contenuto += string.Format("DT: {0} | DbNum: {1} | indiceMem: {2} | num2write: {3}{4}{4}", DataType.DataBlock, memoria.DbNum, memoria.indiceMem, num2write, Environment.NewLine);
|
|
string byteVal = "";
|
|
for (int i = 0; i < DB_Byte.Length; i++)
|
|
{
|
|
byteVal = Convert.ToString(DB_Byte[i], 2).PadLeft(8, '0');
|
|
contenuto += string.Format("B{0:000}: {1} | {2}{3}", i, byteVal, DB_Byte[i], Environment.NewLine);
|
|
}
|
|
showOut(titolo, contenuto);
|
|
}
|
|
sw.Stop();
|
|
tslRTime.Text = string.Format("{0}", sw.Elapsed);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Caricamento conf memoria DB del SIEMENS
|
|
/// </summary>
|
|
private void loadMemConf()
|
|
{
|
|
// carico conf memoria
|
|
utils.loadConfFile(ref memMapR, filePath("MMapR"), 1, ref numByte);
|
|
utils.loadConfFile(ref memMapW, filePath("MMapW"), 1, ref numByte);
|
|
}
|
|
|
|
/// <summary>
|
|
/// inizializzo
|
|
/// </summary>
|
|
private void myInit()
|
|
{
|
|
lg = LogManager.GetCurrentClassLogger();
|
|
// inizializzo parametri...
|
|
parametri = new connParam()
|
|
{
|
|
ipAdrr = "127.0.0.1",
|
|
tipoCpu = CpuType.S7200,
|
|
slot = 0,
|
|
rack = 0
|
|
};
|
|
setParamPlc();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Imposto parametri PLC
|
|
/// </summary>
|
|
private void setParamPlc()
|
|
{
|
|
txtOut.Text = "";
|
|
// SE è necessario refresh...
|
|
if (needRefresh)
|
|
{
|
|
lg.Info("Refreshing connection...");
|
|
try
|
|
{
|
|
short.TryParse(txtSlot.Text, out parametri.slot);
|
|
short.TryParse(txtRack.Text, out parametri.rack);
|
|
parametri.tipoCpu = (CpuType)Enum.Parse(typeof(CpuType), cbCpuType.SelectedItem.ToString());
|
|
parametri.ipAdrr = txtIP.Text.Trim();
|
|
titolo = "PARAM PLC (pre connect)";
|
|
lg.Info(titolo);
|
|
contenuto = string.Format("IP: {0}{1}", parametri.ipAdrr, Environment.NewLine);
|
|
contenuto += string.Format("CPU: {0}{1}", parametri.tipoCpu, Environment.NewLine);
|
|
contenuto += string.Format("RACK: {0}{1}", parametri.rack, Environment.NewLine);
|
|
contenuto += string.Format("SLOT: {0}", parametri.slot, Environment.NewLine);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lg.Error(exc, "Errore in parse parametri");
|
|
}
|
|
// ora tento avvio PLC... SE PING OK...
|
|
if (testPing() == IPStatus.Success)
|
|
{
|
|
try
|
|
{
|
|
currPLC = new Plc(parametri.tipoCpu, parametri.ipAdrr, parametri.rack, parametri.slot);
|
|
currPLC.Open();
|
|
if (currPLC.IsConnected)
|
|
{
|
|
titolo = "CONNESSIONE AVVENUTA";
|
|
}
|
|
else
|
|
{
|
|
titolo = "Impossibile connettersi al PLC";
|
|
}
|
|
lg.Info(titolo);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lg.Error(exc, "Errore in INIT PLC");
|
|
}
|
|
needRefresh = false;
|
|
}
|
|
// carico conf vettore memoria...
|
|
loadMemConf();
|
|
lg.Info("Eseguito loadMemConf");
|
|
// mostra output
|
|
showOut(titolo, contenuto);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Test connessione CNC
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private bool testCncConn()
|
|
{
|
|
bool answ = false;
|
|
IPStatus pingStatus = testPing();
|
|
// se passa il ping faccio il resto...
|
|
if (pingStatus != IPStatus.Success)
|
|
{
|
|
titolo = "Errore ping";
|
|
contenuto = string.Format("Reply Status per {0}: {1}", parametri.ipAdrr, pingStatus);
|
|
showOut(titolo, contenuto);
|
|
}
|
|
else
|
|
{
|
|
if (!currPLC.IsConnected) currPLC.Open();
|
|
if (!currPLC.IsAvailable)
|
|
{
|
|
titolo = "Errore Disponibilità";
|
|
contenuto = string.Format("{0} | {1}", currPLC.LastErrorCode, currPLC.LastErrorString);
|
|
currPLC.ClearLastError();
|
|
showOut(titolo, contenuto);
|
|
}
|
|
else
|
|
{
|
|
if (!currPLC.IsConnected)
|
|
{
|
|
titolo = "Errore connessione";
|
|
contenuto = string.Format("{0} | {1}", currPLC.LastErrorCode, currPLC.LastErrorString);
|
|
currPLC.ClearLastError();
|
|
showOut(titolo, contenuto);
|
|
tslConn.Text = "NO Connection";
|
|
}
|
|
else
|
|
{
|
|
tslConn.Text = "Connection OK";
|
|
answ = true;
|
|
}
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// test ping all'indirizzo impostato nei parametri
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private IPStatus testPing()
|
|
{
|
|
IPStatus answ = IPStatus.Unknown; ;
|
|
IPAddress address;
|
|
PingReply reply;
|
|
Ping pingSender = new Ping();
|
|
address = IPAddress.Loopback;
|
|
IPAddress.TryParse(parametri.ipAdrr, out address);
|
|
reply = pingSender.Send(address, 100);
|
|
answ = reply.Status;
|
|
return answ;
|
|
}
|
|
|
|
private void txtIP_TextChanged(object sender, EventArgs e)
|
|
{
|
|
needRefresh = true;
|
|
}
|
|
|
|
private void txtMemArea_TextChanged(object sender, EventArgs e)
|
|
{
|
|
needRefresh = true;
|
|
}
|
|
|
|
private void txtMemSize_TextChanged(object sender, EventArgs e)
|
|
{
|
|
needRefresh = true;
|
|
}
|
|
|
|
private void txtRack_TextChanged(object sender, EventArgs e)
|
|
{
|
|
needRefresh = true;
|
|
}
|
|
|
|
private void txtSlot_TextChanged(object sender, EventArgs e)
|
|
{
|
|
needRefresh = true;
|
|
}
|
|
|
|
#endregion Private Methods
|
|
|
|
#region Protected Methods
|
|
|
|
/// <summary>
|
|
/// Restituisce path completo file da chaive configurazione
|
|
/// </summary>
|
|
/// <param name="keyFile">chaive conf x file richiesto</param>
|
|
/// <returns></returns>
|
|
protected string filePath(string keyFile)
|
|
{
|
|
return string.Format(@"{0}\{1}", utils.confDir, utils.CRS(keyFile));
|
|
}
|
|
|
|
protected void showOut(string title, string content)
|
|
{
|
|
string outText = "";
|
|
// a video
|
|
outText += string.Format("{0}--------------------------------------------------------------------------------------{0}", Environment.NewLine);
|
|
outText += string.Format("- {0}{1}", title, Environment.NewLine);
|
|
outText += string.Format("--------------------------------------------------------------------------------------{0}", Environment.NewLine);
|
|
outText += string.Format("{0}{1}", content, Environment.NewLine);
|
|
outText += string.Format("--------------------------------------------------------------------------------------{0}{0}", Environment.NewLine);
|
|
|
|
// aggiorno visualizzazione
|
|
txtOut.Text += outText;
|
|
// loggo!
|
|
lg.Info(outText);
|
|
}
|
|
|
|
#endregion Protected Methods
|
|
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// formatta un numero in forma binaria 0/1 a 32 bit (4 byte)
|
|
/// </summary>
|
|
/// <param name="valore"></param>
|
|
/// <returns></returns>
|
|
public static string binaryForm(int valore)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = string.Format(new BinaryFormatter(), "{0:B}", valore);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
|
|
#endregion Public Methods
|
|
}
|
|
} |