public static int GetSize(S7FunctionBlockRow myCmd) { int MN = 0; //Memnoic still needs to be implemented! //This function is there, because for a Jump it sould not call GetMC7, because then we can get circular calls! //A Jump in GetMC7 will also call this, to callculate the distance to the jump mark! if (Helper.IsJump(myCmd, MN)) return 4; else try { if (myCmd.MC7 == null) myCmd.MC7 = GetMC7(myCmd); return myCmd.MC7.Length; } catch (Exception) { return 0; } }
public S7FunctionBlockParameter(S7FunctionBlockRow Parent) { this.Parent = Parent; }
public static bool IsNetwork(S7FunctionBlockRow row) { return row.Command == "NETWORK"; }
//Todo: Check if Jump label is used in the Block! public static bool IsJumpTarget(S7FunctionBlockRow myCmd, S7FunctionBlock myBlk) { if (!string.IsNullOrEmpty(myCmd.Label)) return true; return false; }
public static bool IsJump(S7FunctionBlockRow myCmd, int akMemnoic) { if (myCmd == null) return false; int MN = akMemnoic; if (myCmd.Command == Mnemonic.opSPA[MN] || myCmd.Command == Mnemonic.opSPB[MN] || myCmd.Command == Mnemonic.opSPBB[MN] || myCmd.Command == Mnemonic.opSPBI[MN] || myCmd.Command == Mnemonic.opSPBIN[MN] || myCmd.Command == Mnemonic.opSPBN[MN] || myCmd.Command == Mnemonic.opSPBNB[MN] || myCmd.Command == Mnemonic.opSPL[MN] || myCmd.Command == Mnemonic.opSPM[MN] || myCmd.Command == Mnemonic.opSPMZ[MN] || myCmd.Command == Mnemonic.opSPN[MN] || myCmd.Command == Mnemonic.opSPO[MN] || myCmd.Command == Mnemonic.opSPP[MN] || myCmd.Command == Mnemonic.opSPPZ[MN] || myCmd.Command == Mnemonic.opSPS[MN] || myCmd.Command == Mnemonic.opSPU[MN] || myCmd.Command == Mnemonic.opSPZ[MN] || myCmd.Command == Mnemonic.opLOOP[MN]) return true; return false; }
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 (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; 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.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; blkInfo._Block = retVal; return retVal; } } return null; }
public S7FunctionBlockParameter(S7FunctionBlockRow Parent) { this.Parent = Parent; }
//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", ""); 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"]; 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 { 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"; newPar.Value = ber.Replace('V', 'L') + ak_address.ToString(); } } 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; } }
//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; } }
static public byte[] GetMC7(S7FunctionBlockRow myCmd) { int MN=0; //Memnoic still needs to be implemented! if (myCmd.Command == "NETWORK") return null; else if (myCmd.Command == Mnemonic.opTAK[MN]) return new byte[] { 0x70, 0x02 }; else if (myCmd.Command == Mnemonic.opPUSH[MN]) return new byte[] { 0x68, 0x2E }; else if (myCmd.Command == Mnemonic.opPOP[MN]) return new byte[] { 0x68, 0x3E }; else if (myCmd.Command == Mnemonic.opENT[MN]) return new byte[] { 0x60, 0x08 }; else if (myCmd.Command == Mnemonic.opLEAVE[MN]) return new byte[] { 0x68, 0x4E }; else if (myCmd.Command == Mnemonic.opPAR1[MN]) return new byte[] { 0xFE, 0x06 }; else if (myCmd.Command == Mnemonic.opPAR2[MN]) return new byte[] { 0xFE, 0x0E }; else if (myCmd.Command == Mnemonic.opNOP[MN]) if (myCmd.Parameter == "0") return new byte[] { 0x00, 0x00 }; else return new byte[] { 0xFF, 0xFF }; else if (myCmd.Command == Mnemonic.opINC[MN]) return new byte[] { 0x11, Convert.ToByte(myCmd.Parameter) }; else if (myCmd.Command == Mnemonic.opBLD[MN]) return new byte[] { 0x10, Convert.ToByte(myCmd.Parameter) }; else if (myCmd.Command == Mnemonic.opDEC[MN]) return new byte[] { 0x19, Convert.ToByte(myCmd.Parameter) }; else if (myCmd.Command == "+D") return new byte[] { 0x60, 0x0D }; else if (myCmd.Command == "-D") return new byte[] { 0x60, 0x09 }; else if (myCmd.Command == "*D") return new byte[] { 0x60, 0x0A }; else if (myCmd.Command == "/D") return new byte[] { 0x60, 0x0E }; else if (myCmd.Command == Mnemonic.opMOD[MN]) return new byte[] { 0x60, 0x01 }; else if (myCmd.Command == "+I") return new byte[] { 0x79, 0x05 }; else if (myCmd.Command == "-I") return new byte[] { 0x59, 0x05 }; else if (myCmd.Command == "*I") return new byte[] { 0x60, 0x04 }; else if (myCmd.Command == "/I") return new byte[] { 0x60, 0x00 }; else if (myCmd.Command == Mnemonic.opSQR[MN]) return new byte[] { 0x60, 0x1C }; else if (myCmd.Command == Mnemonic.opSQRT[MN]) return new byte[] { 0x60, 0x14 }; else if (myCmd.Command == Mnemonic.opEXP[MN]) return new byte[] { 0x60, 0x1B }; else if (myCmd.Command == Mnemonic.opLN[MN]) return new byte[] { 0x60, 0x13 }; else if (myCmd.Command == Mnemonic.opSIN[MN]) return new byte[] { 0x60, 0x10 }; else if (myCmd.Command == Mnemonic.opCOS[MN]) return new byte[] { 0x60, 0x11 }; else if (myCmd.Command == Mnemonic.opTAN[MN]) return new byte[] { 0x60, 0x12 }; else if (myCmd.Command == Mnemonic.opASIN[MN]) return new byte[] { 0x60, 0x18 }; else if (myCmd.Command == Mnemonic.opACOS[MN]) return new byte[] { 0x60, 0x19 }; else if (myCmd.Command == Mnemonic.opATAN[MN]) return new byte[] { 0x60, 0x1A }; else if (myCmd.Command == "+R") return new byte[] { 0x60, 0x0F }; else if (myCmd.Command == "-R") return new byte[] { 0x60, 0x0B }; else if (myCmd.Command == "*R") return new byte[] { 0x60, 0x07 }; else if (myCmd.Command == "/R") return new byte[] { 0x60, 0x03 }; else if (myCmd.Command == Mnemonic.opBTI[MN]) return new byte[] { 0x68, 0x0C }; else if (myCmd.Command == Mnemonic.opITB[MN]) return new byte[] { 0x68, 0x08 }; else if (myCmd.Command == Mnemonic.opBTD[MN]) return new byte[] { 0x68, 0x08 }; else if (myCmd.Command == Mnemonic.opITD[MN]) return new byte[] { 0x68, 0x1E }; else if (myCmd.Command == Mnemonic.opDTB[MN]) return new byte[] { 0x68, 0x0A }; else if (myCmd.Command == Mnemonic.opDTR[MN]) return new byte[] { 0x68, 0x06 }; else if (myCmd.Command == Mnemonic.opINVI[MN]) return new byte[] { 0x01, 0x00 }; else if (myCmd.Command == Mnemonic.opINVD[MN]) return new byte[] { 0x68, 0x0D }; else if (myCmd.Command == Mnemonic.opNEGI[MN]) return new byte[] { 0x09, 0x00 }; else if (myCmd.Command == Mnemonic.opNEGD[MN]) return new byte[] { 0x68, 0x07 }; else if (myCmd.Command == Mnemonic.opNEGR[MN]) return new byte[] { 0x60, 0x06 }; else if (myCmd.Command == Mnemonic.opTAW[MN]) return new byte[] { 0x68, 0x1A }; else if (myCmd.Command == Mnemonic.opTAD[MN]) return new byte[] { 0x68, 0x1B }; else if (myCmd.Command == Mnemonic.opRND[MN]) return new byte[] { 0x68, 0x5C }; else if (myCmd.Command == Mnemonic.opTRUNC[MN]) return new byte[] { 0x68, 0x5F }; else if (myCmd.Command == Mnemonic.opRNDP[MN]) return new byte[] { 0x68, 0x5E }; else if (myCmd.Command == Mnemonic.opRNDM[MN]) return new byte[] { 0x68, 0x5D }; else if (myCmd.Command == Mnemonic.opABS[MN]) return new byte[] { 0x60, 0x02 }; else if (myCmd.Command == Mnemonic.opBE[MN]) return new byte[] { 0x65, 0x00 }; else if (myCmd.Command == Mnemonic.opBEA[MN]) return new byte[] { 0x65, 0x01 }; else if (myCmd.Command == Mnemonic.opBEB[MN]) return new byte[] { 0x05, 0x00 }; else if (myCmd.Command == Mnemonic.opCLR[MN]) return new byte[] { 0x68, 0x1C }; else if (myCmd.Command == Mnemonic.opNOT[MN]) return new byte[] { 0x68, 0x2D }; else if (myCmd.Command == Mnemonic.opSET[MN]) return new byte[] { 0x68, 0x1D }; else if (myCmd.Command == Mnemonic.opSAVE[MN]) return new byte[] { 0x68, 0x2C }; else if (myCmd.Command == Mnemonic.opUO[MN]) return new byte[] { 0xBA, 0x00 }; else if (myCmd.Command == Mnemonic.opOO[MN]) return new byte[] { 0xBB, 0x00 }; else if (myCmd.Command == Mnemonic.opUNO[MN]) return new byte[] { 0xFF, 0xF1 }; else if (myCmd.Command == Mnemonic.opONO[MN]) return new byte[] { 0xFF, 0xF3 }; else if (myCmd.Command == Mnemonic.opMCRA[MN]) return new byte[] { 0x68, 0x3a }; else if (myCmd.Command == Mnemonic.opMCRD[MN]) return new byte[] { 0x68, 0x3b }; else if (myCmd.Command == Mnemonic.opMCRO[MN]) return new byte[] { 0x68, 0x3c }; else if (myCmd.Command == Mnemonic.opMCRC[MN]) return new byte[] { 0x68, 0x3d }; else if (myCmd.Command == Mnemonic.opXO[MN]) return new byte[] { 0xFF, 0xF4 }; else if (myCmd.Command == Mnemonic.opXNO[MN]) return new byte[] { 0xFF, 0xF5 }; else if (myCmd.Command == Mnemonic.opTAR[MN]) return new byte[] { 0xFE, 0x08 }; else if (myCmd.Command == Mnemonic.opTDB[MN]) return new byte[] { 0xFB, 0x7C }; else if (myCmd.Command == Mnemonic.opUC[MN]) { switch (myCmd.GetParameterType()) { case PLCFunctionBlockAdressType.Direct: if (myCmd.Parameter.ToUpper().Contains("FB")) if (Helper.GetParameterValueInt(myCmd.Parameter) < 256) return new byte[] { 0x75, Helper.GetParameterValueBytes(myCmd.Parameter)[0] }; else return new byte[] { 0xFB, 0x72, Helper.GetParameterValueBytes(myCmd.Parameter)[1], Helper.GetParameterValueBytes(myCmd.Parameter)[0] }; else if (myCmd.ExtParameter == null || myCmd.ExtParameter.Count == 0) if (Helper.GetParameterValueInt(myCmd.Parameter) < 256) return new byte[] { 0x3D, Helper.GetParameterValueBytes(myCmd.Parameter)[0], 0x70, 0x0B, 0x00, 0x02 }; else return new byte[] { 0xFB, 0x70, Helper.GetParameterValueBytes(myCmd.Parameter)[1], Helper.GetParameterValueBytes(myCmd.Parameter)[0], 0x70, 0x0B, 0x00, 0x02 }; else { List<byte> myAddVal = new List<byte>(); if (Helper.GetParameterValueInt(myCmd.Parameter) < 256) myAddVal.AddRange(new byte[] { 0xFB, 0x70, 0x00, Helper.GetParameterValueBytes(myCmd.Parameter)[0], 0x70, 0x0B, 0x00 }); else myAddVal.AddRange(new byte[] { 0xFB, 0x70, Helper.GetParameterValueBytes(myCmd.Parameter)[1], Helper.GetParameterValueBytes(myCmd.Parameter)[0], 0x70, 0x0B, 0x00 }); myAddVal.Add(Convert.ToByte(myCmd.ExtParameter.Count * 2 + 2)); foreach (string par in myCmd.ExtParameter) myAddVal.AddRange(Helper.GetCallParameterByte(par)); return myAddVal.ToArray(); } case PLCFunctionBlockAdressType.Indirect: if (myCmd.Parameter.ToUpper().Contains("FB")) return new byte[] { 0xFB, Convert.ToByte(Helper.GetIndirectBytesWord(myCmd.Parameter)[2] | 0x02), Helper.GetIndirectBytesWord(myCmd.Parameter)[1], Helper.GetIndirectBytesWord(myCmd.Parameter)[0], 0x70, 0x0B, 0x00, 0x02 }; else return new byte[] { 0xFB, Convert.ToByte(Helper.GetIndirectBytesWord(myCmd.Parameter)[2] | 0x00), Helper.GetIndirectBytesWord(myCmd.Parameter)[1], Helper.GetIndirectBytesWord(myCmd.Parameter)[0], 0x70, 0x0B, 0x00, 0x02 }; } } /* else if (myCmd.Command == Memnoic.opAUF[MN]) switch (myCmd.GetParameterType()) { case PLCFunctionBlockAdressType. if (myCmd.Parameter.ToUpper().Contains("FB")) if (Helper.GetParameterValueInt(myCmd.Parameter) < 256) return new byte[] { 0xFB, 0x7C }; 0x20 //auf db 0xFB, 0x38 //db [mw] 48=dbw 58=diw 68=lw 0x39 //di [mw] 0xfb, 0x78 //auf db >256 0xfb, 0x79 //auf di >256 0xfb, 0xd8 //auf db #par * * public static string[] opU = new[] { "U", "U" }; public static string[] opFN = new[] { "FN", "FN" }; public static string[] opFP = new[] { "FP", "FP" }; public static string[] opO = new[] { "O", "O" }; public static string[] opR = new[] { "R", "R" }; public static string[] opS = new[] { "S", "S" }; public static string[] opUN = new[] { "UN", "UN" }; public static string[] opX = new[] { "X", "X" }; public static string[] opXN = new[] { "XN", "XN" }; public static string[] opZUW = new[] { "=", "=" }; */ /* * Commands still to do: public static string[] opAUF = new[] { "AUF", "OPN" }; public static string[] opCC = new[] { "CC", "CC" }; * * public static string[] opFR = new[] { "FR", "FR" }; * public static string[] opL = new[] { "L", "L" }; * public static string[] opLAR1 = new[] { "LAR1", "LAR1" }; public static string[] opLAR2 = new[] { "LAR2", "LAR2" }; public static string[] opLC = new[] { "LC", "LC" }; public static string[] opLN = new[] { "LN", "LN" }; * public static string[] opOD = new[] { "OD", "OD" }; public static string[] opON = new[] { "ON", "ON" }; public static string[] opOW = new[] { "OW", "OW" }; public static string[] opPLU = new[] { "+", "+" }; public static string[] opRLD = new[] { "RLD", "RLD" }; public static string[] opRLDA = new[] { "RLDA", "RLDA" }; public static string[] opRRD = new[] { "RRD", "RRD" }; public static string[] opRRDA = new[] { "RRDA", "RRDA" }; public static string[] opSA = new[] { "SA", "SF" }; public static string[] opSE = new[] { "SE", "SD" }; public static string[] opSI = new[] { "SI", "SP" }; public static string[] opSLD = new[] { "SLD", "SLD" }; public static string[] opSLW = new[] { "SLW", "SLW" }; * * public static string[] opLOOP = new[] { "LOOP", "LOOP" }; public static string[] opSPA = new[] { "SPA", "JU" }; public static string[] opSPB = new[] { "SPB", "JC" }; public static string[] opSPBB = new[] { "SPBB", "JCB" }; public static string[] opSPBI = new[] { "SPBI", "JBI" }; public static string[] opSPBIN = new[] { "SPBIN", "JBNI" }; public static string[] opSPBN = new[] { "SPBN", "JCN" }; public static string[] opSPBNB = new[] { "SPBNB", "JNB" }; public static string[] opSPL = new[] { "SPL", "SPL" }; public static string[] opSPM = new[] { "SPM", "SPM" }; public static string[] opSPMZ = new[] { "SPMZ", "SPMZ" }; public static string[] opSPN = new[] { "SPN", "SPN" }; public static string[] opSPO = new[] { "SPO", "SPO" }; public static string[] opSPP = new[] { "SPP", "SPP" }; public static string[] opSPPZ = new[] { "SPPZ", "SPPZ" }; public static string[] opSPS = new[] { "SPS", "SPS" }; public static string[] opSPU = new[] { "SPU", "SPU" }; public static string[] opSPZ = new[] { "SPZ", "SPZ" }; public static string[] opSRD = new[] { "SRD", "SRD" }; public static string[] opSRW = new[] { "SRW", "SRW" }; public static string[] opSS = new[] { "SS", "SS" }; public static string[] opSSD = new[] { "SSD", "SSD" }; public static string[] opSSI = new[] { "SSI", "SSI" }; public static string[] opSV = new[] { "SV", "SV" }; public static string[] opT = new[] { "T", "T" }; public static string[] opTAR1 = new[] { "TAR1", "TAR1" }; public static string[] opTAR2 = new[] { "TAR2", "TAR2" }; public static string[] opUD = new[] { "UD", "UD" }; public static string[] opUW = new[] { "UW", "UW" }; public static string[] opXOD = new[] { "XOD", "XOD" }; public static string[] opXOW = new[] { "XOW", "XOW" }; public static string[] opZR = new[] { "ZR", "ZR" }; public static string[] opZV = new[] { "ZV", "ZV" }; * End of commands list */ return null; }
public void ExecuteCommand(S7FunctionBlockRow row) { if (row.Command == Mnemonic.opABS[0]) { Akku1.Int32 = Math.Abs(Akku1.Int32); } else if (row.Command == Mnemonic.opACOS[0]) { Akku1.Single = (Single)Math.Acos(Akku1.Single); } else if (row.Command == Mnemonic.opL[0]) { Akku1.Single = (Single)Math.Acos(Akku1.Single); } else if (row.Command == Mnemonic.opTAK[0]) { var sp = Akku2; Akku2 = Akku1.UInt32; Akku1.UInt32 = sp; } }