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());
}
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);
}
}
}
}
/// <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 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);
}
}
}
}
private void cmdSelectStep7UDT_Click(object sender, EventArgs e)
{
S7DataBlock myDB = DotNetSiemensPLCToolBoxLibrary.Projectfiles.SelectProjectPart.SelectUDT();
if (myDB != null)
{
var myLst = S7DataRow.GetChildrowsAsList(((S7DataRow)myDB.GetArrayExpandedStructure(new S7DataBlockExpandOptions()
{
ExpandCharArrays = false
})));
dtaSendTabelle.Rows.Clear();
dtaEmpfangstelegrammAufgeschluesselt.Rows.Clear();
foreach (var itm in myLst)
{
if (itm.DataType != S7DataRowType.STRUCT && itm.DataType != S7DataRowType.UDT)
{
dtaSendTabelle.Rows.Add(new object[] { itm.StructuredName, itm.ByteLength });
dtaEmpfangstelegrammAufgeschluesselt.Rows.Add(new object[] { itm.StructuredName, itm.ByteLength });
}
}
}
}
//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);
}
//In this Class a UC is converted to a Call and also backwards...
public static void ConvertUCToCall(S7FunctionBlock myFct, S7ProgrammFolder myFld, BlocksOfflineFolder myblkFld, S7ConvertingOptions myOpt, byte[] addInfoFromBlock)
{
if (myOpt.GenerateCallsfromUCs)
{
int inBld = 0; //1=nach BLD 1
S7FunctionBlockRow newRow = null;
Dictionary <string, string> Parameters = new Dictionary <string, string>();
List <FunctionBlockRow> retVal = new List <FunctionBlockRow>();
List <FunctionBlockRow> tempList = new List <FunctionBlockRow>();
string registerDi = "DI";
string registerDb = "";
string registerAkku1 = "";
string registerAkku2 = "";
string registerAR1 = "";
string registerAR2 = "";
string diName = "";
string akPar = "";
string db = "";
string label = "";
string akku = "";
bool afterCall = false;
bool multiInstance = false;
int multiInstanceOffset = 0;
Pointer ar2Addr = new Pointer(0, 0);
S7FunctionBlockRow callRow = null;
for (int n = 0; n < myFct.AWLCode.Count; n++)
{
S7FunctionBlockRow row = (S7FunctionBlockRow)myFct.AWLCode[n];
if (row.Command == Mnemonic.opBLD[(int)myOpt.Mnemonic] && (row.Parameter == "1" || row.Parameter == "7" || row.Parameter == "3" || row.Parameter == "16" || row.Parameter == "14") && inBld == 0)
{
retVal.AddRange(tempList);
tempList.Clear();
Parameters.Clear();
db = "";
label = row.Label;
inBld = Convert.ToInt32(row.Parameter);
newRow = null;
afterCall = false;
callRow = null;
diName = "";
multiInstance = false;
multiInstanceOffset = 0;
ar2Addr = new Pointer(0, 0);
tempList.Add(row);
}
else if (inBld == 1 || inBld == 7)
{
#region FC Aufruf
tempList.Add(row);
if (row.Command == "=" && n > 0 && myFct.AWLCode[n - 1].Command == Mnemonic.opBLD[(int)myOpt.Mnemonic])
{
//Do nothing, but this line needs to be there!
}
else if (row.Command == Mnemonic.opU[(int)myOpt.Mnemonic] || row.Command == Mnemonic.opUN[(int)myOpt.Mnemonic] ||
row.Command == Mnemonic.opO[(int)myOpt.Mnemonic] || row.Command == Mnemonic.opON[(int)myOpt.Mnemonic] ||
row.Command == Mnemonic.opO[(int)myOpt.Mnemonic] || row.Command == Mnemonic.opON[(int)myOpt.Mnemonic] ||
row.Command == Mnemonic.opX[(int)myOpt.Mnemonic] || row.Command == Mnemonic.opXN[(int)myOpt.Mnemonic] ||
row.Command == Mnemonic.opL[(int)myOpt.Mnemonic])
{
akPar = row.Parameter;
}
else if (row.Command == Mnemonic.opAUF[(int)myOpt.Mnemonic])
{
db = row.Parameter + ".";
}
else if (row.Command == Mnemonic.opCLR[(int)myOpt.Mnemonic])
{
akPar = "FALSE";
}
else if (row.Command == Mnemonic.opSET[(int)myOpt.Mnemonic])
{
akPar = "TRUE";
}
else if (row.Command == Mnemonic.opTAR2[(int)myOpt.Mnemonic])
{
//look what we need to do here!!!
}
else if (row.Command == Mnemonic.opPAR2[(int)myOpt.Mnemonic])
{
//look what we need to do here!!!
}
else if (row.Command == Mnemonic.opLAR2[(int)myOpt.Mnemonic])
{
//look what we need to do here!!!
}
else if (row.Command == Mnemonic.opLAR1[(int)myOpt.Mnemonic])
{
//look what we need to do here!!!
}
else if ((row.Command == "=") && akPar != "")
{
if (afterCall == false)
{
string key = row.Parameter.Replace("L", "").Replace("W", "").Replace("B", "").Replace("D", "");
if (!Parameters.ContainsKey(key))
{
Parameters.Add("P#V " + key, db + akPar);
}
}
else
{
string key = akPar.Replace("L", "").Replace("W", "").Replace("B", "").Replace("D", "");
if (!Parameters.ContainsKey(key))
{
Parameters.Add("P#V " + key, db + row.Parameter);
}
}
akPar = "";
db = "";
}
else if (row.Command == Mnemonic.opT[(int)myOpt.Mnemonic] && akPar != "")
{
if (afterCall == false)
{
string key = row.Parameter.Replace("L", "").Replace("W", "").Replace("B", "").Replace("D", "");
//Fix for replace db accesses with symbols
if (myOpt.ReplaceDBAccessesWithSymbolNames && db != "")
{
string dbnr = db.Substring(0, db.Length - 1);
string dbSymbol = Helper.TryGetSymbolFromOperand(myblkFld, dbnr);
db = (dbSymbol != null ? "\"" + dbSymbol + "\"" : dbnr) + ".";
akPar = Helper.TryGetStructuredName(myblkFld, dbnr, akPar);
}
//end fix
if (!Parameters.ContainsKey(key))
{
Parameters.Add("P#V " + key + ".0", db + akPar);
}
}
else
{
string key = akPar.Replace("L", "").Replace("W", "").Replace("B", "").Replace("D", "");
if (!Parameters.ContainsKey("P#V " + key))
{
Parameters.Add("P#V " + key, db + row.Parameter);
}
}
akPar = "";
db = "";
}
else if (row.Command == Mnemonic.opT[(int)myOpt.Mnemonic] && akPar == "")
{
//look what we need to do here!!!
}
else if (row.Command == Mnemonic.opUC[(int)myOpt.Mnemonic])
{
//Commands after a Call --> Out-Para
callRow = row;
afterCall = true;
}
else if (row.Command == Mnemonic.opBLD[(int)myOpt.Mnemonic] && (row.Parameter == "2" || row.Parameter == "8"))
{
//Block Interface auslesen (von FC oder vom Programm)
S7DataRow para = myblkFld.GetInterface(callRow.Parameter);
newRow = new S7FunctionBlockRow();
newRow.Command = Mnemonic.opCALL[(int)myOpt.Mnemonic];
newRow.Parent = callRow.Parent;
newRow.Parameter = callRow.Parameter;
newRow.CallParameter = new List <S7FunctionBlockParameter>();
for (int i = 0; i < callRow.ExtParameter.Count; i++)
{
string s = callRow.ExtParameter[i];
string parnm = "";
S7DataRow akRow = Parameter.GetFunctionParameterFromNumber(para, i);
if (akRow != null)
{
parnm = akRow.Name + "";
}
else
{
parnm = "$$undef";
}
S7FunctionBlockParameter newPar = new S7FunctionBlockParameter(newRow);
newPar.Name = parnm;
if (akRow != null)
{
newPar.ParameterDataType = akRow.DataType;
if (akRow.Parent.Name == "OUT")
{
newPar.ParameterType = S7FunctionBlockParameterDirection.OUT;
}
else if (akRow.Parent.Name == "IN_OUT")
{
newPar.ParameterType = S7FunctionBlockParameterDirection.IN_OUT;
}
else
{
newPar.ParameterType = S7FunctionBlockParameterDirection.IN;
}
}
if (akRow != null)
{
int posL = s.IndexOf(' ');
int ak_address = 0;
if (posL >= 0)
{
ak_address = Convert.ToInt32(s.Substring(posL + 1).Split('.')[0]);
}
else
{
ak_address = Convert.ToInt32(s.Substring(2).Split('.')[0]) * 8 +
Convert.ToInt32(s.Substring(2).Split('.')[1]);
}
int lokaldata_address = -1;
if (s.Substring(0, 3) == "P#V")
{
lokaldata_address = Convert.ToInt32(s.Substring(4).Split('.')[0]);
}
if (akRow.DataType == S7DataRowType.STRING || akRow.DataType == S7DataRowType.DATE_AND_TIME ||
akRow.DataType == S7DataRowType.STRUCT || akRow.DataType == S7DataRowType.UDT ||
akRow.DataType == S7DataRowType.POINTER || akRow.IsArray)
{
string p1 = "";
string p2 = "";
Parameters.TryGetValue("P#V " + (lokaldata_address + 0).ToString() + ".0", out p1);
Parameters.TryGetValue("P#V " + (lokaldata_address + 2).ToString() + ".0", out p2);
string tmp = "";
if (p1 != "" && p1 != "0")
{
tmp += "P#DB" + p1 + "." + (p2 == null ? "0" : p2.Substring(2));
}
else
{
tmp += p2;
}
newPar.Value = tmp;
newRow.CallParameter.Add(newPar);
}
else if (akRow.DataType == S7DataRowType.ANY)
{
string tmp = s;
if (Parameters.ContainsKey("P#V " + (lokaldata_address + 0).ToString() + ".0") &&
Parameters.ContainsKey("P#V " + (lokaldata_address + 2).ToString() + ".0") &&
Parameters.ContainsKey("P#V " + (lokaldata_address + 4).ToString() + ".0") &&
Parameters.ContainsKey("P#V " + (lokaldata_address + 6).ToString() + ".0"))
{
string p1 = Parameters["P#V " + (lokaldata_address + 0).ToString() + ".0"];
string p2 = Parameters["P#V " + (lokaldata_address + 2).ToString() + ".0"];
string p3 = Parameters["P#V " + (lokaldata_address + 4).ToString() + ".0"];
string p4 = Parameters["P#V " + (lokaldata_address + 6).ToString() + ".0"];
//Fix for wrong construction of any pointers
var anyPtr = new S7AnyPointer(p1, p2, p3, p4);
if (myOpt.ReplaceDBAccessesWithSymbolNames)
{
//TODO: make the any pointer symbolic.
tmp = "" + anyPtr.ToString();
}
else
{
tmp = anyPtr.ToString();
}
//end fix
//tmp = "P#";
//if (p3 != "0")
// tmp += "DB" + p3 + ".";
//tmp += p4.Substring(2);
//tmp += " BYTE "; //Todo Parse Byte 1 if the Type is Byte!
//tmp += p2;
}
newPar.Value = tmp;
newRow.CallParameter.Add(newPar);
}
else
{
if (Parameters.ContainsKey(s))
{
string par = Parameters[s];
if (akRow.DataType == S7DataRowType.S5TIME && par[0] >= '0' && par[0] <= '9')
{
newPar.Value = Helper.GetS5Time(
BitConverter.GetBytes(Convert.ToInt32(par))[1],
BitConverter.GetBytes(Convert.ToInt32(par))[0]);
}
else if (akRow.DataType == S7DataRowType.TIME && par[0] >= '0' && par[0] <= '9')
{
newPar.Value = Helper.GetDTime(BitConverter.GetBytes(Convert.ToInt32(par)), 0);
}
else if (akRow.DataType == S7DataRowType.CHAR && par[0] == 'B')
{
newPar.Value = (char)Int32.Parse(par.Substring(5), System.Globalization.NumberStyles.AllowHexSpecifier) + "'";
}
else if (akRow.DataType == S7DataRowType.REAL)
{
var bt = new byte[4];
libnodave.putS32at(bt, 0, Int32.Parse(par.Substring(2)));
var real = libnodave.getFloatfrom(bt, 0);
newPar.Value = real.ToString("e6", CultureInfo.InvariantCulture);
}
else
{
newPar.Value = Parameters[s];
}
}
else
{
if (akRow.DataType == S7DataRowType.BOOL)
{
newPar.Value = s.Substring(2).Replace('V', 'L');
}
else if (akRow.DataType == S7DataRowType.BLOCK_DB)
{
newPar.Value = "DB" + ak_address.ToString();
}
else if (akRow.DataType == S7DataRowType.BLOCK_FB)
{
newPar.Value = "FB" + ak_address.ToString();
}
else if (akRow.DataType == S7DataRowType.BLOCK_FC)
{
newPar.Value = "FC" + ak_address.ToString();
}
else if (akRow.DataType == S7DataRowType.BLOCK_SDB)
{
newPar.Value = "SDB" + ak_address.ToString();
}
else if (akRow.DataType == S7DataRowType.TIMER)
{
newPar.Value = Mnemonic.adT[(int)myOpt.Mnemonic] + ak_address.ToString();
}
else if (akRow.DataType == S7DataRowType.COUNTER)
{
newPar.Value = Mnemonic.adZ[(int)myOpt.Mnemonic] + ak_address.ToString();
}
else
{
string ber = "";
if (s.Substring(0, 5) == "P#DBX")
{
ber = "DB";
}
else if (s.Substring(0, 5) == "P#DIX")
{
ber = "DI";
}
else
{
ber = s.Substring(2, 1);
}
if (akRow.ByteLength == 1)
{
ber += "B";
}
else if (akRow.ByteLength == 2)
{
ber += "W";
}
else if (akRow.ByteLength == 4)
{
ber += "D";
}
var access = ber.Replace('V', 'L') + ak_address;
//fix for temporary area not replaced with symbolnames
if (myOpt.ReplaceLokalDataAddressesWithSymbolNames)
{
var tempSymbol = S7DataRow.GetDataRowWithAddress(myFct.Parameter, new ByteBitAddress(ak_address, 0));
if (tempSymbol != null)
{
access = "#" + tempSymbol.StructuredName.Replace("TEMP.", "");
}
}
newPar.Value = access;
}
}
newRow.CallParameter.Add(newPar);
}
}
}
newRow.CombinedCommands = tempList;
newRow.Label = label;
int sz = 0;
foreach (var functionBlockRow in newRow.CombinedCommands)
{
sz += ((S7FunctionBlockRow)functionBlockRow).ByteSize;
}
byte[] mcges = new byte[sz];
sz = 0;
foreach (var functionBlockRow in newRow.CombinedCommands)
{
Array.Copy(((S7FunctionBlockRow)functionBlockRow).MC7, 0, mcges, sz, ((S7FunctionBlockRow)functionBlockRow).ByteSize);
sz += ((S7FunctionBlockRow)functionBlockRow).ByteSize;
}
newRow.MC7 = mcges;
retVal.Add(newRow);
Parameters.Clear();
tempList = new List <FunctionBlockRow>();
inBld = 0;
newRow = null;
}
else
{
retVal.AddRange(tempList);
tempList.Clear();
inBld = 0;
}
#endregion
}
else if (inBld == 3 || inBld == 16 || inBld == 14)
{
#region FB Aufruf
tempList.Add(row);
if (row.Command == "=" && n > 0 && myFct.AWLCode[n - 1].Command == Mnemonic.opBLD[(int)myOpt.Mnemonic])
{
//Do nothing, but this line needs to be there!
}
else if (row.Command == Mnemonic.opTDB[(int)myOpt.Mnemonic])
{
//Do nothing, but this line needs to be there!
}
else if (row.Command == Mnemonic.opBLD[(int)myOpt.Mnemonic] && row.Parameter == "11")
{
//whatever this BLD 11 in the FB Calls means...
}
else if (row.Command == Mnemonic.opTAR2[(int)myOpt.Mnemonic])
{
if (ar2Addr.MemoryArea == MemoryArea.None)
{
akPar = "P#DIX " + ar2Addr.ToString();
}
else
{
akPar = ar2Addr.ToString(myOpt.Mnemonic);
}
}
else if (row.Command == Mnemonic.opLAR2[(int)myOpt.Mnemonic])
{
if (row.Parameter.StartsWith("P#"))
{
ar2Addr = new Pointer(row.Parameter.Substring(2));
}
else
{
ar2Addr.ByteAddress = 0;
ar2Addr.BitAddress = 0;
}
}
else if (row.Command == Mnemonic.opPAR2[(int)myOpt.Mnemonic])
{
ar2Addr += new Pointer(row.Parameter);
}
else if (row.Command == Mnemonic.opAUF[(int)myOpt.Mnemonic] && (tempList.Count == 4))
{
diName = row.Parameter;
}
else if (row.Command == Mnemonic.opAUF[(int)myOpt.Mnemonic] && row.Parameter.Contains("[") && (tempList.Count == 6))
{
multiInstance = true;
diName = "";
}
else if (row.Command == Mnemonic.opU[(int)myOpt.Mnemonic] || row.Command == Mnemonic.opUN[(int)myOpt.Mnemonic] ||
row.Command == Mnemonic.opO[(int)myOpt.Mnemonic] || row.Command == Mnemonic.opON[(int)myOpt.Mnemonic] ||
row.Command == Mnemonic.opO[(int)myOpt.Mnemonic] || row.Command == Mnemonic.opON[(int)myOpt.Mnemonic] ||
row.Command == Mnemonic.opX[(int)myOpt.Mnemonic] || row.Command == Mnemonic.opXN[(int)myOpt.Mnemonic] ||
row.Command == Mnemonic.opL[(int)myOpt.Mnemonic])
{
akPar = db + row.Parameter;
db = "";
}
else if (row.Command == Mnemonic.opAUF[(int)myOpt.Mnemonic])
{
db = row.Parameter + ".";
}
else if (row.Command == "CLR")
{
akPar = "FALSE";
}
else if (row.Command == "SET")
{
akPar = "TRUE";
}
else if ((row.Command == "=") && akPar != "")
{
if (afterCall == false)
{
if (!Parameters.ContainsKey(row.Parameter))
{
Parameters.Add(row.Parameter, akPar);
}
}
else
{
if (!Parameters.ContainsKey(akPar))
{
Parameters.Add(akPar, row.Parameter);
}
}
akPar = "";
db = "";
}
else if (row.Command == Mnemonic.opT[(int)myOpt.Mnemonic] && akPar != "")
{
if (afterCall == false)
{
if (!Parameters.ContainsKey(row.Parameter))
{
Parameters.Add(row.Parameter, akPar);
}
}
else
{
if (!Parameters.ContainsKey(akPar))
{
Parameters.Add(akPar, row.Parameter);
}
}
akPar = "";
db = "";
}
else if (row.Command == Mnemonic.opT[(int)myOpt.Mnemonic])
{
if (afterCall == false)
{
if (!Parameters.ContainsKey(row.Parameter))
{
Parameters.Add(row.Parameter, "");
}
}
akPar = "";
db = "";
}
else if (row.Command == Mnemonic.opUC[(int)myOpt.Mnemonic])
{
multiInstanceOffset = 0;
for (int j = tempList.Count - 2; j > -1; j--)
{
if (tempList[j].Command == Mnemonic.opPAR2[(int)myOpt.Mnemonic])
{
multiInstanceOffset += (int)double.Parse((((S7FunctionBlockRow)tempList[j]).Parameter.Substring(2)), CultureInfo.InvariantCulture);
}
break;
}
//Commands after a Call --> Out-Para
callRow = row;
afterCall = true;
}
else if (row.Command == Mnemonic.opBLD[(int)myOpt.Mnemonic] && (row.Parameter == "4" || row.Parameter == "17" || row.Parameter == "15"))
{
//Block Interface auslesen (von FC oder vom Programm)
S7DataRow para = myblkFld.GetInterface(callRow.Parameter);
newRow = new S7FunctionBlockRow();
newRow.Parent = callRow.Parent;
newRow.Command = Mnemonic.opCALL[(int)myOpt.Mnemonic];
newRow.Parameter = callRow.Parameter;
if (diName.Length > 2 && !diName.StartsWith("#"))
{
newRow.DiName = "DI" + int.Parse(diName.Substring(2));
}
else if (diName.StartsWith("#"))
{
newRow.DiName = diName;
}
newRow.CallParameter = new List <S7FunctionBlockParameter>();
if (para != null)
{
var allPar = para.Children.Where(itm => itm.Name == "IN" || itm.Name == "IN_OUT" || itm.Name == "OUT");
foreach (var s7DataRowMain in allPar)
{
foreach (var s7DataRow in s7DataRowMain.Children)
{
S7FunctionBlockParameter newPar = new S7FunctionBlockParameter(newRow);
newPar.Name = s7DataRow.Name;
string par = null;
if (!multiInstance)
{
Parameters.TryGetValue(((S7DataRow)s7DataRow).BlockAddressInDbFormat.Replace("DB", "DI"), out par);
}
else if (((S7DataRow)s7DataRow).DataType == S7DataRowType.ANY)
{
var anySizeAddr = ((S7DataRow)s7DataRow).BlockAddress.ByteAddress + multiInstanceOffset + 2;
var anyPosAddr = ((S7DataRow)s7DataRow).BlockAddress.ByteAddress + multiInstanceOffset + 6;
string anySize = "";
string anyPos = "";
Parameters.TryGetValue("DIW[AR2,P#" + anySizeAddr + ".0]", out anySize);
Parameters.TryGetValue("DID[AR2,P#" + anyPosAddr + ".0]", out anyPos);
par = anyPos + " BYTE " + anySize;
}
else
{
var addr = ((S7DataRow)s7DataRow).BlockAddressInDbFormat;
if (!string.IsNullOrEmpty(addr))
{
var addrTp = addr.Substring(0, 3).Replace("DB", "DI");
double bytepos = double.Parse(addr.Substring(3), CultureInfo.InvariantCulture) + multiInstanceOffset;
Parameters.TryGetValue(addrTp + "[AR2,P#" + bytepos.ToString("0.0", CultureInfo.InvariantCulture) + "]", out par);
}
}
if (par != null && par.Contains("[AR2"))
{
newPar.Value = par;
var addr = par.Substring(10);
addr = addr.Substring(0, addr.Length - 1);
var pRow = S7DataRow.GetDataRowWithAddress(myFct.Parameter.Children.Where(itm => itm.Name != "TEMP").Cast <S7DataRow>(), new ByteBitAddress(addr));
if (pRow != null)
{
newPar.Value = ((S7DataRow)pRow).StructuredName.Substring(((S7DataRow)pRow).StructuredName.IndexOf('.') + 1);
}
}
else
{
switch (((S7DataRow)s7DataRow).DataType)
{
case S7DataRowType.BLOCK_DB:
newPar.Value = "DB" + par;
break;
case S7DataRowType.BLOCK_FC:
newPar.Value = "FC" + par;
break;
case S7DataRowType.BLOCK_FB:
newPar.Value = "FB" + par;
break;
case S7DataRowType.TIMER:
newPar.Value = Mnemonic.adT[(int)myOpt.Mnemonic] + par.ToString();
break;
case S7DataRowType.COUNTER:
newPar.Value = Mnemonic.adZ[(int)myOpt.Mnemonic] + par.ToString();
break;
case S7DataRowType.TIME:
if (par != null && par.StartsWith("L#"))
{
var arr = BitConverter.GetBytes(Convert.ToInt32(par.Substring(2)));
Array.Reverse(arr);
newPar.Value = Helper.GetDTime(arr, 0);
}
else
{
newPar.Value = par;
}
break;
default:
newPar.Value = par;
break;
}
}
newRow.CallParameter.Add(newPar);
}
}
}
newRow.CombinedCommands = tempList;
newRow.Label = label;
int sz = 0;
foreach (var functionBlockRow in newRow.CombinedCommands)
{
sz += ((S7FunctionBlockRow)functionBlockRow).ByteSize;
}
byte[] mcges = new byte[sz];
sz = 0;
foreach (var functionBlockRow in newRow.CombinedCommands)
{
Array.Copy(((S7FunctionBlockRow)functionBlockRow).MC7, 0, mcges, sz, ((S7FunctionBlockRow)functionBlockRow).ByteSize);
sz += ((S7FunctionBlockRow)functionBlockRow).ByteSize;
}
newRow.MC7 = mcges;
retVal.Add(newRow);
Parameters.Clear();
tempList = new List <FunctionBlockRow>();
inBld = 0;
newRow = null;
}
else
{
retVal.AddRange(tempList);
tempList.Clear();
inBld = 0;
}
#endregion
}
else
{
retVal.Add(row);
}
}
myFct.AWLCode = retVal;
}
}
/// <summary>
/// Parses the AWL Text and returns the S7Blocks
/// </summary>
/// <param name="AWL"></param>
/// <param name="SymbolTable">Can be null</param>
/// <returns></returns>
public static List <S7Block> ParseAWL(string AWL, string SymbolTable)
{
var retVal = new List <S7Block>();
string txt = "";
string blockType = "";
string blockNumberOrName = "";
string blockRetValType = "";
bool startOfQuote = false;
ParseStep step = ParseStep.ReadBlockType;
S7DataRow akDataRow = null;
S7Block akBlock = null;
foreach (char c in AWL)
{
if (!startOfQuote && (c == ' ' || c == '\n' || c == '\r' || c == '=' || c == ':') || c == '"')
{
if (c == '"' && !startOfQuote)
{
startOfQuote = true;
}
else if (startOfQuote)
{
startOfQuote = false;
}
if (step == ParseStep.ReadBlockRetVal && txt != "" && txt != ":") //Header ohne RetVal
{
blockRetValType = "";
akBlock = CreateBlock(blockType, blockNumberOrName, blockRetValType);
step = ParseStep.ParseHeaderRow;
}
if (step == ParseStep.ParseTitle && (c == '\n' || c == '\r'))
{
step = ParseStep.ParseHeaderRow;
}
if (txt != "")
{
switch (step)
{
case ParseStep.ReadBlockType:
{
blockType = txt.ToUpper();
step = ParseStep.ReadBlockNumberOrName;
break;
}
case ParseStep.ReadBlockNumberOrName:
{
blockNumberOrName = txt;
step = ParseStep.ReadBlockRetVal;
break;
}
case ParseStep.ReadBlockRetVal:
{
step = ParseStep.ReadBlockRetValType;
break;
}
case ParseStep.ReadBlockRetValType:
{
blockRetValType = txt;
akBlock = CreateBlock(blockType, blockNumberOrName, blockRetValType);
step = ParseStep.ParseHeaderRow;
break;
}
case ParseStep.ParseHeaderRow:
{
switch (txt.ToUpper())
{
case ("TITLE"):
{
step = ParseStep.ParseTitle;
break;
}
case ("VERSION"):
{
step = ParseStep.ParseVersion;
break;
}
case ("STRUCT"):
{
step = ParseStep.ParseStructure;
break;
}
case ("BEGIN"):
{
step = ParseStep.ParseAWLCode;
break;
}
case ("VAR_INPUT"):
case ("VAR_OUTPUT"):
case ("VAR_IN_OUT"):
case ("VAR_TEMP"):
{
step = ParseStep.ParsePara;
break;
}
default:
{
if (txt.StartsWith("{") && txt.EndsWith("}"))
{
akBlock.Attributes = ParseStep7Attribute(txt);
}
break;
}
}
break;
}
case ParseStep.ParseTitle:
{
akBlock.Title = txt;
step = ParseStep.ParseHeaderRow;
break;
}
case ParseStep.ParseVersion:
{
akBlock.Version = txt;
step = ParseStep.ParseHeaderRow;
break;
}
}
}
txt = "";
}
else
{
txt = txt + c;
}
}
return(retVal);
}
/// <summary>
/// Reads an Block from the Project and returns the block data that is stored in the S7 Project
/// </summary>
/// <param name="blkInfo">The Block info object that identifies the block to read from Disk</param>
/// <param name="myConvOpt">Defines options that determine how the Block will be converted</param>
/// <returns></returns>
public Block GetBlock(ProjectBlockInfo blkInfo, S7ConvertingOptions myConvOpt)
{
if (blkInfo._Block != null && ((blkInfo._Block) as S7Block).usedS7ConvertingOptions.Equals(myConvOpt))
{
return(blkInfo._Block);
}
ProjectPlcBlockInfo plcblkifo = (ProjectPlcBlockInfo)blkInfo;
tmpBlock myTmpBlk = GetBlockBytes(blkInfo);
List <Step7Attribute> step7Attributes = null;
if (myTmpBlk != null)
{
if (myTmpBlk.uda != null)
{
int uPos = 2;
if (myTmpBlk.uda != null && myTmpBlk.uda.Length > 0 && myTmpBlk.uda[0] > 0)
{
step7Attributes = new List <Step7Attribute>();
for (int j = 0; j < myTmpBlk.uda[0]; j++)
{
string t1 = Project.ProjectEncoding.GetString(myTmpBlk.uda, uPos + 1, myTmpBlk.uda[uPos]);
uPos += myTmpBlk.uda[uPos] + 1;
string t2 = Project.ProjectEncoding.GetString(myTmpBlk.uda, uPos + 1, myTmpBlk.uda[uPos]);
uPos += myTmpBlk.uda[uPos] + 1;
step7Attributes.Add(new Step7Attribute(t1, t2));
}
}
}
//Begin with the Block Reading...
if (blkInfo.BlockType == PLCBlockType.VAT)
{
S7VATBlock retValBlock = new S7VATBlock(myTmpBlk.mc7code, myTmpBlk.comments, plcblkifo.BlockNumber, Project.ProjectEncoding);
retValBlock.Attributes = step7Attributes;
retValBlock.LastCodeChange = myTmpBlk.LastCodeChange;
retValBlock.LastInterfaceChange = myTmpBlk.LastInterfaceChange;
retValBlock.ParentFolder = this;
retValBlock.usedS7ConvertingOptions = myConvOpt;
blkInfo._Block = retValBlock;
return(retValBlock);
}
else if (blkInfo.BlockType == PLCBlockType.DB || blkInfo.BlockType == PLCBlockType.UDT)
{
List <string> tmpList = new List <string>();
S7DataBlock retVal = new S7DataBlock();
retVal.IsInstanceDB = myTmpBlk.IsInstanceDB;
retVal.FBNumber = myTmpBlk.FBNumber;
//if this is an interface DB, then rather take the Interface declaration from the instance FB,
//instead of the data sotred in the project.
//The reason is that if you change the comment in an FB, the DB data is not actualized and my contain outdated
//Declarations. When you change the interface, Step7 tells you to "regenerate" the instance DB which only then would
//Actualize the comments. Simple Commentary changes do not change the Datablocks row.
if (retVal.IsInstanceDB && myConvOpt.UseFBDeclarationForInstanceDB)
{
//load the FB data from the Project
tmpBlock InstFB = GetBlockBytes((myTmpBlk.IsSFB ? "SFB" : "FB") + myTmpBlk.FBNumber);
//Resolve both interfaces
List <string> tmpPar = new List <string>();
if (InstFB != null)
{
S7DataRow InterfaceFB =
Parameter.GetInterfaceOrDBFromStep7ProjectString(InstFB.blkinterface, ref tmpPar,
PLCBlockType.FB, false, this, null);
S7DataRow InterfaceDB =
Parameter.GetInterfaceOrDBFromStep7ProjectString(myTmpBlk.blkinterface, ref tmpPar,
PLCBlockType.DB, false, this, null);
//Only use the FB interface Declaration if they are compatible
if (Parameter.IsInterfaceCompatible(InterfaceFB, InterfaceDB))
{
myTmpBlk.blkinterface = InstFB.blkinterface;
}
}
}
if (myTmpBlk.mc7code != null)
{
retVal.CodeSize = myTmpBlk.mc7code.Length;
}
retVal.StructureFromString = Parameter.GetInterfaceOrDBFromStep7ProjectString(myTmpBlk.blkinterface, ref tmpList, blkInfo.BlockType, false, this, retVal, myTmpBlk.mc7code);
if (myTmpBlk.blkinterfaceInMC5 != null)
{
//List<string> tmp = new List<string>();
//retVal.StructureFromMC7 = Parameter.GetInterface(myTmpBlk.blkinterfaceInMC5, myTmpBlk.mc7code, ref tmp, blkInfo.BlockType, myTmpBlk.IsInstanceDB, retVal);
}
retVal.BlockNumber = plcblkifo.BlockNumber;
retVal.BlockType = blkInfo.BlockType;
retVal.Attributes = step7Attributes;
retVal.LastCodeChange = myTmpBlk.LastCodeChange;
retVal.LastInterfaceChange = myTmpBlk.LastInterfaceChange;
retVal.ParentFolder = this;
retVal.usedS7ConvertingOptions = myConvOpt;
retVal.CheckSum = myTmpBlk.CheckSum;
blkInfo._Block = retVal;
return(retVal);
}
else if (blkInfo.BlockType == PLCBlockType.FC || blkInfo.BlockType == PLCBlockType.FB || blkInfo.BlockType == PLCBlockType.OB || blkInfo.BlockType == PLCBlockType.SFB || blkInfo.BlockType == PLCBlockType.SFC)
{
List <string> ParaList = new List <string>();
S7FunctionBlock retVal = new S7FunctionBlock();
retVal.LastCodeChange = myTmpBlk.LastCodeChange;
retVal.LastInterfaceChange = myTmpBlk.LastInterfaceChange;
retVal.BlockNumber = plcblkifo.BlockNumber;
retVal.BlockType = blkInfo.BlockType;
retVal.Attributes = step7Attributes;
retVal.KnowHowProtection = myTmpBlk.knowHowProtection;
retVal.MnemonicLanguage = Project.ProjectLanguage;
retVal.Author = myTmpBlk.username;
retVal.Version = myTmpBlk.version;
retVal.Parameter = Parameter.GetInterfaceOrDBFromStep7ProjectString(myTmpBlk.blkinterface, ref ParaList, blkInfo.BlockType, false, this, retVal);
if (myTmpBlk.blockdescription != null)
{
retVal.Title = Project.ProjectEncoding.GetString(myTmpBlk.blockdescription, 3, myTmpBlk.blockdescription[1] - 4);
retVal.Description = Project.ProjectEncoding.GetString(myTmpBlk.blockdescription, myTmpBlk.blockdescription[1], myTmpBlk.blockdescription.Length - myTmpBlk.blockdescription[1] - 1).Replace("\n", Environment.NewLine);
}
if (blkInfo.BlockType == PLCBlockType.FC || blkInfo.BlockType == PLCBlockType.FB || blkInfo.BlockType == PLCBlockType.OB)
{
retVal.CodeSize = myTmpBlk.mc7code.Length;
int[] Networks;
Networks = NetWork.GetNetworks(0, myTmpBlk.nwinfo);
S7ProgrammFolder prgFld = null;
if (this.Parent is S7ProgrammFolder)
{
prgFld = (S7ProgrammFolder)this.Parent;
}
retVal.AWLCode = MC7toAWL.GetAWL(0, myTmpBlk.mc7code.Length - 2, (int)myConvOpt.Mnemonic, myTmpBlk.mc7code, Networks, ParaList, prgFld, retVal, retVal.Parameter);
retVal.AWLCode = JumpMarks.AddJumpmarks(retVal.AWLCode, myTmpBlk.jumpmarks, myTmpBlk.nwinfo, myConvOpt);
LocalDataConverter.ConvertLocaldataToSymbols(retVal, myConvOpt);
CallConverter.ConvertUCToCall(retVal, prgFld, this, myConvOpt, null);
FBStaticAccessConverter.ReplaceStaticAccess(retVal, prgFld, myConvOpt);
#region UseComments from Block
if (myConvOpt.UseComments)
{
List <FunctionBlockRow> newAwlCode = new List <FunctionBlockRow>();
int n = 0;
int akRowInAwlCode = 0;
int lineNumberInCall = 0; //Counter wich line in Command (for Calls and UCs)
if (myTmpBlk.comments != null)
{
byte[] cmt = myTmpBlk.comments;
//string aa = System.Text.Encoding.GetEncoding("Windows-1251").GetString(cmt);
//string testaa = "";
while (n < myTmpBlk.comments.Length)
{
int kommLen = cmt[n + 0];
int startNWKomm = cmt[n + 1];
int anzUebsprungZeilen = cmt[n + 2] + cmt[n + 3] * 0x100;
int lenNWKommZeile = cmt[n + 3] + cmt[n + 4] * 0x100;
//Console.WriteLine(cmt[n + 5].ToString("X"));
if (cmt[n + 5] == 0x06)
{
//NWKomentar:
string tx1 = Project.ProjectEncoding.GetString(cmt, n + 6, startNWKomm - 7);
string tx2 = Project.ProjectEncoding.GetString(cmt, n + startNWKomm, lenNWKommZeile - startNWKomm - 1).Replace("\n", Environment.NewLine);
n += lenNWKommZeile;
if (retVal.AWLCode.Count > akRowInAwlCode)
{
while (retVal.AWLCode.Count - 1 > akRowInAwlCode && retVal.AWLCode[akRowInAwlCode].Command != "NETWORK")
{
if (!newAwlCode.Contains(retVal.AWLCode[akRowInAwlCode]))
{
//newAwlCode.Add(retVal.AWLCode[akRowInAwlCode]);
S7FunctionBlockRow akRw = (S7FunctionBlockRow)retVal.AWLCode[akRowInAwlCode];
if (akRw.CombineDBAccess)
{
S7FunctionBlockRow nRw = (S7FunctionBlockRow)retVal.AWLCode[akRowInAwlCode + 1];
if (!nRw.Parameter.Contains("["))
{
nRw.Parameter = akRw.Parameter + "." + nRw.Parameter;
nRw.MC7 = Helper.CombineByteArray(akRw.MC7, nRw.MC7);
nRw.Label = akRw.Label ?? nRw.Label;
akRw = nRw;
retVal.AWLCode.RemoveAt(akRowInAwlCode + 1);
}
}
if (!newAwlCode.Contains(akRw))
{
newAwlCode.Add(akRw);
}
}
akRowInAwlCode++;
}
((S7FunctionBlockRow)retVal.AWLCode[akRowInAwlCode]).NetworkName = tx1;
((S7FunctionBlockRow)retVal.AWLCode[akRowInAwlCode]).Comment = tx2;
newAwlCode.Add(retVal.AWLCode[akRowInAwlCode]);
}
akRowInAwlCode++;
lineNumberInCall = 0;
}
else
{
S7FunctionBlockRow lastRow = null;
//Anzahl der Anweisungen vor diesem Kommentar (inklusive aktueller Zeile!)
for (int q = 0; q < (anzUebsprungZeilen); q++)
{
if (retVal.AWLCode.Count > akRowInAwlCode)
{
S7FunctionBlockRow akRw = (S7FunctionBlockRow)retVal.AWLCode[akRowInAwlCode];
if (cmt[n + 4] == 0xc0 && q == anzUebsprungZeilen - 1)
{
akRw.CombineDBAccess = false;
}
//Db Zugriff zusammenfügen...
if (akRw.CombineDBAccess)
{
S7FunctionBlockRow nRw = (S7FunctionBlockRow)retVal.AWLCode[akRowInAwlCode + 1];
nRw.Parameter = akRw.Parameter + "." + nRw.Parameter;
nRw.MC7 = Helper.CombineByteArray(akRw.MC7, nRw.MC7);
nRw.Label = akRw.Label ?? nRw.Label;
akRw = nRw;
retVal.AWLCode.RemoveAt(akRowInAwlCode + 1);
}
if (!newAwlCode.Contains(akRw))
{
newAwlCode.Add(akRw);
}
if (akRw.GetNumberOfLines() == 1)
{
lineNumberInCall = 0;
lastRow = akRw;
//if (!newAwlCode.Contains(akRw))
// newAwlCode.Add(akRw);
akRowInAwlCode++;
}
else
{
lastRow = akRw;
if (lineNumberInCall == 0 && !(cmt[n + 4] != 0x80 && cmt[n + 4] != 0xc0))
{
//if (!newAwlCode.Contains(akRw))
// newAwlCode.Add(akRw);
}
if (akRw.GetNumberOfLines() - 1 == lineNumberInCall)
{
akRowInAwlCode++;
lineNumberInCall = 0;
//subCnt++; //The set to zero was wrong here, but maybe now comments on calls do not work, need to check!
}
else
{
lineNumberInCall++;
}
}
}
}
//if (lastRow == null || cmt[n + 4] != 0x80)
if (lastRow == null || (cmt[n + 4] != 0x80 && cmt[n + 4] != 0xc0))
{
lastRow = new S7FunctionBlockRow()
{
Parent = retVal
};
newAwlCode.Add(lastRow);
lineNumberInCall = 0;
}
string tx1 = Project.ProjectEncoding.GetString(cmt, n + 6, kommLen);
if (lineNumberInCall == 0)
{
lastRow.Comment = tx1;
}
else
if (lastRow.Command == "CALL")
{
if (lineNumberInCall == 1)
{
lastRow.Comment = tx1;
}
else
{
if (lastRow.CallParameter.Count >= lineNumberInCall - 2)
{
lastRow.CallParameter[lineNumberInCall - 2].Comment = tx1;
}
}
}
n += kommLen + 6;
//subCnt = 0;
}
}
}
while (akRowInAwlCode < retVal.AWLCode.Count)
{
newAwlCode.Add(retVal.AWLCode[akRowInAwlCode]);
akRowInAwlCode++;
}
retVal.AWLCode = newAwlCode;
}
#endregion
}
retVal.Networks = NetWork.GetNetworksList(retVal);
retVal.ParentFolder = this;
retVal.usedS7ConvertingOptions = myConvOpt;
retVal.CheckSum = myTmpBlk.CheckSum;
blkInfo._Block = retVal;
return(retVal);
}
}
return(null);
}
/*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;
}
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);
}
//
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);
}
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;
parameterIN.isRootBlock = true;
parameterOUT.isRootBlock = true;
parameterINOUT.isRootBlock = true;
parameterINOUT.isInOut = true;
parameterSTAT.isRootBlock = true;
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 static void ReplaceStaticAccess(S7FunctionBlock myFct, S7ProgrammFolder myFld, S7ConvertingOptions myOpt)
{
if (myOpt.ReplaceDIAccessesWithSymbolNames && myFct.BlockType == PLCBlockType.FB)
{
List <FunctionBlockRow> retVal = new List <FunctionBlockRow>();
List <FunctionBlockRow> tempList = new List <FunctionBlockRow>();
bool LargeAccess = false;
int add_adresse = 0;
foreach (var functionBlockRow in myFct.AWLCode)
{
if (functionBlockRow.Command == "TAR2")
{
tempList.Add(functionBlockRow);
LargeAccess = true;
}
else if (functionBlockRow.Command == "+AR2" && LargeAccess)
{
tempList.Add(functionBlockRow);
add_adresse += Convert.ToInt32(Convert.ToDouble(((S7FunctionBlockRow)functionBlockRow).Parameter.Substring(2), new NumberFormatInfo()
{
NumberDecimalSeparator = "."
}));
}
else if (((S7FunctionBlockRow)functionBlockRow).Parameter.Contains("[AR2,P#") && ((S7FunctionBlockRow)functionBlockRow).Parameter.Substring(0, 2) == "DI" && !LargeAccess)
{
string para = ((S7FunctionBlockRow)functionBlockRow).Parameter;
ByteBitAddress adr = new ByteBitAddress(para.Substring(10, para.Length - 11));
var parRow = S7DataRow.GetDataRowWithAddress(myFct.Parameter, adr, true);
if (parRow != null)
{
byte[] tmp = ((S7FunctionBlockRow)functionBlockRow).MC7;
((S7FunctionBlockRow)functionBlockRow).Parameter = "#" + parRow.StructuredName.Substring(parRow.StructuredName.IndexOf('.') + 1);
((S7FunctionBlockRow)functionBlockRow).MC7 = tmp;
}
retVal.Add(functionBlockRow);
}
else if (((S7FunctionBlockRow)functionBlockRow).Parameter.Contains("[AR2,P#") && ((S7FunctionBlockRow)functionBlockRow).Parameter.Substring(0, 2) == "DI" && LargeAccess)
{
/*
* string para = ((S7FunctionBlockRow)functionBlockRow).Parameter;
* ByteBitAddress adr = new ByteBitAddress(para.Substring(10, para.Length - 11));
* adr.ByteAddress += add_adresse;
* var parRow = S7DataRow.GetDataRowWithAddress(myFct.Parameter, adr);
* if (parRow != null)
* {
* byte[] tmp = ((S7FunctionBlockRow)functionBlockRow).MC7;
* ((S7FunctionBlockRow)functionBlockRow).Parameter = "#" + parRow.StructuredName;
* ((S7FunctionBlockRow)functionBlockRow).MC7 = tmp;
* }
* retVal.Add(functionBlockRow);
*/
LargeAccess = false;
}
else if (functionBlockRow.Command == "LAR2")
{
}
else
{
LargeAccess = false;
retVal.AddRange(tempList);
tempList.Clear();
retVal.Add(functionBlockRow);
}
}
myFct.AWLCode = retVal;
}
}
public static S7DataRow ParseChildrenRowsFromText(List <String> inputText, String structName, String structComment, DotNetSiemensPLCToolBoxLibrary.DataTypes.Blocks.Block blockName)
{
S7DataRow newRow = new S7DataRow(structName, S7DataRowType.STRUCT, blockName);
newRow.Comment = structComment;
bool finished = false;
while (inputText.Count > 0 && !finished)
{
String line = inputText[0];
inputText.RemoveAt(0);
String trimmedLine = line.Trim();
String comment = "";
String type = "";
String name = "";
String arrayType = "";
String[] splitString;
S7DataRow childRow = new S7DataRow("", S7DataRowType.ANY, blockName);
int length = 0;
int arrayStart = 0;
bool typeFailed = false;
if (trimmedLine.Contains("//"))
{
splitString = trimmedLine.Split(new string[] { "//" }, StringSplitOptions.RemoveEmptyEntries);
comment = splitString[1].Trim();
trimmedLine = splitString[0];
}
if (trimmedLine.Contains(":"))
{
splitString = trimmedLine.Split(':');
type = splitString[1].Trim().Trim(';').Trim('\"').Trim();
name = splitString[0].Trim();
if (type.ToUpper().Contains("ARRAY"))
{
name = name.Trim('\"');
splitString = type.Split(new string[] { "[", "..", "]" }, StringSplitOptions.RemoveEmptyEntries);
if (splitString.Length == 4)
{
bool parsed = Int32.TryParse(splitString[2], out length);
bool parsed2 = Int32.TryParse(splitString[1], out arrayStart);
}
splitString = type.Split(new string[] { "of" }, StringSplitOptions.RemoveEmptyEntries);
if (splitString.Length > 1)
{
arrayType = splitString[1].Trim().Trim('\"');
}
type = "ARRAY";
}
else if (type.ToUpper().Contains("STRING"))
{
splitString = type.Split(new string[] { "[", "]" }, StringSplitOptions.RemoveEmptyEntries);
if (splitString.Length > 1)
{
bool parsed = Int32.TryParse(splitString[1], out length);
}
else
{
length = 254;
}
type = "STRING";
}
}
comment = String.IsNullOrEmpty(comment) ? name : comment;
if (trimmedLine.ToUpper().Contains("END_STRUCT"))
{
finished = true;
break;
}
switch (type.ToUpper())
{
case "":
typeFailed = true;
break;
case "ARRAY":
S7DataRowType dataType;
bool parsed = Enum.TryParse <S7DataRowType>(arrayType.ToUpper(), out dataType);
if (!parsed)
{
typeFailed = GetUdtStructureFromSource(arrayType, out childRow);
childRow.Name = name;
childRow.DataType = S7DataRowType.UDT;
}
else
{
childRow = new S7DataRow(name, dataType, blockName);
}
childRow.IsArray = true;
childRow.ArrayStart = new List <int>(new int[] { arrayStart });
childRow.ArrayStop = new List <int>(new int[] { length });
break;
case "STRING":
childRow = new S7DataRow(name, S7DataRowType.STRING, blockName);
childRow.StringSize = length;
break;
case "BOOL":
childRow = new S7DataRow(name, S7DataRowType.BOOL, blockName);
break;
case "INT":
childRow = new S7DataRow(name, S7DataRowType.INT, blockName);
break;
case "REAL":
childRow = new S7DataRow(name, S7DataRowType.REAL, blockName);
break;
case "DATE":
childRow = new S7DataRow(name, S7DataRowType.DATE, blockName);
break;
case "DATE_AND_TIME":
childRow = new S7DataRow(name, S7DataRowType.DATE_AND_TIME, blockName);
break;
case "TIME":
childRow = new S7DataRow(name, S7DataRowType.TIME, blockName);
break;
case "TIME_OF_DAY":
childRow = new S7DataRow(name, S7DataRowType.TIME_OF_DAY, blockName);
break;
case "S5TIME":
childRow = new S7DataRow(name, S7DataRowType.S5TIME, blockName);
break;
case "WORD":
childRow = new S7DataRow(name, S7DataRowType.WORD, blockName);
break;
case "BYTE":
childRow = new S7DataRow(name, S7DataRowType.BYTE, blockName);
break;
case "CHAR":
childRow = new S7DataRow(name, S7DataRowType.CHAR, blockName);
break;
case "DINT":
childRow = new S7DataRow(name, S7DataRowType.DINT, blockName);
break;
case "DWORD":
childRow = new S7DataRow(name, S7DataRowType.DWORD, blockName);
break;
case "STRUCT":
childRow = ParseChildrenRowsFromText(inputText, name, comment, blockName);
break;
default:
typeFailed = GetUdtStructureFromSource(type, out childRow);
childRow.Name = name;
break;
}
if (typeFailed)
{
break;
}
childRow.Comment = comment;
newRow.Add(childRow);
}
if (!finished)
{
// for some reason we didn't get to an "END_STRUCT" and there is a struct mismatch
throw new NotImplementedException();
}
return(newRow);
}
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);
}
private void cmdCreateWinCCFlexibleTags_Click(object sender, EventArgs e)
{
S7DataBlock myDB = (S7DataBlock)((BlocksOfflineFolder)blkFld).GetBlock((S7ProjectBlockInfo)lstListBox.SelectedItem);
List <S7DataRow> myLst = null;
if (chkExpandArrays.Checked)
{
myLst = S7DataRow.GetChildrowsAsList(myDB.GetArrayExpandedStructure(new S7DataBlockExpandOptions())); // ) myDB.GetRowsAsArrayExpandedList(ne);
}
else
{
myLst = S7DataRow.GetChildrowsAsList(myDB.Structure); // myDB.GetRowsAsList();
}
string tags = "";
foreach (S7DataRow plcDataRow in myLst) // myDB.GetRowsAsList())
{
string tagName = txtTagsPrefix.Text + plcDataRow.StructuredName.Replace(".", "_").Replace("[", "_").Replace("]", "").Replace(" ", "").Replace(",", "_");
switch (plcDataRow.DataType)
{
case S7DataRowType.BOOL:
tags += tagName + ";" + txtConnectionName.Text + ";DB " + myDB.BlockNumber + " DBX " + plcDataRow.BlockAddress.ByteAddress.ToString() + "." + plcDataRow.BlockAddress.BitAddress.ToString() + ";Bool;;" + "1" + ";2;1 s;;;;;0;10;0;100;0;;0;\r\n";
break;
case S7DataRowType.INT:
tags += tagName + ";" + txtConnectionName.Text + ";DB " + myDB.BlockNumber + " DBW " + plcDataRow.BlockAddress.ByteAddress.ToString() + ";Int;;" + "1" + ";2;1 s;;;;;0;10;0;100;0;;0;\r\n";
break;
case S7DataRowType.DINT:
tags += tagName + ";" + txtConnectionName.Text + ";DB " + myDB.BlockNumber + " DBD " + plcDataRow.BlockAddress.ByteAddress.ToString() + ";DInt;;" + "1" + ";2;1 s;;;;;0;10;0;100;0;;0;\r\n";
break;
case S7DataRowType.WORD:
tags += tagName + ";" + txtConnectionName.Text + ";DB " + myDB.BlockNumber + " DBW " + plcDataRow.BlockAddress.ByteAddress.ToString() + ";Word;;" + "1" + ";2;1 s;;;;;0;10;0;100;0;;0;\r\n";
break;
case S7DataRowType.DWORD:
tags += tagName + ";" + txtConnectionName.Text + ";DB " + myDB.BlockNumber + " DBD " + plcDataRow.BlockAddress.ByteAddress.ToString() + ";DWord;;" + "1" + ";2;1 s;;;;;0;10;0;100;0;;0;\r\n";
break;
case S7DataRowType.BYTE:
tags += tagName + ";" + txtConnectionName.Text + ";DB " + myDB.BlockNumber + " DBB " + plcDataRow.BlockAddress.ByteAddress.ToString() + ";Byte;;" + "1" + ";2;1 s;;;;;0;10;0;100;0;;0;\r\n";
break;
case S7DataRowType.REAL:
tags += tagName + ";" + txtConnectionName.Text + ";DB " + myDB.BlockNumber + " DBD " + plcDataRow.BlockAddress.ByteAddress.ToString() + ";Real;;" + "1" + ";2;1 s;;;;;0;10;0;100;0;;0;\r\n";
break;
case S7DataRowType.CHAR:
if (plcDataRow.IsArray)
{
tags += tagName + ";" + txtConnectionName.Text + ";DB " + myDB.BlockNumber + " DBB " + plcDataRow.BlockAddress.ByteAddress.ToString() + ";StringChar;" + plcDataRow.GetArrayLines().ToString() + ";" + "1" + ";2;1 s;;;;;0;10;0;100;0;;0;\r\n";
}
else
{
tags += tagName + ";" + txtConnectionName.Text + ";DB " + myDB.BlockNumber + " DBB " + plcDataRow.BlockAddress.ByteAddress.ToString() + ";Char;;" + "1" + ";2;1 s;;;;;0;10;0;100;0;;0;\r\n";
}
break;
case S7DataRowType.COUNTER:
tags += tagName + ";" + txtConnectionName.Text + ";DB " + myDB.BlockNumber + " DBW " + plcDataRow.BlockAddress.ByteAddress.ToString() + ";Counter;;" + "1" + ";2;1 s;;;;;0;10;0;100;0;;0;\r\n";
break;
case S7DataRowType.DATE:
tags += tagName + ";" + txtConnectionName.Text + ";DB " + myDB.BlockNumber + " DBD " + plcDataRow.BlockAddress.ByteAddress.ToString() + ";Date;;" + "1" + ";2;1 s;;;;;0;10;0;100;0;;0;\r\n";
break;
case S7DataRowType.DATE_AND_TIME:
tags += tagName + ";" + txtConnectionName.Text + ";DB " + myDB.BlockNumber + " DBB " + plcDataRow.BlockAddress.ByteAddress.ToString() + ";Date and Time;;" + "1" + ";2;1 s;;;;;0;10;0;100;0;;0;\r\n";
break;
case S7DataRowType.S5TIME:
tags += tagName + ";" + txtConnectionName.Text + ";DB " + myDB.BlockNumber + " DBW " + plcDataRow.BlockAddress.ByteAddress.ToString() + ";Timer;;" + "1" + ";2;1 s;;;;;0;10;0;100;0;;0;\r\n";
break;
case S7DataRowType.STRING:
tags += tagName + ";" + txtConnectionName.Text + ";DB " + myDB.BlockNumber + " DBB " + plcDataRow.BlockAddress.ByteAddress.ToString() + ";String;" + plcDataRow.StringSize.ToString() + ";" + "1" + ";2;1 s;;;;;0;10;0;100;0;;0;\r\n";
break;
case S7DataRowType.TIME:
tags += tagName + ";" + txtConnectionName.Text + ";DB " + myDB.BlockNumber + " DBD " + plcDataRow.BlockAddress.ByteAddress.ToString() + ";Time;;" + "1" + ";2;1 s;;;;;0;10;0;100;0;;0;\r\n";
break;
case S7DataRowType.TIME_OF_DAY:
tags += tagName + ";" + txtConnectionName.Text + ";DB " + myDB.BlockNumber + " DBD " + plcDataRow.BlockAddress.ByteAddress.ToString() + ";Time of Day;;" + "1" + ";2;1 s;;;;;0;10;0;100;0;;0;\r\n";
break;
case S7DataRowType.TIMER:
tags += tagName + ";" + txtConnectionName.Text + ";DB " + myDB.BlockNumber + " DBW " + plcDataRow.BlockAddress.ByteAddress.ToString() + ";Timer;;" + "1" + ";2;1 s;;;;;0;10;0;100;0;;0;\r\n";
break;
}
}
FolderBrowserDialog fldDlg = null;
fldDlg = new FolderBrowserDialog();
fldDlg.Description = "Destination Directory for Tags.csv!";
if (fldDlg.ShowDialog() == DialogResult.OK)
{
System.IO.StreamWriter swr;
swr = new System.IO.StreamWriter(fldDlg.SelectedPath + "\\Tags.csv");
swr.Write(tags.Replace(";", "\t"));
swr.Close();
}
}
private void Button_Click(object sender, RoutedEventArgs e)
{
string errors = "";
string tags = "";
foreach (var projectBlockInfo in ConvertBlocks)
{
S7DataBlock myDB = (S7DataBlock)projectBlockInfo.GetBlock();
int cnt = 0;
if (myDB.Structure != null && myDB.Structure.Children != null)
{
cnt = myDB.Structure.Children[myDB.Structure.Children.Count - 1].NextBlockAddress.ByteAddress;
}
string varname = "STOERUNGEN_DB" + myDB.BlockNumber;
tags += varname + ";" + txtConnectionName.Text + ";DB " + myDB.BlockNumber + " DBW 0;Int;;" +
((cnt - 2) / 2).ToString() + ";2;1 s;;;;;0;10;0;100;0;;0;\r\n";
int errNr = Convert.ToInt32(txtStartErrorNumber.Text);
foreach (S7DataRow plcDataRow in S7DataRow.GetChildrowsAsList(myDB.Structure))
// myDB.GetRowsAsList())
{
if (plcDataRow.DataType == S7DataRowType.BOOL)
{
ByteBitAddress akAddr = plcDataRow.BlockAddress;
int bitnr = (akAddr.ByteAddress / 2) * 16 + akAddr.BitAddress; //akAddr.BitAddress;
if (akAddr.ByteAddress % 2 == 0)
{
bitnr += 8;
}
string stoeTxt = "";
string stoeTxtEn = "";
stoeTxt = plcDataRow.Comment;
if (stoeTxt.Contains(";"))
{
stoeTxt = "Störort: " + stoeTxt.Split(';')[0] + ", " + stoeTxt.Split(';')[1];
}
if (chkFixedErrorNumber.IsChecked.Value)
{
errNr = Convert.ToInt32(txtStartErrorNumber.Text) + akAddr.ByteAddress * 8 + akAddr.BitAddress;
}
errors += "\"D\"\t\"" + errNr.ToString() + "\"\t\"Alarms\"\t\"" + varname + "\"\t\"" +
bitnr.ToString() + "\"\t\t\t\t\t\t\"0\"\t\"de-DE=" + stoeTxt + "\"\t\"en-US=" +
stoeTxtEn + "\"\t\"de-DE=\"" + "\r\n";
if (!chkFixedErrorNumber.IsChecked.Value)
{
errNr++;
}
}
}
}
FolderBrowserDialog fldDlg = null;
fldDlg = new FolderBrowserDialog();
fldDlg.Description = "Destination Diretory for Alarms.csv and Tags.csv!";
if (fldDlg.ShowDialog() == DialogResult.OK)
{
System.IO.StreamWriter swr;
swr = new System.IO.StreamWriter(fldDlg.SelectedPath + "\\Alarms.csv");
swr.Write(errors);
swr.Close();
swr = new System.IO.StreamWriter(fldDlg.SelectedPath + "\\Tags.csv");
swr.Write(tags.Replace(";", "\t"));
swr.Close();
}
}
private void Button_Click_2(object sender, RoutedEventArgs e)
{
HMIGENOBJECTSLib.HMIGO HMIGOObject = null;
try
{
HMIGOObject = new HMIGENOBJECTSLib.HMIGO();
}
catch (Exception ex)
{
MessageBox.Show("The WinCC Object could not be created!\n\n Error:" + ex.Message);
}
foreach (var projectBlockInfo in ConvertBlocks)
{
S7DataBlock myDB = (S7DataBlock)projectBlockInfo.GetBlock();
List <S7DataRow> myLst = null;
if (chkExpandArrays.IsChecked.Value)
{
myLst =
S7DataRow.GetChildrowsAsList(myDB.GetArrayExpandedStructure(new S7DataBlockExpandOptions()));
}
// ) myDB.GetRowsAsArrayExpandedList(ne);
else
{
myLst = S7DataRow.GetChildrowsAsList(myDB.Structure); // myDB.GetRowsAsList();
}
int cnt = 0;
try
{
foreach (S7DataRow plcDataRow in myLst)
{
string tagName = txtTagsPrefix.Text +
plcDataRow.StructuredName.Replace(".", "_").Replace("[", "_").Replace("]", "").
Replace(" ", "").Replace(",", "_");
try
{
switch (plcDataRow.DataType)
{
case S7DataRowType.BOOL:
HMIGOObject.CreateTag(tagName, HMIGENOBJECTSLib.HMIGO_TAG_TYPE.TAG_BINARY_TAG,
txtConnectionName.Text,
"DB" + myDB.BlockNumber + ",D" +
plcDataRow.BlockAddress.ToString(),
"TAGS_DB" + myDB.BlockNumber);
break;
case S7DataRowType.INT:
HMIGOObject.CreateTag(tagName,
HMIGENOBJECTSLib.HMIGO_TAG_TYPE.TAG_SIGNED_16BIT_VALUE,
txtConnectionName.Text,
"DB" + myDB.BlockNumber + ",DW" +
plcDataRow.BlockAddress.ByteAddress.ToString(),
"TAGS_DB" + myDB.BlockNumber);
break;
case S7DataRowType.DINT:
HMIGOObject.CreateTag(tagName,
HMIGENOBJECTSLib.HMIGO_TAG_TYPE.TAG_SIGNED_32BIT_VALUE,
txtConnectionName.Text,
"DB" + myDB.BlockNumber + ",DD" +
plcDataRow.BlockAddress.ByteAddress.ToString(),
"TAGS_DB" + myDB.BlockNumber);
break;
case S7DataRowType.WORD:
HMIGOObject.CreateTag(tagName,
HMIGENOBJECTSLib.HMIGO_TAG_TYPE.TAG_UNSIGNED_16BIT_VALUE,
txtConnectionName.Text,
"DB" + myDB.BlockNumber + ",DW" +
plcDataRow.BlockAddress.ByteAddress.ToString(),
"TAGS_DB" + myDB.BlockNumber);
break;
case S7DataRowType.DWORD:
HMIGOObject.CreateTag(tagName,
HMIGENOBJECTSLib.HMIGO_TAG_TYPE.TAG_UNSIGNED_32BIT_VALUE,
txtConnectionName.Text,
"DB" + myDB.BlockNumber + ",DD" +
plcDataRow.BlockAddress.ByteAddress.ToString(),
"TAGS_DB" + myDB.BlockNumber);
break;
case S7DataRowType.BYTE:
HMIGOObject.CreateTag(tagName,
HMIGENOBJECTSLib.HMIGO_TAG_TYPE.TAG_UNSIGNED_8BIT_VALUE,
txtConnectionName.Text,
"DB" + myDB.BlockNumber + ",DBB" +
plcDataRow.BlockAddress.ByteAddress.ToString(),
"TAGS_DB" + myDB.BlockNumber);
break;
case S7DataRowType.REAL:
HMIGOObject.CreateTag(tagName,
HMIGENOBJECTSLib.HMIGO_TAG_TYPE.
TAG_FLOATINGPOINT_NUMBER_32BIT_IEEE_754,
txtConnectionName.Text,
"DB" + myDB.BlockNumber + ",DD" +
plcDataRow.BlockAddress.ByteAddress.ToString(),
"TAGS_DB" + myDB.BlockNumber);
break;
}
}
catch (System.Runtime.InteropServices.COMException ex)
{
if (ex.ErrorCode != -2147196408)
{
throw ex;
}
//Tag existiert schoin
}
}
}
catch (System.Runtime.InteropServices.COMException ex)
{
if (ex.ErrorCode == -2147195889)
{
MessageBox.Show("Error: The Connection Name you specified does not exist!");
}
else
{
MessageBox.Show("Error: " + ex.Message);
}
return;
}
catch (Exception ex)
{
MessageBox.Show("Error: " + ex.Message);
return;
}
}
}
private void Button_Click_1(object sender, RoutedEventArgs e)
{
HMIGENOBJECTSLib.HMIGO HMIGOObject = null;
try
{
HMIGOObject = new HMIGENOBJECTSLib.HMIGO();
}
catch (Exception ex)
{
MessageBox.Show("The WinCC Object could not be created!\n\n Error:" + ex.Message);
}
try
{
foreach (var projectBlockInfo in ConvertBlocks)
{
S7DataBlock myDB = (S7DataBlock)projectBlockInfo.GetBlock();
int cnt = 0;
if (myDB.Structure != null && myDB.Structure.Children != null)
{
cnt = myDB.Structure.Children[myDB.Structure.Children.Count - 1].NextBlockAddress.ByteAddress;
}
string varname = "STOERUNGEN_DB" + myDB.BlockNumber;
for (int n = 0; n < cnt / 2; n++)
{
try
{
HMIGOObject.CreateTag(varname + "_" + (n + 1).ToString(),
HMIGENOBJECTSLib.HMIGO_TAG_TYPE.TAG_UNSIGNED_16BIT_VALUE,
txtConnectionName.Text,
"DB" + myDB.BlockNumber + ",DD" + (n * 2).ToString(), "Stoerungen");
}
catch (COMException ex)
{
if (ex.ErrorCode != -2147196408)
{
throw ex;
}
}
}
string errors = "";
int errNr = Convert.ToInt32(txtStartErrorNumber.Text);
foreach (S7DataRow plcDataRow in S7DataRow.GetChildrowsAsList(myDB.Structure))
// myDB.GetRowsAsList())
{
if (plcDataRow.DataType == S7DataRowType.BOOL)
{
ByteBitAddress akAddr = plcDataRow.BlockAddress;
int varnr = (akAddr.ByteAddress / 2) + 1;
int bitnr = akAddr.BitAddress;
if (akAddr.ByteAddress % 2 == 0)
{
bitnr += 8;
}
string stoeTxt = "";
string stoeOrt = "";
string stoeTxtEn = "";
stoeTxt = plcDataRow.Comment;
if (stoeTxt.Contains(";"))
{
stoeTxt = stoeTxt.Split(';')[1];
stoeOrt = stoeTxt.Split(';')[0];
}
if (chkFixedErrorNumber.IsChecked.Value)
{
errNr = Convert.ToInt32(txtStartErrorNumber.Text) + akAddr.ByteAddress * 8 +
akAddr.BitAddress;
}
try
{
HMIGOObject.CreateSingleAlarm(errNr,
HMIGENOBJECTSLib.HMIGO_SINGLE_ALARM_CLASS_ID.
SINGLE_ALARM_ERROR, 1, stoeTxt,
varname + "_" + varnr.ToString(), bitnr);
HMIGOObject.SingleAlarmInfoText = stoeTxt;
HMIGOObject.SingleAlarmText2ID = stoeOrt;
HMIGOObject.CommitSingleAlarm();
}
catch (System.Runtime.InteropServices.COMException ex)
{
if (ex.ErrorCode != -2147467259)
{
throw ex;
}
}
//errors += "\"D\"\t\"" + errNr.ToString() + "\"\t\"Alarms\"\t\"" + varname + "\"\t\"" + bitnr.ToString() + "\"\t\t\t\t\t\t\"0\"\t\"de-DE=" + stoeTxt + "\"\t\"en-US=" + stoeTxtEn + "\"\t\"de-DE=\"" + "\r\n";
if (!chkFixedErrorNumber.IsChecked.Value)
{
errNr++;
}
}
}
}
}
catch (System.Runtime.InteropServices.COMException ex)
{
if (ex.ErrorCode == -2147195889)
{
MessageBox.Show("Error: The Connection Name you specified does not exist!");
}
else
{
MessageBox.Show("Error: " + ex.Message);
}
}
catch (Exception ex)
{
MessageBox.Show("Error: " + ex.Message);
}
}
private void fetchPLCData_Tick(object sender, EventArgs e)
{
if (lblConnected.BackColor == Color.LightGreen)
{
lblConnected.BackColor = Color.DarkGray;
}
else
{
lblConnected.BackColor = Color.LightGreen;
}
try
{
if (myConn.Connected)
{
/* Get the ScrollViewer des XAML Trees (um scrollposition zu lesen!)... */
if (myScrollViewer == null)
{
DependencyObject tst = VisualTreeHelper.GetChild(dataBlockViewControl.MyTree, 0);
while (tst != null && tst.GetType() != typeof(ScrollViewer))
{
tst = VisualTreeHelper.GetChild(tst, 0);
}
if (tst != null)
{
myScrollViewer = (ScrollViewer)tst;
}
}
//nur die angezeigten Values von der SPS lesen...
int start = (int)myScrollViewer.VerticalOffset / 20;
if (valueList == null || start != oldPos)
{
List <S7DataRow> tmpLst = S7DataRow.GetChildrowsAsList(expRow);
List <S7DataRow> askLst = new List <S7DataRow>();
for (int n = 0; n < tmpLst.Count; n++)
{
if (n >= start && n < start + 24)
{
askLst.Add(tmpLst[n]);
}
}
valueList = S7DataRow.GetLibnoDaveValues(askLst);
oldPos = start;
}
myConn.ReadValues(valueList);
}
else
{
oldPos = 0;
myScrollViewer = null;
fetchPLCData.Enabled = false;
valueList = null;
lblConnected.BackColor = Color.DarkGray;
}
}
catch (Exception ex)
{
lblStatus.Text = ex.Message;
}
}
/// <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 void ConvertLocaldataToSymbols(S7FunctionBlock myFct, S7ConvertingOptions myOpt)
{
if (myOpt.ReplaceLokalDataAddressesWithSymbolNames)
{
List <S7DataRow> rows = null;
Dictionary <String, String> parLst = new Dictionary <string, string>();
if (myFct.Parameter != null && myFct.Parameter.Children != null)
{
foreach (var plcDataRow in myFct.Parameter.Children)
{
if (plcDataRow.Name == "TEMP")
{
S7DataRow tmpRw = ((S7DataRow)plcDataRow)._GetExpandedChlidren(new S7DataBlockExpandOptions()
{
ExpandCharArrays = true, ExpandSubChildInINOUT = false
})[0];
rows = S7DataRow.GetChildrowsAsList(tmpRw);
break;
}
}
}
if (rows != null)
{
foreach (var plcDataRow in rows)
{
if (plcDataRow.DataType != S7DataRowType.STRUCT && plcDataRow.DataType != S7DataRowType.UDT && plcDataRow.DataType != S7DataRowType.FB)
{
parLst.Add("P#L" + plcDataRow.BlockAddress.ToString(), "P##" + plcDataRow.StructuredName);
}
string tmp = plcDataRow.GetSymbolicAddress();
if (tmp != null)
{
parLst.Add("L" + tmp.Replace("X", ""), "#" + plcDataRow.StructuredName);
}
}
}
foreach (S7FunctionBlockRow plcFunctionBlockRow in myFct.AWLCode)
{
if (!plcFunctionBlockRow.Parameter.Contains("'") && !plcFunctionBlockRow.Parameter.Contains("[AR") && plcFunctionBlockRow.Parameter.Contains("["))
{
int pos1 = plcFunctionBlockRow.Parameter.IndexOf("[") + 1;
int pos2 = plcFunctionBlockRow.Parameter.IndexOf("]");
string par = plcFunctionBlockRow.Parameter.Substring(pos1, pos2 - pos1);
if (parLst.ContainsKey(par))
{
byte[] tmp = plcFunctionBlockRow.MC7;
plcFunctionBlockRow.Parameter = plcFunctionBlockRow.Parameter.Substring(0, pos1) + parLst[par] + "]";
plcFunctionBlockRow.MC7 = tmp;
}
}
else
{
string par = plcFunctionBlockRow.Parameter.Replace(" ", "");
if (parLst.ContainsKey(par))
{
byte[] tmp = plcFunctionBlockRow.MC7;
plcFunctionBlockRow.Parameter = "";
plcFunctionBlockRow.Parameter = parLst[par];
plcFunctionBlockRow.MC7 = tmp;
}
}
}
}
}
//In this Class a UC is converted to a Call and also backwards...
public static void ConvertUCToCall(S7FunctionBlock myFct, S7ProgrammFolder myFld, BlocksOfflineFolder myblkFld, S7ConvertingOptions myOpt, byte[] addInfoFromBlock)
{
if (myOpt.GenerateCallsfromUCs)
{
int inBld = 0; //1=nach BLD 1
S7FunctionBlockRow newRow = null;
Dictionary <string, string> Parameters = new Dictionary <string, string>();
List <FunctionBlockRow> retVal = new List <FunctionBlockRow>();
List <FunctionBlockRow> tempList = new List <FunctionBlockRow>();
string akPar = "";
string db = "";
string label = "";
bool afterCall = false;
S7FunctionBlockRow callRow = null;
for (int n = 0; n < myFct.AWLCode.Count; n++)
{
S7FunctionBlockRow row = (S7FunctionBlockRow)myFct.AWLCode[n];
if (row.Command == Mnemonic.opBLD[(int)myOpt.Mnemonic] && (row.Parameter == "1" || row.Parameter == "7") && inBld == 0)
{
retVal.AddRange(tempList);
tempList.Clear();
Parameters.Clear();
db = "";
label = row.Label;
inBld = Convert.ToInt32(row.Parameter);
newRow = null;
afterCall = false;
callRow = null;
tempList.Add(row);
}
else if (inBld > 0)
{
tempList.Add(row);
if (row.Command == "=" && n > 0 && myFct.AWLCode[n - 1].Command == Mnemonic.opBLD[(int)myOpt.Mnemonic])
{
//Do nothing, but this line needs to be there!
}
else if (row.Command == Mnemonic.opU[(int)myOpt.Mnemonic] || row.Command == Mnemonic.opUN[(int)myOpt.Mnemonic] ||
row.Command == Mnemonic.opO[(int)myOpt.Mnemonic] || row.Command == Mnemonic.opON[(int)myOpt.Mnemonic] ||
row.Command == Mnemonic.opO[(int)myOpt.Mnemonic] || row.Command == Mnemonic.opON[(int)myOpt.Mnemonic] ||
row.Command == Mnemonic.opX[(int)myOpt.Mnemonic] || row.Command == Mnemonic.opXN[(int)myOpt.Mnemonic] ||
row.Command == Mnemonic.opL[(int)myOpt.Mnemonic])
{
akPar = row.Parameter;
}
else if (row.Command == "AUF")
{
db = row.Parameter + ".";
}
else if (row.Command == "CLR")
{
akPar = "FALSE";
}
else if (row.Command == "SET")
{
akPar = "TRUE";
}
else if ((row.Command == "=") && akPar != "")
{
if (afterCall == false)
{
string key = row.Parameter.Replace("L", "").Replace("W", "").Replace("B", "").Replace("D", "");
if (!Parameters.ContainsKey(key))
{
Parameters.Add("P#V " + key, db + akPar);
}
}
else
{
string key = akPar.Replace("L", "").Replace("W", "").Replace("B", "").Replace("D", "");
if (!Parameters.ContainsKey(key))
{
Parameters.Add("P#V " + key, db + row.Parameter);
}
}
akPar = "";
db = "";
}
else if (row.Command == Mnemonic.opT[(int)myOpt.Mnemonic] && akPar != "")
{
if (afterCall == false)
{
string key = row.Parameter.Replace("L", "").Replace("W", "").Replace("B", "").Replace("D", "");
if (!Parameters.ContainsKey(key))
{
Parameters.Add("P#V " + key + ".0", db + akPar);
}
}
else
{
string key = akPar.Replace("L", "").Replace("W", "").Replace("B", "").Replace("D", "");
if (!Parameters.ContainsKey(key))
{
Parameters.Add("P#V " + key, db + row.Parameter);
}
}
akPar = "";
db = "";
}
else if (row.Command == Mnemonic.opUC[(int)myOpt.Mnemonic])
{
//Commands after a Call --> Out-Para
callRow = row;
afterCall = true;
}
else if (row.Command == Mnemonic.opBLD[(int)myOpt.Mnemonic] && (row.Parameter == "2" || row.Parameter == "8"))
{
//Block Interface auslesen (von FC oder vom Programm)
//myFld.BlocksOfflineFolder.GetBlock()
S7DataRow para = myblkFld.GetInterface(callRow.Parameter);
newRow = new S7FunctionBlockRow();
newRow.Command = Mnemonic.opCALL[(int)myOpt.Mnemonic];
newRow.Parameter = callRow.Parameter;
//newRow.ExtParameter = new List<string>();
newRow.CallParameter = new List <S7FunctionBlockParameter>();
for (int i = 0; i < callRow.ExtParameter.Count; i++)
{
string s = callRow.ExtParameter[i];
string parnm = "";
S7DataRow akRow = Parameter.GetFunctionParameterFromNumber(para, i);
if (akRow != null)
{
parnm = akRow.Name + "";
}
else
{
parnm = "$$undef";
}
S7FunctionBlockParameter newPar = new S7FunctionBlockParameter();
newPar.Name = parnm;
if (akRow != null)
{
newPar.ParameterDataType = akRow.DataType;
if (akRow.Parent.Name == "OUT")
{
newPar.ParameterType = S7FunctionBlockParameterDirection.OUT;
}
else if (akRow.Parent.Name == "IN_OUT")
{
newPar.ParameterType = S7FunctionBlockParameterDirection.IN_OUT;
}
else
{
newPar.ParameterType = S7FunctionBlockParameterDirection.IN;
}
//newPar.ParameterType
}
if (akRow != null)
{
int posL = s.IndexOf(' ');
int ak_address = 0;
if (posL >= 0)
{
ak_address = Convert.ToInt32(s.Substring(posL + 1).Split('.')[0]);
}
else
{
ak_address = Convert.ToInt32(s.Substring(2).Split('.')[0]) * 8 +
Convert.ToInt32(s.Substring(2).Split('.')[1]);
}
int lokaldata_address = -1;
if (s.Substring(0, 3) == "P#V")
{
lokaldata_address = Convert.ToInt32(s.Substring(4).Split('.')[0]);
}
if (akRow.DataType == S7DataRowType.STRING || akRow.DataType == S7DataRowType.DATE_AND_TIME ||
akRow.DataType == S7DataRowType.STRUCT || akRow.DataType == S7DataRowType.UDT ||
akRow.DataType == S7DataRowType.POINTER || akRow.IsArray)
{
string p1 = Parameters["P#V " + (lokaldata_address + 0).ToString() + ".0"];
string p2 = Parameters["P#V " + (lokaldata_address + 2).ToString() + ".0"];
string tmp = "";
if (p1 != "" && p1 != "0")
{
tmp += "P#DB" + p1 + "." + p2.Substring(2);
}
else
{
tmp += p2;
}
newPar.Value = tmp;
newRow.CallParameter.Add(newPar);
//newRow.ExtParameter.Add(parnm + tmp);
}
else if (akRow.DataType == S7DataRowType.ANY)
{
string tmp = s;
if (Parameters.ContainsKey("P#V " + (lokaldata_address + 0).ToString() + ".0") &&
Parameters.ContainsKey("P#V " + (lokaldata_address + 2).ToString() + ".0") &&
Parameters.ContainsKey("P#V " + (lokaldata_address + 4).ToString() + ".0") &&
Parameters.ContainsKey("P#V " + (lokaldata_address + 6).ToString() + ".0"))
{
string p1 = Parameters["P#V " + (lokaldata_address + 0).ToString() + ".0"];
string p2 = Parameters["P#V " + (lokaldata_address + 2).ToString() + ".0"];
string p3 = Parameters["P#V " + (lokaldata_address + 4).ToString() + ".0"];
string p4 = Parameters["P#V " + (lokaldata_address + 6).ToString() + ".0"];
tmp = "P#";
if (p3 != "0")
{
tmp += "DB" + p3 + ".";
}
tmp += p4.Substring(2);
tmp += " BYTE "; //Todo Parse Byte 1 if the Type is Byte!
tmp += p2;
}
newPar.Value = tmp;
newRow.CallParameter.Add(newPar);
//newRow.ExtParameter.Add(parnm + tmp);
}
else
{
if (Parameters.ContainsKey(s))
{
string par = Parameters[s];
if (akRow.DataType == S7DataRowType.S5TIME && par[0] >= '0' && par[0] <= '9')
{
newPar.Value = Helper.GetS5Time(
BitConverter.GetBytes(Convert.ToInt32(par))[1],
BitConverter.GetBytes(Convert.ToInt32(par))[0]);
newRow.CallParameter.Add(newPar);
//newRow.ExtParameter.Add(parnm +
// Helper.GetS5Time(
// BitConverter.GetBytes(Convert.ToInt32(par))[1],
// BitConverter.GetBytes(Convert.ToInt32(par))[0]));
}
else if (akRow.DataType == S7DataRowType.TIME && par[0] >= '0' && par[0] <= '9')
{
newPar.Value = Helper.GetDTime(BitConverter.GetBytes(Convert.ToInt32(par)), 0);
newRow.CallParameter.Add(newPar);
//newRow.ExtParameter.Add(parnm +
// Helper.GetDTime(BitConverter.GetBytes(Convert.ToInt32(par)),0));
}
else if (akRow.DataType == S7DataRowType.CHAR && par[0] == 'B')
{
newPar.Value =
(char)
Int32.Parse(par.Substring(5),
System.Globalization.NumberStyles.AllowHexSpecifier) +
"'";
newRow.CallParameter.Add(newPar);
//newRow.ExtParameter.Add(parnm + "'" +
// (char)Int32.Parse(par.Substring(5), System.Globalization.NumberStyles.AllowHexSpecifier) + "'");
}
else
{
newPar.Value = Parameters[s];
newRow.CallParameter.Add(newPar);
//newRow.ExtParameter.Add(parnm + Parameters[s]);
}
}
else
{
if (akRow.DataType == S7DataRowType.BOOL)
{
newPar.Value = s.Substring(2).Replace('V', 'L');
newRow.CallParameter.Add(newPar);
//newRow.ExtParameter.Add(parnm + s.Substring(2).Replace('V', 'L'));
}
else if (akRow.DataType == S7DataRowType.BLOCK_DB)
{
newPar.Value = "DB" + ak_address.ToString();
newRow.CallParameter.Add(newPar);
//newRow.ExtParameter.Add(parnm + "DB" + ak_address.ToString());
}
else if (akRow.DataType == S7DataRowType.BLOCK_FB)
{
newPar.Value = "FB" + ak_address.ToString();
newRow.CallParameter.Add(newPar);
//newRow.ExtParameter.Add(parnm + "FB" + ak_address.ToString());
}
else if (akRow.DataType == S7DataRowType.BLOCK_FC)
{
newPar.Value = "FC" + ak_address.ToString();
newRow.CallParameter.Add(newPar);
}
else if (akRow.DataType == S7DataRowType.BLOCK_SDB)
{
newPar.Value = "SDB" + ak_address.ToString();
newRow.CallParameter.Add(newPar);
}
else if (akRow.DataType == S7DataRowType.TIMER)
{
newPar.Value = Mnemonic.adT[(int)myOpt.Mnemonic] + ak_address.ToString();
newRow.CallParameter.Add(newPar);
}
else if (akRow.DataType == S7DataRowType.COUNTER)
{
newPar.Value = Mnemonic.adZ[(int)myOpt.Mnemonic] + ak_address.ToString();
newRow.CallParameter.Add(newPar);
}
else
{
string ber = "";
if (s.Substring(0, 5) == "P#DBX")
{
ber = "DB";
}
else if (s.Substring(0, 5) == "P#DIX")
{
ber = "DI";
}
else
{
ber = s.Substring(2, 1);
}
if (akRow.ByteLength == 1)
{
ber += "B";
}
else if (akRow.ByteLength == 2)
{
ber += "W";
}
else if (akRow.ByteLength == 4)
{
ber += "D";
}
newPar.Value = ber.Replace('V', 'L') + ak_address.ToString();
newRow.CallParameter.Add(newPar);
//newRow.ExtParameter.Add(parnm +
// ber.Replace('V', 'L') +
// ak_address.ToString());
}
}
}
}
}
newRow.CombinedCommands = tempList;
newRow.Label = label;
int sz = 0;
foreach (var functionBlockRow in newRow.CombinedCommands)
{
sz += ((S7FunctionBlockRow)functionBlockRow).ByteSize;
}
byte[] mcges = new byte[sz];
sz = 0;
foreach (var functionBlockRow in newRow.CombinedCommands)
{
Array.Copy(((S7FunctionBlockRow)functionBlockRow).MC7, 0, mcges, sz, ((S7FunctionBlockRow)functionBlockRow).ByteSize);
sz += ((S7FunctionBlockRow)functionBlockRow).ByteSize;
}
newRow.MC7 = mcges;
retVal.Add(newRow);
Parameters.Clear();
tempList = new List <FunctionBlockRow>();
inBld = 0;
}
else
{
retVal.AddRange(tempList);
tempList.Clear();
inBld = 0;
}
}
else
{
retVal.Add(row);
}
}
myFct.AWLCode = retVal;
}
}
