public override TiaAndSTep7DataBlockRow DeepCopy()
{
S7DataRow newRow = new S7DataRow(this.Name, this.DataType, this.PlcBlock);
newRow.Parent = this.Parent;
newRow.ArrayStart = this.ArrayStart;
newRow.ArrayStop = this.ArrayStop;
newRow.IsArray = this.IsArray;
newRow.WasFirstInArray = this.WasFirstInArray;
newRow.WasArray = this.WasArray;
newRow.WasNextHigherIndex = this.WasNextHigherIndex;
newRow.Attributes = this.Attributes;
newRow.Comment = this.Comment;
newRow.DataTypeBlockNumber = this.DataTypeBlockNumber;
newRow.ReadOnly = this.ReadOnly;
newRow.StartValue = this.StartValue;
newRow.StringSize = this.StringSize;
newRow.TimeStampConflict = this.TimeStampConflict;
newRow.isInOut = this.isInOut;
newRow.isRootBlock = this.isRootBlock;
newRow.Value = this.Value;
if (Children!=null)
foreach (S7DataRow plcDataRow in Children)
{
TiaAndSTep7DataBlockRow copy = plcDataRow.DeepCopy();
copy.Parent = newRow;
newRow.Add(copy);
}
return newRow;
}
internal static void FillActualValuesInDataBlock(S7DataRow row, byte[] actualValues, ref int valuePos, ref int bitPos)
{
if (valuePos >= actualValues.Length)
return;
else
{
if (row.DataType != S7DataRowType.STRUCT && row.DataType != S7DataRowType.UDT)
{
if (row.DataType == S7DataRowType.BOOL)
{
row.Value = libnodave.getBit(actualValues[valuePos], bitPos);
bitPos++;
if (bitPos > 7)
{
bitPos = 0;
valuePos++;
}
}
else
{
bitPos = 0;
row.Value = GetVarTypeVal((byte)row.DataType, actualValues, ref valuePos);
}
}
else
{
bitPos = 0;
foreach (var child in row.Children)
{
FillActualValuesInDataBlock(((S7DataRow)child), actualValues, ref valuePos, ref bitPos);
}
}
}
}
public static int GetDepth(S7DataRow item)
{
int cnt = 0;
while (item.Parent != null)
{
cnt++;
item = item.Parent;
}
return cnt;
}
private void AddDBValueSubNodes(TreeNode nd, S7DataRow row)
{
if (row.Children!=null)
foreach (S7DataRow s7DataRow in row.Children)
{
if (s7DataRow._children!=null && s7DataRow.Children.Count>0)
{
DBValueTreeNode newNd = new DBValueTreeNode();
newNd.Text = s7DataRow.Name;
newNd.s7datarow = s7DataRow;
nd.Nodes.Add(newNd);
AddDBValueSubNodes(newNd, s7DataRow);
}
}
}
public void Remove(S7DataRow par)
{
if (this._children != null)
{
if (ReadOnly)
{
return;
}
_children.Remove(par);
if (_children.Count == 0)
{
this._children = null;
}
}
ClearBlockAddress();
}
public static string DataRowValueToSource(S7DataRow datrw, string leerz)
{
var retval = new StringBuilder();
foreach (S7DataRow s7DataRow in datrw.Children)
{
if (s7DataRow.DataType == S7DataRowType.STRUCT)
{
retval.Append(DataRowValueToSource(s7DataRow, leerz + " "));
}
else
{
retval.AppendLine(leerz + s7DataRow.Name + " := " + s7DataRow.ValueAsString + ";");
}
}
return retval.ToString();
}
public S7DataRow DeepCopy()
{
S7DataRow newRow = new S7DataRow(this.Name, this.DataType, this.PlcBlock);
newRow.ArrayStart = this.ArrayStart;
newRow.ArrayStop = this.ArrayStop;
newRow.IsArray = this.IsArray;
newRow.WasFirstInArray = this.WasFirstInArray;
newRow.WasArray = this.WasArray;
newRow.WasNextHigherIndex = this.WasNextHigherIndex;
newRow.Attributes = this.Attributes;
newRow.Comment = this.Comment;
newRow.DataTypeBlockNumber = this.DataTypeBlockNumber;
newRow.ReadOnly = this.ReadOnly;
newRow.StartValue = this.StartValue;
newRow.StringSize = this.StringSize;
newRow.TimeStampConflict = this.TimeStampConflict;
newRow.isInOut = this.isInOut;
newRow.isRootBlock = this.isRootBlock;
newRow.Value = this.Value;
if (Children != null)
{
foreach (S7DataRow plcDataRow in Children)
{
S7DataRow copy = plcDataRow.DeepCopy();
copy.Parent = newRow;
newRow.Add(copy);
}
}
return(newRow);
/*
* MemoryStream ms = new MemoryStream();
* BinaryFormatter bf = new BinaryFormatter();
* bf.Serialize(ms, this);
* ms.Position = 0;
* object obj = bf.Deserialize(ms);
* ms.Close();
* return obj;
* */
}
//PLCDataRow
//Diconary ByteAddres, PLCDataRow
//Create Extra Functions for GetValues and GetActualValues
//This functions get the PLCDataRow Structure.
internal static S7DataRow GetFunctionParameterFromNumber(S7DataRow parameters, int index)
{
if (parameters==null || parameters.Children==null)
return null;
int n = 0;
int akIdx = index;
while (n < parameters.Children.Count)
{
S7DataRow tmp = ((S7DataRow)parameters.Children[n]);
if (akIdx >= tmp.Children.Count)
{
akIdx -= tmp.Children.Count;
n++;
}
else
{
return ((S7DataRow)tmp.Children[akIdx]);
}
}
return null;
}
public static S7DataRow GetDataRowWithAddress(S7DataRow startRow, ByteBitAddress address)
{
for (int n = 0; n < startRow.Children.Count; n++)
//foreach (var s7DataRow in startRow.Children)
{
var s7DataRow = startRow.Children[n];
if (n == startRow.Children.Count - 1 || address < startRow.Children[n + 1].BlockAddress)
{
if (s7DataRow.BlockAddress == address && (s7DataRow.Children == null || s7DataRow.Children.Count == 0))
{
return(s7DataRow);
}
var tmp = GetDataRowWithAddress(s7DataRow, address);
if (tmp != null)
{
return(tmp);
}
}
}
return(null);
}
public static S7DataRow GetDataRowWithAddress(S7DataRow startRow, ByteBitAddress address, bool dontLookInTemp = false)
{
IList <IDataRow> col = startRow.Children;
if (dontLookInTemp)
{
col = startRow.Children.Where(itm => itm.Name != "TEMP").ToList();
}
for (int n = 0; n < col.Count; n++)
{
var s7DataRow = col[n];
if (n == col.Count - 1 || address < ((S7DataRow)col[n + 1]).BlockAddress)
{
if (((S7DataRow)s7DataRow).BlockAddress == address && (s7DataRow.Children == null || s7DataRow.Children.Count == 0))
{
return((S7DataRow)s7DataRow);
}
//fix for finding the absoluteaddress of a string
var stringDataRow = (S7DataRow)s7DataRow;
if (stringDataRow.DataType == S7DataRowType.STRING)
{
int firstByte = stringDataRow.BlockAddress.ByteAddress;
int lastByte = firstByte + stringDataRow.PlcTag.ArraySize + 2;
//If is a string the calling logic has determine which character is bein accessed
if (address.ByteAddress >= (firstByte) && address.ByteAddress <= lastByte)
{
return(stringDataRow);
}
}
var tmp = GetDataRowWithAddress(((S7DataRow)s7DataRow), address);
if (tmp != null)
{
return(tmp);
}
}
}
return(null);
}
//
internal static S7DataRow GetInterface(byte[] interfaceBytes, byte[] actualvalueBytes, ref List<String> ParaList, DataTypes.PLCBlockType blkTP, bool isInstanceDB, S7Block myBlk)
{
S7DataRow parameterRoot = new S7DataRow("ROOTNODE", S7DataRowType.STRUCT, myBlk);
S7DataRow parameterIN = new S7DataRow("IN", S7DataRowType.STRUCT, myBlk);
S7DataRow parameterOUT = new S7DataRow("OUT", S7DataRowType.STRUCT, myBlk);
S7DataRow parameterINOUT = new S7DataRow("IN_OUT", S7DataRowType.STRUCT, myBlk);
S7DataRow parameterSTAT = new S7DataRow("STATIC", S7DataRowType.STRUCT, myBlk);
S7DataRow parameterTEMP = new S7DataRow("TEMP", S7DataRowType.STRUCT, myBlk);
S7DataRow parameterRETVAL = new S7DataRow("RET_VAL", S7DataRowType.STRUCT, myBlk);
parameterRoot.Add(parameterIN);
parameterRoot.Add(parameterOUT);
parameterRoot.Add(parameterINOUT);
if (blkTP == DataTypes.PLCBlockType.FB || (blkTP == DataTypes.PLCBlockType.DB && isInstanceDB))
parameterRoot.Add(parameterSTAT);
if (blkTP != DataTypes.PLCBlockType.DB)
parameterRoot.Add(parameterTEMP);
parameterRoot.Add(parameterRETVAL);
parameterRoot.ReadOnly = true;
if (blkTP == DataTypes.PLCBlockType.DB && !isInstanceDB)
parameterRoot = parameterSTAT;
int INp = 0;
int OUTp = 0;
int IN_OUTp = 0;
int STATp = 0;
int TEMPp = 0;
int StackNr = 1;
int pos = 7;
int Valpos = 0;
S7DataRow akParameter = parameterRoot;
ParaList.Clear();
while (pos <= (interfaceBytes.Length-2)) // && pos < BD.Length - 2) //pos<BD.Length-2 was added so SDBs can be converted!! but is this needed?
{
object startVal;
if (Helper.IsWithStartVal(interfaceBytes[pos + 1]))
{
if (interfaceBytes[pos] != 0x10) //Datentyp == Array...
startVal = GetVarTypeVal(interfaceBytes[pos], actualvalueBytes, ref Valpos);
else
{
Valpos = Valpos + 6;
startVal = GetVarTypeVal(interfaceBytes[pos + 3 + (interfaceBytes[pos + 2] * 4)], actualvalueBytes, ref Valpos);
}
}
else
startVal = null;
switch (interfaceBytes[pos + 1])
{
case 0x01:
case 0x09:
{
GetVarTypeEN(parameterIN, startVal, interfaceBytes[pos], false, false, "IN" + Convert.ToString(INp), interfaceBytes, actualvalueBytes, ref pos, ref ParaList, ref StackNr, "IN", ref INp, ref Valpos, myBlk);
}
break;
case 0x02:
case 0x0A:
{
GetVarTypeEN(parameterOUT, startVal, interfaceBytes[pos], false, false, "OUT" + Convert.ToString(OUTp), interfaceBytes, actualvalueBytes, ref pos, ref ParaList, ref StackNr, "OUT", ref OUTp, ref Valpos, myBlk);
}
break;
case 0x03:
case 0x0b:
{
GetVarTypeEN(parameterINOUT, startVal, interfaceBytes[pos], false, false, "IN_OUT" + Convert.ToString(IN_OUTp), interfaceBytes, actualvalueBytes, ref pos, ref ParaList, ref StackNr, "IN_OUT", ref IN_OUTp, ref Valpos, myBlk);
}
break;
case 0x04:
case 0x0C:
{
GetVarTypeEN(parameterSTAT, startVal, interfaceBytes[pos], false, false, "STAT" + Convert.ToString(STATp), interfaceBytes, actualvalueBytes, ref pos, ref ParaList, ref StackNr, "STAT", ref STATp, ref Valpos, myBlk);
}
break;
case 0x05:
{
GetVarTypeEN(parameterTEMP, startVal, interfaceBytes[pos], false, false, "TEMP" + Convert.ToString(TEMPp), interfaceBytes, actualvalueBytes, ref pos, ref ParaList, ref StackNr, "TEMP", ref TEMPp, ref Valpos, myBlk);
}
break;
case 0x06:
{
int tmp = 0;
GetVarTypeEN(parameterRETVAL, startVal, interfaceBytes[pos], false, false, "RET_VAL", interfaceBytes, actualvalueBytes, ref pos, ref ParaList, ref StackNr, "RET_VAL", ref tmp, ref Valpos, myBlk);
}
break;
/*default:
RETURNIntf = RETURNIntf + Convert.ToString(pos) + " UNKNOWN: " +
Convert.ToString(BD[pos + 1]) + " " + Convert.ToString(BD[pos]) + startVal +
"\r\n";
break;*/
}
pos += 2;
}
return parameterRoot;
}
private static S7Block CreateBlock(string blockType, string blockNumber, string type)
{
S7Block akBlock = null;
switch (blockType.ToUpper())
{
case ("TYPE"):
{
akBlock = new S7DataBlock() { BlockType = DataTypes.PLCBlockType.UDT, BlockLanguage = PLCLanguage.DB };
}
break;
case ("DATA_BLOCK"):
{
akBlock = new S7DataBlock() { BlockType = DataTypes.PLCBlockType.DB, BlockLanguage = PLCLanguage.DB };
}
break;
case ("FUNCTION"):
{
akBlock = new S7FunctionBlock() { BlockType = DataTypes.PLCBlockType.FC, BlockLanguage = PLCLanguage.AWL };
S7DataRow parameterRoot = new S7DataRow("ROOTNODE", S7DataRowType.STRUCT, akBlock);
S7DataRow parameterIN = new S7DataRow("IN", S7DataRowType.STRUCT, akBlock);
S7DataRow parameterOUT = new S7DataRow("OUT", S7DataRowType.STRUCT, akBlock);
S7DataRow parameterINOUT = new S7DataRow("IN_OUT", S7DataRowType.STRUCT, akBlock);
S7DataRow parameterSTAT = new S7DataRow("STATIC", S7DataRowType.STRUCT, akBlock);
S7DataRow parameterTEMP = new S7DataRow("TEMP", S7DataRowType.STRUCT, akBlock);
parameterOUT.Add(new S7DataRow("RET_VAL", (S7DataRowType)Enum.Parse(typeof(S7DataRowType), type), akBlock));
parameterRoot.Children.Add(parameterIN);
parameterRoot.Children.Add(parameterOUT);
parameterRoot.Children.Add(parameterINOUT);
parameterRoot.Children.Add(parameterSTAT);
parameterRoot.Children.Add(parameterTEMP);
}
break;
case ("FUNCTION_BLOCK"):
{
akBlock = new S7FunctionBlock() { BlockType = DataTypes.PLCBlockType.FB, BlockLanguage = PLCLanguage.AWL };
S7DataRow parameterRoot = new S7DataRow("ROOTNODE", S7DataRowType.STRUCT, akBlock);
S7DataRow parameterIN = new S7DataRow("IN", S7DataRowType.STRUCT, akBlock);
S7DataRow parameterOUT = new S7DataRow("OUT", S7DataRowType.STRUCT, akBlock);
S7DataRow parameterINOUT = new S7DataRow("IN_OUT", S7DataRowType.STRUCT, akBlock);
S7DataRow parameterTEMP = new S7DataRow("TEMP", S7DataRowType.STRUCT, akBlock);
parameterRoot.Children.Add(parameterIN);
parameterRoot.Children.Add(parameterOUT);
parameterRoot.Children.Add(parameterINOUT);
parameterRoot.Children.Add(parameterTEMP);
}
break;
}
return akBlock;
}
public void Remove(S7DataRow par)
{
if (this._children != null)
{
if (ReadOnly) return;
_children.Remove(par);
if (_children.Count == 0)
this._children = null;
}
ClearBlockAddress();
}
/*
* internal static List<PLCDataRow> _GetRowsAsList(PLCDataRow currRow)
* {
* List<PLCDataRow> retVal = new List<PLCDataRow>();
* retVal.Add(currRow);
* if (currRow.Children != null && currRow.DataType == PLCDataRowType.STRUCT)
* foreach (PLCDataRow plcDataRow in currRow.Children)
* retVal.AddRange(_GetRowsAsList(plcDataRow));
* return retVal;
* }
*/
internal List <S7DataRow> _GetExpandedChlidren(S7DataBlockExpandOptions myExpOpt)
{
S7DataRow retVal = (S7DataRow)this.DeepCopy();
retVal._children = new List <IDataRow>();
if (Children != null)
{
if (this.Parent == null || ((S7DataRow)this.Parent).isInOut == false || myExpOpt.ExpandSubChildInINOUT)
{
foreach (S7DataRow plcDataRow in this.Children)
{
List <S7DataRow> tmp = plcDataRow._GetExpandedChlidren(myExpOpt);
retVal.AddRange(tmp);
}
}
}
if (this.IsArray && (this.DataType != S7DataRowType.CHAR || myExpOpt.ExpandCharArrays))
{
List <S7DataRow> arrAsList = new List <S7DataRow>();
var lastCnt = (ArrayStop.Last() - ArrayStart.Last()) + 1;
int[] arrAk = ArrayStart.ToArray();
for (int i = 0; i < this.GetArrayLines(); i++)
{
string nm = "";
for (int n = 0; n < arrAk.Length; n++)
{
if (nm != "")
{
nm += ", ";
}
nm += arrAk[n];
}
var frst = (i % lastCnt) == 0; //Erstes Elment des letzten Index eines Arrays
S7DataRow tmp = (S7DataRow)retVal.DeepCopy();
tmp.Name = tmp.Name + "[" + nm + "]";
tmp.WasFirstInArray = retVal.IsArray && i == 0;
tmp.WasArray = retVal.IsArray;
tmp.IsArray = false;
tmp.WasNextHigherIndex = frst; // arrAk[ArrayStart.Count - 1] == ArrayStart[ArrayStart.Count - 1];
arrAsList.Add(tmp);
for (int n = arrAk.Length - 1; n >= 0; n--)
{
arrAk[n]++;
if (arrAk[n] > ArrayStop[n])
{
arrAk[n] = ArrayStart[n];
}
else
{
break;
}
}
}
return(arrAsList);
}
return(new List <S7DataRow>()
{
retVal
});
}
public S7DataRow GetDataRowWithAddress(ByteBitAddress address)
{
var allRw = this.GetArrayExpandedStructure();
return(S7DataRow.GetDataRowWithAddress((S7DataRow)allRw, address));
}
public S7DataRow DeepCopy()
{
S7DataRow newRow = new S7DataRow(this.Name, this.DataType, this.PlcBlock);
newRow.ArrayStart = this.ArrayStart;
newRow.ArrayStop = this.ArrayStop;
newRow.IsArray = this.IsArray;
newRow.WasFirstInArray = this.WasFirstInArray;
newRow.WasArray = this.WasArray;
newRow.WasNextHigherIndex = this.WasNextHigherIndex;
newRow.Attributes = this.Attributes;
newRow.Comment = this.Comment;
newRow.DataTypeBlockNumber = this.DataTypeBlockNumber;
newRow.ReadOnly = this.ReadOnly;
newRow.StartValue = this.StartValue;
newRow.StringSize = this.StringSize;
newRow.TimeStampConflict = this.TimeStampConflict;
newRow.isInOut = this.isInOut;
newRow.isRootBlock = this.isRootBlock;
if (Children!=null)
foreach (S7DataRow plcDataRow in Children)
{
S7DataRow copy = plcDataRow.DeepCopy();
copy.Parent = newRow;
newRow.Add(copy);
}
return newRow;
/*
MemoryStream ms = new MemoryStream();
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(ms, this);
ms.Position = 0;
object obj = bf.Deserialize(ms);
ms.Close();
return obj;
* */
}
public static S5DataBlock GetDB(ProjectPlcBlockInfo blkInfo, byte[] block, byte[] preHeader, byte[] commentBlock)
{
S5DataBlock retVal = new S5DataBlock();
retVal.BlockType = blkInfo.BlockType;
retVal.BlockNumber = blkInfo.BlockNumber;
S7DataRow main = new S7DataRow("STATIC", S7DataRowType.STRUCT, retVal);
retVal.Structure = main;
var zeilenListe = new List<S7DataRow>();
if (preHeader != null)
{
int akcnt = 0;
//S7DataRowType akRwTp = (S7DataRowType) (preHeader[9] | 0xf00);
int anzTypes = (((preHeader[6] * 256 + preHeader[7]) - 2)/2); //How many different Types are in the Header
for (int n = 1; n <= anzTypes; n++)
{
int rowStart = preHeader[(n - 1) * 4 + 10] * 256 + preHeader[(n - 1) * 4 + 11];
int rowStop = preHeader[n * 4 + 10] * 256 + preHeader[n * 4 + 11];
var akRwTp = (S7DataRowType)(preHeader[9 + (n - 1) * 4] | 0xf00);
if (akRwTp == S7DataRowType.S5_C || akRwTp == S7DataRowType.S5_KC)
{
for (int j = rowStart; j < rowStop; j += 24)
{
var row = new S7DataRow(string.Empty, akRwTp, retVal);
row.StringSize = rowStop - j > 12 ? 24 : (rowStop - j)*2;
main.Add(row);
for (int q = 0; q < (row.StringSize/2); q++)
{
zeilenListe.Add(row);
}
}
}
else if (akRwTp == S7DataRowType.S5_KG)
{
for (int j = rowStart; j < rowStop; j += 2)
{
var row = new S7DataRow(string.Empty, akRwTp, retVal);
main.Add(row);
zeilenListe.Add(row);
zeilenListe.Add(row);
}
}
else
{
for (int j = rowStart; j < rowStop; j += 1)
{
var row = new S7DataRow(string.Empty, akRwTp, retVal);
main.Add(row);
zeilenListe.Add(row);
}
}
}
}
try
{
int st = 10;
int maxZ = (block[8] * 256 + block[9]);
int n = 0;
while(n < maxZ - 5)
//foreach (var s7DataRow in main.Children)
{
S7DataRow s7DataRow;
if (zeilenListe.Count > n)
s7DataRow = zeilenListe[n];
else
{
s7DataRow = new S7DataRow(string.Empty, S7DataRowType.S5_KH, retVal);
main.Add(s7DataRow);
}
switch (s7DataRow.DataType)
{
case S7DataRowType.S5_KF:
s7DataRow.Value = libnodave.getS16from(block, st);
break;
case S7DataRowType.S5_KZ:
s7DataRow.Value = libnodave.getBCD16from(block, st);
break;
case S7DataRowType.S5_KM:
s7DataRow.Value = libnodave.getU16from(block, st);
break;
case S7DataRowType.S5_KH:
s7DataRow.Value = libnodave.getU16from(block, st);
break;
case S7DataRowType.S5_KY:
s7DataRow.Value = libnodave.getU16from(block, st);
break;
case S7DataRowType.S5_KG:
s7DataRow.Value = libnodave.getS5Floatfrom(block, st);
break;
case S7DataRowType.S5_KC:
case S7DataRowType.S5_C:
s7DataRow.Value = System.Text.ASCIIEncoding.ASCII.GetString(block, st, s7DataRow.StringSize);
break;
case S7DataRowType.S5_KT:
s7DataRow.Value = libnodave.getS5Timefrom(block, st);
break;
default:
s7DataRow.Value = libnodave.getU16from(block, st);
break;
}
st += s7DataRow.ByteLength;
n += s7DataRow.ByteLength / 2;
}
}
catch (Exception ex)
{ }
try
{
if (commentBlock != null && main._children != null && main._children.Count > 0)
{
int nr = 28;
int hdlen = 0x7f & commentBlock[nr];
retVal.Name = System.Text.Encoding.GetEncoding("ISO-8859-1").GetString(commentBlock, nr + 1, hdlen);
nr += hdlen + 1;
while (nr + 3 < commentBlock.Length)
{
int zeile = ((commentBlock[nr + 1] - 128) * 256) + commentBlock[nr];
int len = 0x7f & commentBlock[nr + 2];
string cmt = System.Text.Encoding.GetEncoding("ISO-8859-1").GetString(commentBlock, nr + 3, len);
//main._children[zeile].Comment = cmt;
zeilenListe[zeile].Comment = cmt;
nr += len + 3;
}
}
}
catch (Exception ex)
{
MessageBox.Show("There was an error parsing the Block Comments! Maybe the Step5 project is broken? \n" + ex.Message);
}
return retVal;
}
public void Add(S7DataRow par)
{
if (ReadOnly) return;
if (_children == null)
_children = new List<IDataRow>();
_children.Add(par);
par.Parent = this;
ClearBlockAddress();
}
/*internal static S7DataRow GetInterface(int Start, int Count, byte[] BD, DataTypes.PLCBlockType blkTP, bool isInstanceDB, S7Block myBlk)
{
S7DataRow parameterRoot = new S7DataRow("ROOTNODE", S7DataRowType.STRUCT, myBlk);
S7DataRow parameterIN = new S7DataRow("IN", S7DataRowType.STRUCT, myBlk);
S7DataRow parameterOUT = new S7DataRow("OUT", S7DataRowType.STRUCT, myBlk);
S7DataRow parameterINOUT = new S7DataRow("IN_OUT", S7DataRowType.STRUCT, myBlk);
S7DataRow parameterSTAT = new S7DataRow("STATIC", S7DataRowType.STRUCT, myBlk);
S7DataRow parameterTEMP = new S7DataRow("TEMP", S7DataRowType.STRUCT, myBlk);
S7DataRow parameterRETVAL = new S7DataRow("RET_VAL", S7DataRowType.STRUCT, myBlk);
parameterRoot.Add(parameterIN);
parameterRoot.Add(parameterOUT);
parameterRoot.Add(parameterINOUT);
if (blkTP == DataTypes.PLCBlockType.FB || (blkTP == DataTypes.PLCBlockType.DB && isInstanceDB))
parameterRoot.Add(parameterSTAT);
if (blkTP != DataTypes.PLCBlockType.DB)
parameterRoot.Add(parameterTEMP);
parameterRoot.Add(parameterRETVAL);
parameterRoot.ReadOnly = true;
if (blkTP == DataTypes.PLCBlockType.DB && !isInstanceDB)
parameterRoot = parameterSTAT;
//PLCDataRowsInterface retVal = new PLCDataRowsInterface();
int INcnt = 0;
int OUTcnt = 0;
int IN_OUTcnt = 0;
int STATcnt = 0;
int TEMPcnt = 0;
int StackNr = 1;
int pos = Start + 4;
string parNm = "";
S7DataRow akParameter = parameterRoot;
while (pos <= (Start + Count))
{
switch (BD[pos + 1])
{
case 0x01:
case 0x09: //with start val
akParameter = parameterIN;
parNm = "IN";
break;
case 0x02:
case 0x0A: //with start val
akParameter = parameterOUT;
parNm = "OUT";
break;
case 0x03:
case 0x0b: //with start val
akParameter = parameterINOUT;
parNm = "IN_OUT";
break;
case 0x04:
case 0x0C: //with start val
akParameter = parameterSTAT;
parNm = "STAT";
break;
case 0x05:
akParameter = parameterTEMP;
parNm = "TEMP";
break;
case 0x06:
akParameter = parameterRETVAL;
parNm = "RET_VAL";
break;
}
pos += 2;
}
return parameterRoot;
}*/
//internal PLCDataRow GetInterfaceSubrows(PLCDataRow currRow)
internal static void GetVarTypeEN(S7DataRow currPar, object startVal, byte b, bool Struct, bool Arry, string VarName, byte[] interfaceBytes, byte[] actualvalueBytes, ref int pos, ref List<string> ParaList, ref int StackNr, string VarNamePrefix, ref int VarCounter, ref int Valpos, S7Block myBlk)
{
int i, max, dim;
S7DataRowType Result = S7DataRowType.BOOL;
switch (b)
{
case 0x01:
Result = S7DataRowType.BOOL;
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal });
VarCounter++;
break;
case 0x02:
Result = S7DataRowType.BYTE;
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal });
VarCounter++;
break;
case 0x03:
Result = S7DataRowType.CHAR;
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal });
VarCounter++;
break;
case 0x04:
Result = S7DataRowType.WORD;
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal });
VarCounter++;
break;
case 0x05:
Result = S7DataRowType.INT;
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal });
VarCounter++;
break;
case 0x06:
Result = S7DataRowType.DWORD;
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal });
VarCounter++;
break;
case 0x07:
Result = S7DataRowType.DINT;
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal });
VarCounter++;
break;
case 0x08:
Result = S7DataRowType.REAL;
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal });
VarCounter++;
break;
case 0x09:
Result = S7DataRowType.DATE;
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal });
VarCounter++;
break;
case 0x0A:
Result = S7DataRowType.TIME_OF_DAY;
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal });
VarCounter++;
break;
case 0x0b:
Result = S7DataRowType.TIME;
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal });
VarCounter++;
break;
case 0x0C:
Result = S7DataRowType.S5TIME;
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal });
VarCounter++;
break;
case 0x0E:
Result = S7DataRowType.DATE_AND_TIME;
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal });
VarCounter++;
break;
case 0x10: //Array...
{
dim = interfaceBytes[pos + 2];
List<int> arrStart = new List<int>();
List<int> arrStop = new List<int>();
for (i = 0; i <= dim - 1; i++)
{
arrStart.Add(BitConverter.ToInt16(interfaceBytes, pos + 3 + (i * 4)));
arrStop.Add(BitConverter.ToInt16(interfaceBytes, pos + 5 + (i * 4)));
}
GetVarTypeEN(currPar, "", interfaceBytes[pos + 3 + (dim * 4)], true, true, VarName, interfaceBytes, actualvalueBytes, ref pos, ref ParaList, ref StackNr, VarNamePrefix, ref VarCounter, ref Valpos, myBlk);
((S7DataRow)currPar.Children[currPar.Children.Count - 1]).ArrayStart = arrStart;
((S7DataRow)currPar.Children[currPar.Children.Count - 1]).ArrayStop = arrStop;
((S7DataRow)currPar.Children[currPar.Children.Count - 1]).IsArray = true;
pos += 3 + (dim * 4);
} break;
case 0x11: //Struct
{
if (Arry) pos += 7;
Result = S7DataRowType.STRUCT;
var akPar = new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { StartValue = startVal };
currPar.Add(akPar);
VarCounter++;
max = interfaceBytes[pos + 2] - 1;
for (i = 0; i <= max; i++)
{
if ((interfaceBytes[pos + 3] == 0x11) || (interfaceBytes[pos + 3] == 0x10))
{
pos += 3;
if (Helper.IsWithStartVal(interfaceBytes[pos + 1]))
{
if (interfaceBytes[pos] != 0x10) //Datentyp == Array...
startVal = GetVarTypeVal(interfaceBytes[pos], actualvalueBytes, ref Valpos);
else
{
Valpos = Valpos + 6;
startVal = GetVarTypeVal(interfaceBytes[pos + 3 + (interfaceBytes[pos + 2] * 4)], actualvalueBytes, ref Valpos);
}
}
else
startVal = null;
GetVarTypeEN(akPar, startVal, interfaceBytes[pos], true, false, VarName + "." + VarNamePrefix + VarCounter.ToString(), interfaceBytes, actualvalueBytes, ref pos, ref ParaList, ref StackNr, VarNamePrefix, ref VarCounter, ref Valpos, myBlk);
pos -= 3;
}
else
{
if (Helper.IsWithStartVal(interfaceBytes[pos + 4]))
{
if (interfaceBytes[pos] != 0x10) //Datentyp == Array...
startVal = GetVarTypeVal(interfaceBytes[pos + 3], actualvalueBytes, ref Valpos);
else
{
Valpos = Valpos + 6;
startVal = GetVarTypeVal(interfaceBytes[pos + 6 + (interfaceBytes[pos + 2] * 4)], actualvalueBytes, ref Valpos);
}
}
else
startVal = null;
GetVarTypeEN(akPar, startVal, interfaceBytes[pos + 3], true, false, VarName + "." + VarNamePrefix + VarCounter.ToString(), interfaceBytes, actualvalueBytes, ref pos, ref ParaList, ref StackNr, VarNamePrefix, ref VarCounter, ref Valpos, myBlk);
}
pos += 2;
}
if (Arry) pos -= 7; pos += 1;
} break;
case 0x13:
{
Result = S7DataRowType.STRING;
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal });
if (Arry)
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal, StringSize = interfaceBytes[pos + 9] });
else
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal, StringSize = interfaceBytes[pos + 2] });
pos += 1;
VarCounter++;
}
break;
case 0x14:
Result = S7DataRowType.POINTER;
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal });
VarCounter++;
break;
case 0x16:
Result = S7DataRowType.ANY;
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal });
VarCounter++;
break;
case 0x17:
Result = S7DataRowType.BLOCK_FB;
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal });
VarCounter++;
break;
case 0x18:
Result = S7DataRowType.BLOCK_FC;
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal });
VarCounter++;
break;
case 0x19:
Result = S7DataRowType.BLOCK_DB;
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal });
VarCounter++;
break;
case 0x1A:
Result = S7DataRowType.BLOCK_SDB;
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal });
VarCounter++;
break;
case 0x1C:
Result = S7DataRowType.COUNTER;
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal });
VarCounter++;
break;
case 0x1D:
Result = S7DataRowType.TIMER;
currPar.Add(new S7DataRow(VarNamePrefix + VarCounter.ToString(), Result, myBlk) { Value = startVal });
VarCounter++;
break;
//default: Result = "UNKNOWN (" + Convert.ToString(b) + ")"; break;
}
//if (!Struct || Arry)
{
ParaList.Add(VarName);
//Result = Result + "(" + Convert.ToString(StackNr * 2) + ")";
StackNr = StackNr + 1;
}
//return Result;
}
/// <summary>
/// This is a Helper Function wich is used by GetSourceBlock
/// </summary>
/// <param name="datrw"></param>
/// <param name="leerz"></param>
/// <returns></returns>
private string GetSubParas(S7DataRow datrw, string leerz)
{
string retval = "";
foreach (S7DataRow s7DataRow in datrw.Children)
{
string arr = "";
string val = "";
string cmt = "";
if (s7DataRow.IsArray)
{
arr += "ARRAY [";
for (int i = 0; i < s7DataRow.ArrayStart.Count; i++)
{
if (i > 1) arr += ", ";
arr += s7DataRow.ArrayStart[i].ToString() + " .. " + s7DataRow.ArrayStop[i].ToString() + " ";
}
arr += "] OF ";
}
if (s7DataRow.StartValue != null)
val += " := " + s7DataRow.StartValue.ToString();
if (!string.IsNullOrEmpty(s7DataRow.Comment))
cmt += " //" + s7DataRow.Comment;
if (s7DataRow.DataType == S7DataRowType.STRUCT)
{
retval += leerz + s7DataRow.Name + " : " + arr + s7DataRow.DataType + cmt + Environment.NewLine;
retval += GetSubParas(s7DataRow, leerz + " ");
retval += leerz + "END_STRUCT ;" + Environment.NewLine;
}
else
{
retval += leerz + s7DataRow.Name + " : " + arr + s7DataRow.DataType + (s7DataRow.DataTypeBlockNumber != 0 ? s7DataRow.DataTypeBlockNumber.ToString() : "") + " " + val + ";" + cmt + Environment.NewLine;
}
}
return retval;
}
/*
* internal static List<PLCDataRow> _GetRowsAsList(PLCDataRow currRow)
* {
* List<PLCDataRow> retVal = new List<PLCDataRow>();
* retVal.Add(currRow);
* if (currRow.Children != null && currRow.DataType == PLCDataRowType.STRUCT)
* foreach (PLCDataRow plcDataRow in currRow.Children)
* retVal.AddRange(_GetRowsAsList(plcDataRow));
* return retVal;
* }
*/
internal List <S7DataRow> _GetExpandedChlidren(S7DataBlockExpandOptions myExpOpt)
{
S7DataRow retVal = (S7DataRow)this.DeepCopy();
retVal._children = new List <S7DataRow>();
if (Children != null)
{
foreach (S7DataRow plcDataRow in this.Children)
{
List <S7DataRow> tmp = plcDataRow._GetExpandedChlidren(myExpOpt);
retVal.AddRange(tmp);
}
}
if (this.IsArray && (this.DataType != S7DataRowType.CHAR || myExpOpt.ExpandCharArrays))
{
List <S7DataRow> arrAsList = new List <S7DataRow>();
int[] arrAk = ArrayStart.ToArray();
for (int i = 0; i < this.GetArrayLines(); i++)
{
string nm = "";
for (int n = 0; n < arrAk.Length; n++)
{
if (nm != "")
{
nm += ", ";
}
nm += arrAk[n];
}
S7DataRow tmp = (S7DataRow)retVal.DeepCopy();
tmp.Name = tmp.Name + "[" + nm + "]";
tmp.WasFirstInArray = retVal.IsArray && i == 0;
tmp.WasArray = retVal.IsArray;
tmp.IsArray = false;
arrAsList.Add(tmp);
for (int n = arrAk.Length - 1; n >= 0; n--)
{
arrAk[n]++;
if (arrAk[n] > ArrayStop[n])
{
arrAk[n] = ArrayStart[n];
}
else
{
break;
}
}
}
return(arrAsList);
}
return(new List <S7DataRow>()
{
retVal
});
}
internal static S7DataRow GetInterfaceOrDBFromStep7ProjectString(string txt, ref List<String> ParaList, PLCBlockType blkTP, bool isInstanceDB, BlocksOfflineFolder myFld, S7Block myBlk, byte[] actualValues = null)
{
S7DataRow parameterRoot = new S7DataRow("ROOTNODE", S7DataRowType.STRUCT, myBlk);
S7DataRow parameterRootWithoutTemp = new S7DataRow("ROOTNODE", S7DataRowType.STRUCT, myBlk);
if (myBlk is S7FunctionBlock)
{
(myBlk as S7FunctionBlock).ParameterWithoutTemp = parameterRootWithoutTemp;
}
S7DataRow parameterIN = new S7DataRow("IN", S7DataRowType.STRUCT,myBlk);
S7DataRow parameterOUT = new S7DataRow("OUT", S7DataRowType.STRUCT,myBlk);
S7DataRow parameterINOUT = new S7DataRow("IN_OUT", S7DataRowType.STRUCT, myBlk);
S7DataRow parameterSTAT = new S7DataRow("STATIC", S7DataRowType.STRUCT, myBlk);
S7DataRow parameterTEMP = new S7DataRow("TEMP", S7DataRowType.STRUCT, myBlk);
//S7DataRow parameterRETVAL = new S7DataRow("RET_VAL", S7DataRowType.STRUCT, myBlk);
S7DataRow akDataRow = parameterRoot;
parameterTEMP.isRootBlock = true;
bool tempAdded = false;
int Valpos = 0;
if (txt == null)
{
if (blkTP != PLCBlockType.DB)
parameterRoot.Add(parameterTEMP);
return parameterRoot;
}
//Todo: read the complete DB from mc5 code first, Read the containing UDTs, compare the UDTs with the Structs, if the UDTs and Structs are not Equal, marke the PLCDataRow as TimeStampConflict
string[] rows = txt.Split(new string[] {"\n"}, StringSplitOptions.RemoveEmptyEntries);
S7DataRow lastrow = null;
Dictionary<string, S7Block> blkHelpers = new Dictionary<string, S7Block>();
for (int n=0;n<rows.Length;n++) // (string row in rows)
{
string rowTr = rows[n].Replace("\0", "").Trim();
int poscm = rowTr.IndexOf("\t//");
if (poscm <= 0)
poscm = rowTr.Length;
string switchrow = rowTr.Substring(0,poscm);
string commnew = "";
if (poscm != rowTr.Length)
commnew = rowTr.Substring(poscm + 1);
if (rowTr.StartsWith("//"))
{
if (lastrow != null)
lastrow.Comment += rowTr;
else
{
if (commnew != null)
if (string.IsNullOrEmpty(akDataRow.Comment))
akDataRow.Comment += rowTr;
else
akDataRow.Comment += "\r\n" + rowTr;
}
}
else
{
switch (switchrow.Trim())
{
case "VAR_INPUT":
akDataRow = parameterIN;
akDataRow.Comment = commnew;
parameterRoot.Add(parameterIN);
parameterRootWithoutTemp.Add(parameterIN);
break;
case "VAR_OUTPUT":
akDataRow = parameterOUT;
akDataRow.Comment = commnew;
parameterRoot.Add(parameterOUT);
parameterRootWithoutTemp.Add(parameterOUT);
break;
case "VAR_IN_OUT":
akDataRow = parameterINOUT;
akDataRow.Comment = commnew;
parameterRoot.Add(parameterINOUT);
parameterRootWithoutTemp.Add(parameterINOUT);
break;
case "VAR_TEMP":
akDataRow = parameterTEMP;
if (blkTP != PLCBlockType.DB)
{
tempAdded = true;
parameterRoot.Add(parameterTEMP);
}
break;
case "VAR": //Static Data on a FB
akDataRow = parameterSTAT;
parameterRoot.Add(parameterSTAT);
parameterRootWithoutTemp.Add(parameterSTAT);
break;
case "END_STRUCT;":
case "END_STRUCT ;":
akDataRow = ((S7DataRow)akDataRow.Parent);
break;
case "STRUCT":
case "END_VAR":
case "":
if (commnew != null)
if (string.IsNullOrEmpty(akDataRow.Comment))
akDataRow.Comment += commnew;
else
akDataRow.Comment += "\r\n" + commnew;
break;
default:
char oldChar = ' ';
List<Step7Attribute> Step7Attributes = new List<Step7Attribute>();
string tmpName = "";
string tmpAttributeName = "";
string tmpAttributeValue = "";
string tmpType = "";
string tmpComment = "";
string tmpValue = "";
int parseZustand = 0; //0=ParName, 1=AttributeName, 6=AfterAttributeName, 2=AttributeValue, 3=Type, 4=Value, 7=InnerValue (without '), 5=Comment
var p1 = rows[n].IndexOf(" OF ");
int p2 = 0, p3 = 0;
if (p1 > 0)
{
p2 = rows[n].IndexOf(";", p1);
p3 = rows[n].IndexOf("//", p1);
}
//if (rows[n].Contains("ARRAY") && rows[n].Contains(" OF ") && !rows[n].Contains("\t\r")) // !rows[n].Contains("\t")
if (rows[n].Contains("ARRAY") && rows[n].Contains(" OF ") && (!(p2 > p1 && (p2 < p3 || p3 < 0)) && !rows[n].Contains("\t\r")))
{
if (rows.Length > n + 1)
{
if (rowTr.Contains("//"))
{
int pos = rowTr.IndexOf("//");
rowTr = rowTr.Substring(0, pos) + " " + rows[n + 1].Trim() + rowTr.Substring(pos);
}
else if (rowTr.Contains("OF STRUCT"))
{
}
else if (rowTr[rowTr.Length - 1] != ';')
{
rowTr += " " + rows[n + 1].Trim();
}
n++;
}
}
for (int j = 0; j < rowTr.Length; j++)
{
char tmpChar = rowTr[j];
if (parseZustand == 0 && tmpChar == '{')
parseZustand = 1;
else if (parseZustand == 0 && tmpChar != ' ' && tmpChar != ':')
tmpName += tmpChar;
else if (parseZustand == 6 && tmpChar == '\'')
parseZustand = 2;
else if (parseZustand == 1 && tmpChar == ':' && rowTr[j + 1] == '=')
{
parseZustand = 6;
j++;
}
else if (parseZustand == 1 && tmpChar != ' ' && tmpChar != ':' && tmpChar != '=' && tmpChar != '}' && tmpChar != '\'' && tmpChar != ';')
tmpAttributeName += tmpChar;
else if (parseZustand == 1 && tmpChar == '}')
parseZustand = 0;
else if (parseZustand == 0 && tmpChar == ':')
parseZustand = 3;
else if (parseZustand == 2 && tmpChar == '$')
{
tmpAttributeValue += rowTr[j + 1];
j++;
}
else if (parseZustand == 2 && tmpChar == '\'')
{
parseZustand = 1;
Step7Attributes.Add(new Step7Attribute(tmpAttributeName, tmpAttributeValue));
tmpAttributeName = "";
tmpAttributeValue = "";
}
else if (parseZustand == 2)
tmpAttributeValue += tmpChar;
//else if (parseZustand == 3 && tmpChar == ':')
// parseZustand = 2;
else if (parseZustand == 3 && tmpChar == ':' && rowTr[j + 1] == '=')
{
parseZustand = 4;
j++;
}
else if ((parseZustand == 3 || parseZustand == 4) && tmpChar == '/' && rowTr[j + 1] == '/')
{
parseZustand = 5;
j++;
}
else if (parseZustand == 4 && tmpChar == '\'')
{
tmpValue += tmpChar;
parseZustand = 7;
}
else if (parseZustand == 7 && tmpChar == '$')
{
tmpValue += rowTr[j + 1];
j++;
}
else if (parseZustand == 7 && tmpChar == '\'')
{
tmpValue += tmpChar;
parseZustand = 4;
}
else if (parseZustand == 3 && tmpChar != ';')
tmpType += tmpChar;
else if (parseZustand == 4 && tmpChar != ';' && tmpChar != ' ')
tmpValue += tmpChar;
else if (parseZustand == 7)
tmpValue += tmpChar;
else if (parseZustand == 5)
tmpComment += tmpChar;
}
tmpType = tmpType.Trim().ToUpper();
S7DataRow addRW = new S7DataRow(tmpName, S7DataRowType.UNKNOWN, myBlk);
lastrow = addRW;
if (tmpType.Replace(" ","").Contains("ARRAY["))
{
List<int> arrayStart = new List<int>();
List<int> arrayStop = new List<int>();
int pos1 = tmpType.IndexOf("[");
int pos2 = tmpType.IndexOf("]", pos1);
string[] arrays = tmpType.Substring(pos1 + 1, pos2 - pos1 - 2).Split(',');
foreach (string array in arrays)
{
string[] akar = array.Split(new string[] {".."}, StringSplitOptions.RemoveEmptyEntries);
arrayStart.Add(Convert.ToInt32(akar[0].Trim()));
arrayStop.Add(Convert.ToInt32(akar[1].Trim()));
}
addRW.ArrayStart = arrayStart;
addRW.ArrayStop = arrayStop;
addRW.IsArray = true;
tmpType = tmpType.Substring(pos2 + 5);
}
addRW.Comment = tmpComment.Replace("$'", "'").Replace("$$", "$");
if (Step7Attributes.Count > 0)
addRW.Attributes = Step7Attributes;
int akRowTypeNumber = 0;
if (tmpType.Contains("SFB"))
{
addRW.DataType = S7DataRowType.SFB;
akRowTypeNumber = Convert.ToInt32(tmpType.Substring(4));
string blkDesc = "SFB" + akRowTypeNumber.ToString();
S7FunctionBlock tmpBlk;
if (blkHelpers.ContainsKey(blkDesc))
tmpBlk = (S7FunctionBlock)blkHelpers[blkDesc];
else
{
tmpBlk = ((S7FunctionBlock)myFld.GetBlock(blkDesc));
blkHelpers.Add(blkDesc, tmpBlk);
}
if (tmpBlk != null && tmpBlk.Parameter != null && tmpBlk.Parameter.Children != null)
addRW.AddRange(tmpBlk.ParameterWithoutTemp.DeepCopy().Children.Cast<S7DataRow>());
}
else if (tmpType.Contains("UDT"))
{
addRW.DataType = S7DataRowType.UDT;
akRowTypeNumber = Convert.ToInt32(tmpType.Substring(4));
string blkDesc = "UDT" + akRowTypeNumber.ToString();
S7DataBlock tmpBlk;
if (blkHelpers.ContainsKey(blkDesc))
tmpBlk = (S7DataBlock)blkHelpers[blkDesc];
else
{
tmpBlk = ((S7DataBlock)myFld.GetBlock(blkDesc));
blkHelpers.Add(blkDesc, tmpBlk);
}
if (tmpBlk != null && tmpBlk.Structure != null && tmpBlk.Structure.Children != null)
addRW.AddRange(((S7DataRow)tmpBlk.Structure).DeepCopy().Children.Cast<S7DataRow>());
}
else if (tmpType.Contains("BLOCK_FB"))
{
addRW.DataType = S7DataRowType.BLOCK_FB;
//akRowTypeNumber = Convert.ToInt32(tmpType.Substring(3));
//PLCFunctionBlock tmpBlk = ((PLCFunctionBlock)myFld.GetBlock("FB" + akRowTypeNumber.ToString()));
//if (tmpBlk != null && tmpBlk.Parameter != null && tmpBlk.Parameter.Children != null)
// addRW.AddRange(tmpBlk.Parameter.Children);
}
else if (tmpType.Contains("FB"))
{
addRW.DataType = S7DataRowType.FB;
akRowTypeNumber = Convert.ToInt32(tmpType.Substring(3));
string blkDesc = "FB" + akRowTypeNumber.ToString();
S7FunctionBlock tmpBlk;
if (blkHelpers.ContainsKey(blkDesc))
tmpBlk = (S7FunctionBlock) blkHelpers[blkDesc];
else
{
tmpBlk = ((S7FunctionBlock)myFld.GetBlock(blkDesc));
blkHelpers.Add(blkDesc, tmpBlk);
}
if (tmpBlk != null && tmpBlk.Parameter != null && tmpBlk.Parameter.Children != null)
addRW.AddRange(tmpBlk.ParameterWithoutTemp.DeepCopy().Children.Cast<S7DataRow>());
}
else if (tmpType.Contains("STRING"))
{
addRW.DataType = S7DataRowType.STRING;
int pos1 = tmpType.IndexOf("[");
int pos2 = tmpType.IndexOf("]", pos1);
addRW.StringSize = Convert.ToInt32(tmpType.Substring(pos1 + 1, pos2 - pos1 - 2));
}
else
addRW.DataType = (S7DataRowType) Enum.Parse(typeof (S7DataRowType), tmpType.ToUpper());
addRW.DataTypeBlockNumber = akRowTypeNumber;
if (tmpValue != "")
{
//Todo: Startvalues bei arrays...
//Mehrere Values...
//TRUE,6(FALSE),TRUE,TRUE,7(FALSE)
if (addRW.IsArray)
{
addRW.StartValue = tmpValue;
}
else
{
addRW.StartValue = Helper.StringValueToObject(tmpValue, addRW.DataType);
}
}
else
{
if (!addRW.IsArray)
addRW.StartValue = Helper.DefaultValueForType(addRW.DataType);
}
//if (actualValues != null)
//{
// addRW.Value = GetVarTypeVal((byte)addRW.DataType, actualValues, ref Valpos);
//}
akDataRow.Add(addRW);
ParaList.Add(tmpName);
if (addRW.DataType == S7DataRowType.STRUCT)
akDataRow = addRW;
break;
/*
* Attributname kann nicht ' und } enthalten!
* In Attribt Values
* $$ zum ausmaskieren von $
* $' zum ausmaskieren von '
*
* Beispielzeilen....
// "ID { S7_co := 'agag'; S7_server1 := 'connection' }: INT ;\t// Connection ID 1..16"
// "LADDR { S7_co := 'agag'; S7_server1 := 'connection' }: WORD ;\t// Module address in hardware configuration"
// "RECV : ANY ;\t// Buffer for received data"
// "NDR : BOOL ;\t// Indicates whether new data were received"
// "aa { ff := '//ghghf}' }: BOOL ;"
// "bb : INT := 8888;"
// "P_1001 : ARRAY [0 .. 3 ] OF CHAR := '1', '0', '0', '1';"
// "aa : STRING [20 ] := 'deewedw';"
// "aa { dsfs := '' }: BOOL ;"
//"res : ARRAY [1 .. 121 ] OF STRUCT"
// "P_AKL1 : ARRAY [0 .. 3 ] OF CHAR := 'A', 'K', 'L', '1';"
*/
}
}
}
if (blkTP != PLCBlockType.DB && blkTP != PLCBlockType.UDT && tempAdded == false)
{
parameterRoot.Add(parameterTEMP);
}
if (actualValues != null)
{
int vPos = 0, bPos = 0;
FillActualValuesInDataBlock(parameterRoot, actualValues, ref vPos, ref bPos);
}
return parameterRoot;
}
public IDataRow GetArrayExpandedStructure()
{
//Todo: Vergleich der Expand Options, und beim änderen eines inneren wertes des blocks, diesen löschen (erst bei schreibsup wichtig!)
if (expStruct != null)
return expStruct;
return expStruct = (S7DataRow)GetArrayExpandedStructure(new S7DataBlockExpandOptions());
}
public static List<S7DataRow> GetChildrowsAsList(S7DataRow akRow)
{
List<S7DataRow> retVal = new List<S7DataRow>();
retVal.Add(akRow);
if (akRow != null && akRow.Children != null && (akRow.DataType == S7DataRowType.STRUCT || akRow.DataType == S7DataRowType.UDT || akRow.DataType == S7DataRowType.FB))
foreach (S7DataRow plcDataRow in akRow.Children)
retVal.AddRange(GetChildrowsAsList(plcDataRow));
return retVal;
}
/// <summary>
/// This is a Helper Function wich is used by GetSourceBlock
/// </summary>
/// <param name="datrw"></param>
/// <param name="leerz"></param>
/// <returns></returns>
public static string DataRowToSource(S7DataRow datrw, string leerz, bool withoutStartValue = false)
{
string retval = "";
foreach (S7DataRow s7DataRow in datrw.Children)
{
string arr = "";
string val = "";
string cmt = "";
if (s7DataRow.IsArray)
{
arr += "ARRAY [";
for (int i = 0; i < s7DataRow.ArrayStart.Count; i++)
{
if (i > 1) arr += ", ";
arr += s7DataRow.ArrayStart[i].ToString() + " .. " + s7DataRow.ArrayStop[i].ToString() + " ";
}
arr += "] OF ";
}
if (s7DataRow.DataType == S7DataRowType.STRING)
{
if (s7DataRow.StartValue != null && s7DataRow.StartValue.ToString() != "" && !withoutStartValue)
{
val += " := " + s7DataRow.StartValue.ToString() + "";
}
}
else if (s7DataRow.StartValue != null && !withoutStartValue)
{
string valuePrefix = "";
switch (s7DataRow.DataType)
{
case S7DataRowType.DWORD:
case S7DataRowType.WORD:
case S7DataRowType.BYTE:
valuePrefix = "16#";
break;
}
val += " := " + valuePrefix;
if ((s7DataRow.DataType == S7DataRowType.REAL))
val += s7DataRow.StartValueAsString;
else
val += s7DataRow.StartValue.ToString();
}
if (!string.IsNullOrEmpty(s7DataRow.Comment))
cmt += " //" + s7DataRow.Comment;
if (s7DataRow.DataType == S7DataRowType.STRUCT)
{
retval += leerz + s7DataRow.Name + " : " + arr + s7DataRow.DataType + cmt + Environment.NewLine;
retval += DataRowToSource(s7DataRow, leerz + " ");
retval += leerz + "END_STRUCT ;" + Environment.NewLine;
}
else
{
retval += leerz + s7DataRow.Name + " : " + arr;
retval += s7DataRow.DataType;
if (s7DataRow.DataType == S7DataRowType.STRING)
{
retval += " [" + s7DataRow.StringSize + "]";
}
retval += (s7DataRow.DataTypeBlockNumber != 0 ? s7DataRow.DataTypeBlockNumber.ToString() : "") + " " + val + ";" + cmt + Environment.NewLine;
}
}
return retval;
}
public static S7DataRow GetDataRowWithAddress(S7DataRow startRow, ByteBitAddress address, bool dontLookInTemp = false)
{
IList<IDataRow> col = startRow.Children;
if (dontLookInTemp)
col = startRow.Children.Where(itm => itm.Name != "TEMP").ToList();
for (int n = 0; n < col.Count; n++)
{
var s7DataRow = col[n];
if (n == col.Count - 1 || address < ((S7DataRow)col[n + 1]).BlockAddress)
{
if (((S7DataRow)s7DataRow).BlockAddress == address && (s7DataRow.Children == null || s7DataRow.Children.Count == 0))
return ((S7DataRow)s7DataRow);
var tmp = GetDataRowWithAddress(((S7DataRow)s7DataRow), address);
if (tmp != null)
return tmp;
}
}
return null;
}
public static S7DataRow GetDataRowWithAddress(S7DataRow startRow, ByteBitAddress address)
{
for (int n = 0; n < startRow.Children.Count;n++)
//foreach (var s7DataRow in startRow.Children)
{
var s7DataRow = startRow.Children[n];
if (n == startRow.Children.Count - 1 || address < startRow.Children[n + 1].BlockAddress)
{
if (s7DataRow.BlockAddress == address && (s7DataRow.Children == null || s7DataRow.Children.Count == 0))
return s7DataRow;
var tmp = GetDataRowWithAddress(s7DataRow, address);
if (tmp != null)
return tmp;
}
}
return null;
}
