Zuviel Werbung? - > Hier kostenlos beim SPS-Forum registrieren

Ergebnis 1 bis 2 von 2

Thema: CALLs aus AWL Code erzeugen...

  1. #1
    Registriert seit
    17.06.2004
    Ort
    Offenau
    Beiträge
    3.746
    Danke
    209
    Erhielt 421 Danke für 338 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Suche nach einer Strategie um aus dem AWL Code der Parameterzuweisungen CALL Anweisungen zu erstellen! Hat da jemand eine gute Idee, hab zwar in Grundzügen schon mal Angefangen, bin aber noch auf keinem grünen Zweig...


    Hab mal meinen momentanen Code angehängt, der aber noch lange nicht fertig ist...
    Code:
    using System;
    using System.Collections.Generic;
    using System.Text;
    using LibNoDaveConnectionLibrary.DataTypes.Blocks;
    using LibNoDaveConnectionLibrary.DataTypes.Step7Project;
    
    namespace LibNoDaveConnectionLibrary.MC7
    {
        static class CallConverter
        {
            //In this Class a UC is converted to a Call and also backwards...
            public static void ConvertUCToCall(PLCFunctionBlock myFct, S7ProgrammFolder myFld, MC7ConvertingOptions myOpt, byte[] addInfoFromBlock)
            {
                if (myOpt.GenerateCallsfromUCs)
                {
                    int inBld = 0; //1=nach BLD 1
                    PLCFunctionBlockRow newRow = null;
    
                    Dictionary<string, string> Parameters = new Dictionary<string, string>();
                    List<PLCFunctionBlockRow> retVal = new List<PLCFunctionBlockRow>();
                    List<PLCFunctionBlockRow> tempList = new List<PLCFunctionBlockRow>();
    
    
    
                    string akPar = "";
    
                    for (int n = 0; n < myFct.AWLCode.Count; n++)
                    {
                        PLCFunctionBlockRow row = myFct.AWLCode[n];
                        if (row.Command == Memnoic.opBLD[myOpt.Memnoic] && row.Parameter == "1")
                        {
                            retVal.AddRange(tempList);
                            tempList.Clear();
    
                            Parameters.Clear();
                            inBld = 1;
                            newRow = null;
                            tempList.Add(row);
                        }
                        else if (inBld == 1)
                        {
                            tempList.Add(row);
                            if (row.Command == "=" && n > 0 && myFct.AWLCode[n - 1].Command == Memnoic.opBLD[myOpt.Memnoic])
                            {
                                //Do nothing, but this line needs to be there!
                            }
                            else if (row.Command == Memnoic.opU[myOpt.Memnoic] || row.Command == Memnoic.opUN[myOpt.Memnoic] ||
                                     row.Command == Memnoic.opO[myOpt.Memnoic] || row.Command == Memnoic.opON[myOpt.Memnoic] ||
                                     row.Command == Memnoic.opO[myOpt.Memnoic] || row.Command == Memnoic.opON[myOpt.Memnoic] ||
                                     row.Command == Memnoic.opX[myOpt.Memnoic] || row.Command == Memnoic.opXN[myOpt.Memnoic] ||
                                     row.Command == Memnoic.opL[myOpt.Memnoic])
                            {
                                akPar = row.Parameter;
                            }
                            else if ((row.Command == "=" || row.Command == Memnoic.opT[myOpt.Memnoic]) && akPar != "")
                            {
                                Parameters.Add("P#V " + (row.Parameter.Replace("L", "").Replace("W", "").Replace("B", "").Replace("D", "")), akPar);
                                akPar = "";
                            }
                            else if (row.Command == Memnoic.opUC[myOpt.Memnoic] && newRow == null)
                            {
                                //Block Interface auslesen (von FC oder vom Programm)
                                //myFld.BlocksOfflineFolder.GetBlock()
                                newRow = new PLCFunctionBlockRow();
                                newRow.Command = Memnoic.opCALL[myOpt.Memnoic];
                                newRow.Parameter = row.Parameter;
                                newRow.ExtParameter = new List<string>();
                                for (int i = 0; i < row.ExtParameter.Count; i++)
                                {
                                    string s = row.ExtParameter[i];
                                    if (Parameters.ContainsKey(s))
                                        newRow.ExtParameter.Add(Parameters[s]);
                                    else
                                        newRow.ExtParameter.Add(s);
                                }
    
                            }
                            else if (row.Command == Memnoic.opBLD[myOpt.Memnoic] && row.Parameter == "2" && newRow != null)
                            {
                                newRow.CombinedCommands = tempList;
                                retVal.Add(newRow);
                                Parameters.Clear();
                                tempList = new List<PLCFunctionBlockRow>();
                                //Do nothing, but this line needs to be there!
                            }
                            else
                            {
                                retVal.AddRange(tempList);
                                tempList.Clear();
                                inBld = 0;
                            }
                        }
                        else
                        {
                            retVal.Add(row);
                        }
    
                    }
                    myFct.AWLCode = retVal;
                }            
            }
        }
    }
    ---------------------------------------------
    Jochen Kühner
    https://github.com/jogibear9988/DotN...ToolBoxLibrary - Bibliothek zur Kommunikation mit PLCs und zum öffnen von Step 5/7 Projekten
    Zitieren Zitieren CALLs aus AWL Code erzeugen...  

  2. #2
    Registriert seit
    17.06.2004
    Ort
    Offenau
    Beiträge
    3.746
    Danke
    209
    Erhielt 421 Danke für 338 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Also falls es jemand intressiert, Ich hab das für FC-Calls in FCs mal realisiert, finde es aber ziemlich umständlich wie Ich das im Moment mache, also falls dazu noch jemand eine Idee hat, nur her damit! (falls es jemand anschauen will der Code ist hier : http://siemensplctoolboxlib.codeplex...et/view/72784# dann auf libnodaveconnectionlib/plc/s7xxx/mc7/callconverter.cs klicken) ( gut, ok, der code mag im moment nicht so toll sein aber er geht!)

    Jetzt will Ich das ganze noch für FBs machen, aber das wird ja noch komplexer, da wird ja im aufruf auch noch TDB ab und an verwendet! Also bin immer noch auf der suche nach einer Idee das einfacher zu lösen...
    ---------------------------------------------
    Jochen Kühner
    https://github.com/jogibear9988/DotN...ToolBoxLibrary - Bibliothek zur Kommunikation mit PLCs und zum öffnen von Step 5/7 Projekten

Ähnliche Themen

  1. C++ Code
    Von rabit im Forum Hochsprachen - OPC
    Antworten: 9
    Letzter Beitrag: 03.01.2010, 10:42
  2. SCL code
    Von awl-scl im Forum Simatic
    Antworten: 21
    Letzter Beitrag: 14.01.2008, 17:02
  3. 10V mit SPS AO erzeugen ?
    Von kirk42 im Forum Simatic
    Antworten: 3
    Letzter Beitrag: 31.07.2006, 18:05
  4. DB mit UDT erzeugen
    Von Anonymous im Forum Simatic
    Antworten: 15
    Letzter Beitrag: 22.11.2005, 22:52
  5. AWL-code
    Von Anonymous im Forum Simatic
    Antworten: 29
    Letzter Beitrag: 09.11.2005, 16:48

Lesezeichen

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •