Beiträge von Drudge

Zitat von chepe

Wie kann man wissen ob eine Justage gut ist oder nicht?

Beim KR3 kannst du einfach in die Kerzenstellung fahren. (PTP {A1 0.0, A2 -90.0, A3 0.0, A4 0.0, A5 0.0, A6 0.0}) Dann sollten die Markierungen an den einzelnen Achsen ziemlich genau übereinander passen. Wenn dem so ist, dann ist die Justage in Ordnung. Wenn nicht, dann sollte die Justage wiederholt werden.

ja tönt sehr interessant. Weil du nach Wünschen fragtest hier eine kleine Liste von Dingen, die mir spontan in den Sinn kommen. Alles Dinge die mir persönlich wichtig sind beim Programmieren von KRL Programmen. Ich denke mal vieles kann der Editor schon.

1. Übersichtlichkeit und lesbarkeit von Code:
- einfaches Einrücken von Codezeilen/Blöcken und auch wieder zurück rücken (z.b. mit Tab und Shift-Tab)
- ähnlich wie oben aber für Ein- und Auskommentieren
- farbliche und/oder schriftstiel Hervorhebungen (für z.B. Kommentartext, Systemvariablen, datentypen, Programmen, Zahlen, Strings, Operatoren, ...)
- Blöcke (If, For, unterprogramm, Fold, etc.) minimieren und wieder expandieren
- Programmzeilen nummern
- Variable Text grösse

2. Suchen, Ersetzten und Alle ersetzten (auch über mehrere Dateien)

3. Vergleich mehrer Dateien mit ensprechendem Unterschied highlighting (ev. von ganzen Verzeichnissen)

4. Autovervollständingung (nicht nur von Systemfuktionen und Variablen sondern auch von selbst deklarierten funktionen, unterprogrammen, datentypen, signale und variablen. Wenn möglich auch Globale aus anderen Dateien und aus $Config.dat)

5. Die geöffneten Dateien in Tabs darstellen um Kaos in der Taskleiste zu vermeiden.

6. (Wunsch) Archiv.zip als Projekt laden, programmieren, projekt speichern. so dass es wieder als archiv.zip auf den Roboter geladen werden kann. Ev. geladenes Projekt als Verzeichnisbaum darstellen.

7. Bei Autovervollständingung direkt zwischen den einzelnen Feldern springen und quasi statische codeelemente "sperren". z.B. beim Unterprogrammaufruf zu den einzelnen Parametern. Einfach nur die variablen Felder angehen. (dass nicht immer mit den pfeiltastern tausendmal bewegt werden muss oder zu Maus gegriffen werden muss.)

8. gute Druckfunktionen um, wenn nötig den Code einfach und übersichtlich zu drucken.

9. undo und redo Funktionen

10. (Traum) ein integriertes KRL API

Das ist mal das was mir so spontan einfällt. Kurz zusammen gefasst eine Entwicklungsumgebung für KRL im Stil von Eclipse für Java mit der Schlankheit, Funktionalität und Bedienbarkeit von einem Texteditor wie Notepad++ wäre genial.

mal ne Frage: Ist diese Liste immernoch aktuell? Und gibt es ev. auch eine Liste für alle Funktionen inkl. Parameterliste? (SIN, SWRITE, STRCOMP, COS, FORWARD, ...)

zusätzlich zu dem was ich schon geschrieben habe:
- im interruptprogram wird $advance nicht = 0 gesetzt, der Vorlaufzeiger ist nur temporär auf 0.
- ich habe gehört, dass z.B. $Load.m (variablen für das höhere Fahrprofil) in der interrupt routine nicht verändert werden dürfen.

base und tool manuell an wählen geht über das Menü [Konfiguration]-> [6. Setzte Werkzeug/Basis] oder im code mit bas.src

Hallo

Ja nach meiner Erfahrung ist der Vorlaufzeiger = 0 in Interruptprogrammen und er kann nicht verändert werden.

Da ein deklarierter Interrupt von überall (auch oberhalb der Deklarationsstufe) ausgelöst werden kann, sofern er nicht deaktiviert wurde, müssen alle verwendeten Variablen sowie die dazugehörigen Typen auch Global sein. Das heisst in $Config.dat oder GLOBAL deklariert. Die Werte im Inlineformular sind normalerweise nicht global.

Ich bin mir auch nicht sicher ob man nichtspeichernde Variablen in Inerruptprogrammen beschreiben kann. Das müsste ich erst testen. Entsprechend kann ich jetzt nicht definitv sagen ob Beschl. und Geschw. etc in Interruptprogrammen verändert werden können.

