Tipps zur übersichtlichen Programmierung

  • Grüßt euch alle miteinander,


    ich bin noch Anfänger in der Programmierung und bin dankbar über jeden Tipp zur strukturierten Programmierung :)


    Ich habe folgende Aufgabe:

    Es geht um einen Rundlauf, auf diesem kommen Werkzeugträger (WT) mit 3 fertigen Bauteilen in jeweils verschiedenen Nestern.

    Der Robi soll nun Stück für Stück entnehmen und in ein Tray beladen in welches 20 dieser Bauteile passen.

    Heißt also es werden 7 WT's entleert um ein Tray zu befüllen.



    Ich hatte vor die Programmstruktur wie folgt anzulegen:


    Job10_Holen ()

    -> Switch Case aus welchem Nest geholt werden soll

    -> UP Holen_Nest1 ()

    -> UP Holen_Nest2 ()

    -> UP Holen_Nest3 ()


    ;jedes UP_Holen hat einen Aufruf für Job20_Bringen ()

    Job20_Bringen ()



    Fragen:

    1. Habe ich nun Probleme mit der Tiefe der Unterprogramme? (gab es nämlich zuletzt bei meinem wirren Prog.Stil)

    2. Wie würdet ihr am besten die UP aufrufen - mit einem IF Befehl (also z.b. wenn er das Bauteil im Greifer)

    3. Nach der Abarbeitung von Job20_Bringen () müsste er eigentlich mein Hauptprogramm Job10 springen (hat aber leider zuletzt auch nicht funktioniert) - muss ich es erneut über Syntax aufrufen?



    Ich hoffe ihr könnt mir ein paar Tipps geben. Ich bitte auch um Nachsicht - bin noch relativ jungfräulich in der Roboter Programmierung und hier im Forum :S


    Freundliche Grüße!

  • Schritt für Schritt zum Roboterprofi!
  • Erst mal beantworte ich die eindeutigen/einfachen Fragen :)


    1. Technisch hast du kein Problem mit der Tiefe - bis zur Ebene 20 ist bei KUKA möglich. Wenn du die Struktur verstehst und anderen verstänldich machen kannst, passt das.
    2. Gibt es eine Prozesskontrolle, ob ein Beiteil im WT vorhanden ist
    3. du brauchst eine Wiederholstruktur, die abbricht, falls Tray voll

    etwa:


    repeat

    job10()

    job20()

    until trayVoll

  • Ich würde den Aufruf für Job20 ins Hauptprogramm setzen und nicht in die anderen Unterprogramme verschachteln. So sieht jeder der mal an die Anlage kommt auf einen Blick ins Hauptprogramm was im groben alles passiert.


    Immer daran denken dass das Programm an jeder stelle abgebrochen werden kann (Anlagenstopp, Not-Halt, ...) und die Anlage danach eventuell von Grundstellung neu gestartet wird. Daher auf jeden Fall daran denken sich zu merken (oder am besten mit einer Abfrage abfragen) ob noch ein Bauteil im Greifer ist.

    Und dann natürlich nur in die Pick-Routinen laufen wenn auch ein Bauteil benötigt wird.


    IF b_Partpicked==FALSE THEN

    Pick()

    ENDIF


    Bei deiner dritten Frage wäre interessant was da bei dir nicht funktioniert hat. Der Programmzeige sollte nach dem Abarbeiten des Unterprogramms auf jeden Fall wieder von selbst ins Hauptprogramm zurückspringen. Verschachtelungen wie main=>UP1=>UP2=>main sind ein Fehler, daher kommen wahrscheinlich deine Probleme mit der Ebenentiefe.

  • Hi, danke für den wertvollen Tipp für den Fall eines Nothalts bzw. Abbruch - werde ich mit beachten und umsetzen!


    Zur Programmstruktur, ich habe es wie folgt umgesetzt:


    Aufruf meines Job's "Transport ()" über die cell.src


    Im Modul Transport () habe ich alle UP's gepackt, jeweiligen Teil HOLEN ( ) springt er einfach in ABLAGE ( ) UP und darin warte ich dann auf Jobaufruf für einen erneuten Aufruf von HOLEN ().


    So mal ganz grob dazu.

    • Hilfreich

    Ich weiß nicht ob ich ich dich richtig verstehe aber es liest sich für mich als würdest du dich immer tiefer in Unterprogramme graben.


    ich würde folgendermaßen vorgehen


    Cell, Transport, Holen, Ablage. Das sind alle Abläufe die ich brauche


    von cell rufe ich dann auch wie du Transport auf.


    in Transport rufe ich dann Holen auf.


    da drin realisiere ich dann die Unterscheidung Nest 1-3. Diese würde ich gar nicht auf 3 weitere UPs aufteilen.

    Am ende springe ich wieder zurück (!! ebene nach oben, nicht nach unten) nach Transport.

    wieder von Transport aus rufe ich dann Ablage auf.

    Ist das Ablegen erledigt gehe ich wieder zurück zur Transportroutine. Entweder hier eine schleife einfügen damit direkt das nächste teil geholt wird oder ich springe zurück (ohne Programmaufruf, einfach das UP fertig laufen lassen) nach cell und warte dort auf einen neuen Fahrauftrag.


    etwa:


    DEF Cell ()


    blablabla


    LOOP

    ...

    CASE 1

    Transport ()

    ...

    ENDLOOP


    END


    DEF Transport ()

    ...

    ini

    logik


    HOLEN()


    etwaige logik


    ABLAGE()


    zurück nach Home


    END


    in den Routinen Holen und Bringen sind dann keine weiteren Unterprogrammaufrufe versteckt.

  • Perfekt beschrieben!

    Tatsächlich mache ich das auch so und habe nur etwas zu sporadisch geschrieben..


    Ich habe zwar tatsächlich noch jeweils für die 3 Nester ein UP, die ich über HOLEN () Aufrufe - brauche ich wirklich nicht ist mir aufgefallen - vll ändere ich das noch..



    Zum Ablegen habe ich jedoch noch die Besonderheit, dass ich unterschiedlich in ein Tray ablegen muss.

    Heißt jede zweite Position wird das Bauteil um 180° verdreht eingelegt.


    Habe dann in ABLEGEN () noch zwei UP's die Ablage_gerade () und Ablage_ungerade benannt sind.

    Ungerade/gerade im Sinne der abgelegten Anzahl im Tray.

    Noch dazu ein Ablage_niO ()


    Aus jedem dieser Ablegen UP's springe ich wieder zurück zu HOLEN ().


    Habe den Ablauf auch schon getestet, die 20 Stück legt er ohne Störungen ein.

    Stellt sich mir nur grade die Frage ob dass dann auch für mehrere Trays nacheinander funktioniert...

    Also gibt es dann möglicherweise Probleme nach dem x-ten befüllten Tray?




    Vielen Dank jeden Falls schon mal für die Zeit und guten Tipps!!

  • Noch eine Zusatzfrage:


    Wie rufst du im UP HOLEN () dass UP ABLEGEN () auf?


    Nur interessehalber mal gefragt, habe mein Programm nun über die Hälfte gekürzt und würde es gerne mal ohne SPS in der Schleife ablaufen lassen für den TEST...tatsächlich bei Ebenentiefe 20 haut er mir den Fehler raus mit Verschachtelung

  • .. Aus jedem dieser Ablegen UP's springe ich wieder zurück zu HOLEN (). ...

    Hoffe mal dass da im Ablegen() nicht wieder ein Aufruf von HOLEN() steht, sondern ein return. Sonst ist das nämlich eine Rekursion, das geht sowas von schief, und ist nur in Ausnahmefällen sinnvoll.


    Am einfachsten wäre es die kompletten Programme zu posten, diese blumigen Beschreibungen des Programmablaufs bringen so überhaupt nix, da gibt es nur jede Menge Ungereimtheiten, Ungenauigkeiten und Missverständnisse. ;)

Erstelle ein Benutzerkonto oder melde dich an um zu kommentieren

Du musst ein Benutzerkonto haben um einen Kommentar hinterlassen zu können

Benutzerkonto erstellen
Neues Benutzerkonto für unsere Community erstellen. Geht einfach!
Neues Benutzerkonto erstellen
Anmelden
Du hast bereits ein Benutzerkonto? Melde dich hier an.
Jetzt anmelden