Die Frage mit Tool und Base ändern im Handverfahren verstehe ich nicht ganz. Willst du einfach ein Tool und Base manuel in T1/2 anwählen um den Roboter nach Base oder Tool zu verfahren?

ja es ist ziemlich mühsam in dem mdb neue Langtexteinträge direkt zu machen. Je nach Softwarestand können die Langtexte aber ziemlich einfach exportiert erweitert und wieder importiert werden.

Was verstehst du unter "standalone Betrieb" ? Meinst du damit, dass der Roboter die Eingangssignale selber auswerten und entsprechend handeln muss?

1. Soviel ich weiss, sollte bei der Steuerung ein Schaltplan dabei sein. Da würde auch die exakte Pin Belegung für den X11 stehen.

2.
erst gewünschtes Programm anwählen
a) SAK Fahrt in T1/T2
b) Antriebeein (grosser Knopf auf dem KCP mit dem Strich)
c) Start-Taste drücken . . . Programm läuft

3. den Programmaufbau und die Bedienung kannst du machen wie du es am besten findest.

suchst du in etwa das?

IF $TIMER_STOP[timerNr] == false THEN
        IF $IN[inNr] == true THEN
            $TIMER_STOP[timerNr] = true
        ELSE
            IF $TIMER_FLAG[timerNr] == true THEN
                $TIMER_STOP[timerNr] = true
                msgToUser()
            ENDIF
        ENDIF
    ELSE
        IF $OUT[outNr] == true THEN
            $TIMER[timerNr] = (-1)*timeOutValue
            $TIMER_FLAG[timerNr] = false
            $TIMER_STOP[timerNr] = false
        ENDIF
    ENDIF

hallo zusammen

ich spiele jetzt schon einige Zeit mit sin, cos, acos, tan, etc. rum, weil ich verschiedene Berechnungen an Dreiecken, Kreisen, etc. machen will. Nun finde ich die Zahl Pi nicht. Kann es sein, dass ich da selber eine Konstante erstellen muss oder gibt es diese Variable im System irgendwo?

Gruss drugde

Ich kenne bis jetzt auf jeden Fall niemanden . . .

nur mal kurz zur allgemeinen Veranschaulichung von wegen POV, Achsgeschwindigkeit und Singularität soweit ich das verstehe:

Wenn also z.B. 10% POV aktiviert ist, dann heisst das: Der TCP bewegt sich 0.2 m/s, sofern die Bewegung bei voller Geschwindigkeit gemacht werden soll.
Nehmen wir mal an der Roboterinterpreter berechnet die Bahnpunkte mit 1mm Distanz, dann hat der Roboter also 5 millisekunden Zeit um von Punkt zu Punkt zu fahren.
Wenn du nun in eine Singularität kommst und die Achse 4 beim Punkt P(x) auf 0° steht, durch die unendliche Anzahl Lösungen der Interpreter beim Punkt P(x+1) aber 180° für die Achse 4 berechnet, bedeutet das, dass die Achse 4 180° in 0.005 sec machen muss. Das wären dann 100 Umdrehungen pro Sekunde (!) für Achse 4 um die geforderten 0.2 m/s am TCP sicher zu stellen.
Da aber die Achse 4 beim Punkt P(x) eigentlich stillsteht, erhöht sich die zu erreichende Geschwindigkeit auf 200 Umdrehungen pro Sekunde bei einer Beschleunigung von 400 Umdrehungen / s^2 (!!) Das aber nur, wenn die Achse in P(x+2) auch noch auf 180° stehen muss. Dabei ist die Trägheit aber noch nicht miteingerechnet.
Einer groben Schätzrechnung nach wären das ca. 450 km/h für die Achse 4.
Ich bin mir aber nicht ganz sicher ob die Mechanik solcher Dynamik gewachsen ist?

So das habe ich jetzt einfach mal so geschrieben. Ich weiss nicht ob ich richtig gerechnet habe und ich weiss dass einige Annahmen nicht 100% korrekt sind. Doch denke ich sieht man so ein wenig woher das Sollgeschwindigkeitsproblem bei Singularitäten kommt.

hmm wenn du von einer vorhängig unbekannten Position wegfahren willst (und das nicht zu einem bekannten Punkt) dann schreib doch einfach die aktuelle Position in eine temporäre Variable und fahre relativ zu dieser Variable mit dem goemetrischen Operator. (Aber Achtung mit dem Vorlaufzeiger!!!!)
Das würde auch bei einer erneuten Satzanwahl keine Probleme geben.

Nein zugross ist es nicht (502KB). Aber es wurde für einen Kunden erstellt und deshalb darf ich es nicht einfach hier posten.

Ja ich habe das Programm selber geschrieben und zwar auf meinem XP Notebook mit dem Notepad++ erstellt.

Nein es ist nicht wirklich möglich ein Archiv zu posten . . . aber was genau willst du gerne sehen? Vieleicht kann ich speziefische, einzelne Dateien oder Auszüge posten.

Was mir jedoch bei der Inbetriebnahme auffiel, war dass es nicht möglich war einen TouchUp auf die Punkte zu machen, die ich in eigenen *.Dat Files deklariert hatte. Deshalb verschob ich diese 1 zu 1 in das $Config.dat und siehe da es funktionierte einwandfrei.

danke soweit

Hallo zusammen

Ich schrieb ein Programm für einen KR15/2 auf einer KRC1 mit Softwarestand V4.1.7

Seit der Inbetriebnahme aber gab es immerwieder mystische modifikationen der Globalen Variablen, ohne Programm oder Benutzereingriff. Bis jetzt nahm ich immer an, dass es ev. eine Fehleingabe meinerseits, vergessene Eingaben oder Usermanipulationen seien. Denn es die Fehlerquelle war nie eindeutig zu identifizieren. Doch nach und nach bekomme ich den Eindruck, dass etwas mit der Speicherverwaltung oder dem Abspeichern auf die HD nicht ganz richtig funktionieren könnte.
Ein zwei mal schien es, dass nach dem Neustart einige manuell veränderte Punktdaten wieder auf die original Daten zurückgesetzt wurden. Manchmal wurden Variablen einfach verändert oder aber nicht verändert obwohl sie druch das Programm verändert werden hätten müssen.
Es gibt keinerlei Fehlermeldungen oder sonstige Auffälligkeiten, die auf die Fehlerquelle hinweisen würden.

Ich habe ca. 40 globale Variablen im $Config.dat im UserFold (meist vom Typ Integer)
dann habe ich 8 zweidimensionale Arrays vom Typ FRAME wo sämmtliche Positionsdaten für das Handling drin sind
zusätzlich gibt es noch 3 eindimensionale Arrays des Typs FRAME mit ca. der Länge von 450
--> $Config.dat ist 165 KByte gross

dann sind noch weitere globale Variablen in 3 wesentlich kleineren Dat- files. (z.B. Ein Array für Fehlertexte) diese Dateien sind in einem separaten Unterordner im Program Ordner.

sämmtliche Dat Files sind Public und die Variablen Global deklariert. jede Variable ist auch speichernd deklariert.

Hat irgendjemand vielleicht schon mal das selbe gehabt oder eine leise Ahnung wo der Hund begraben sein könnte?

Es grüsst
Drudge

ich persönlich finde die Kurse die KUKA anbietet sehr lehrreich und auch einiges spannender als die Unterlagen zu studieren. Es kostet zwar ein wenig, doch kann man da von der Erfahrung der Teacher provitieren und wenn mal was schiefgeht, dann ist es auch nicht so schlimm. Am Besten mal versuchen den Chef zu einem Kurs zu überreden.

Ich denke was WolfHenk schrieb ist wohl die schnellste und praktischste Lösung. Wenn aber unbedingt eine real Variable übergeben werden muss kann man folgendes machen:
(zu beachten ist, dass die KRL real Variable der 32Bit float Variable in C entspricht. http://babbage.cs.qc.edu/cours…1/IEEE-754references.html)

DEF realToBin()
  DECL int i, j, selector
  DECL real var
  DECL CHAR realString[4]
  DECL CHAR binaryView[32]


  realString[] = "XXXX"
  binaryView[] = "00000000000000000000000000000000"
  var = 33333.332

  offset = 0
  SWRITE(realString[], status, offset, "%r", var)
  $LOOP_MSG[] = "                                                                                               "


  FOR i=1 TO 4 STEP 1
    selector = 'b00000001'
    FOR j=8 TO 1 STEP -1
      IF NOT ((realString[i] B_AND selector)==0) THEN
        binaryView[((4-i)*8)+j] = "1"
      ENDIF
      selector = selector * 2
    ENDFOR
  ENDFOR


  offset = 0
  SWRITE($LOOP_MSG[], status, offset, "%s", binaryView[])


END

Im Zielstring binaryView[] ist nun die real Variable in CHAR "0" oder "1" gespeichert. Wie man unschwer erkennen kann, muss das resultat nicht genau so gespeichert werden, es könnte auch in eine INT Variable geschrieben oder auf 32 Ausgänge gelegt werden, etc. Ich habe es mir nur so gemacht um das Resultat über $MSG_LOOP zu betrachten. Der CHAR mit dem Index 1 ist das bit 31 und der Index 32 ist das Bit 0. Oder auch [1]:=Vorzeichen [2-9]:=Exponent [10-32]:=Zahl