Textausgabe programmieren

Ragnar · 23. September 2010

Hallo liebe Gemeinde,

ich soll innerhalb der KR C 5.2.14 einen Programmabschnitt schreiben der so aussehen soll:
- Bewegung
- Roboter hält an
- Textausgabe (ob im Meldungsfenster oder falls möglich irgendwo anders auf dem TeachPanel ist egal)
zum Beispiel "Möchten sie fortfahren (J)a / (N)ein"
-dann eine Verzweigung -> wenn "Ja" dann , wenn "Nein" dann...

eigentlich besteht das Problem nur bei den Befehlen Textausgabe (gibt es da evtl. sowas wie "printf"?) und der Tasteneingabe ("scanf"-ähnliches??), da ich Kuka mäßig noch nie Programme programmieren musste. In der Doku habe ich zu den beiden Problemchen nix gefunden.

Für eure Antworten bedanke ich mich schon mal jetzt

Ragnar

mike · 23. September 2010

Mit der Meldungsprogrammierung würdest du alles erschlagen.

Gruß

Programmiersklave · 23. September 2010

Ich mach das immer ungefähr so:

Code

answer=frageint("Chef, sollen wir das Programm %1 fahren?",programmnummer_integer,"Gewiss!|Neinnein")
if answer<> 1 then
 	halt
endif

oder für einfache Fälle ohne übergebene Zahl:

Code

answer=frage("Ey, willste das wirklich?","Ja|Nein|Vielleicht")
switch answer
  case 1:
  ;du hast es so gewollt
  case 2:
  ;dann eben nicht
  halt
  case 3:
  ;vielleicht aber auch nicht
  default
  ;was soll das?
endswitch

Alles anzeigen

und dann die zugehoerigen Funktionen.

Code

GLOBAL deffct int frage(fragetxt[]:in, antw[]:in)


  DECL CHAR fragetxt[]
  DECL CHAR antw[]
  DECL INT ANSWER
  DECL STATE_T STATE
  DECL MSG_T EMPTY_MSG
  EMPTY_MSG={MSG_T: VALID FALSE,RELEASE FALSE,TYP #NOTIFY,MODUL[] " ",KEY[] " ",PARAM_TYP #VALUE,PARAM[] " ",DLG_FORMAT[] " ",ANSWER 0}
  	$MSG_T=EMPTY_MSG
  	wait sec 0.3
        $MSG_T.MODUL[]=" "
        $MSG_T.KEY[]=fragetxt[]
        $MSG_T.PARAM[]="  "
        $MSG_T.RELEASE=FALSE
        $MSG_T.PARAM_TYP=#KEY
        $MSG_T.TYP=#DIALOG
        $MSG_T.DLG_FORMAT[]=antw[]
        $MSG_T.VALID=TRUE
       WHILE  $MSG_T.VALID
            WAIT SEC 0.05
       ENDWHILE
       WAIT SEC 0.2
       ANSWER=$MSG_T.ANSWER
  WAIT SEC 0.2
  $MSG_T=EMPTY_MSG
  WAIT SEC 0.2
  return answer
ENDFCT


GLOBAL deffct int frageint(fragetxt[]:in, zahl:in, antw[]:in)


  DECL CHAR fragetxt[]
  DECL CHAR antw[]
  INT zahl
  DECL INT ANSWER, OFFSET
  DECL STATE_T STATE
  DECL MSG_T EMPTY_MSG
  EMPTY_MSG={MSG_T: VALID FALSE,RELEASE FALSE,TYP #NOTIFY,MODUL[] " ",KEY[] " ",PARAM_TYP #VALUE,PARAM[] " ",DLG_FORMAT[] " ",ANSWER 0}
  	$MSG_T=EMPTY_MSG
  	wait sec 0.3
        offset=0
        $MSG_T.MODUL[]=" "
        $MSG_T.KEY[]=fragetxt[]
        $MSG_T.PARAM[]="  "
        SWRITE($MSG_T.PARAM[],STATE,OFFSET,"%d",zahl)
        $MSG_T.RELEASE=FALSE
        $MSG_T.PARAM_TYP=#VALUE
        $MSG_T.TYP=#DIALOG
        $MSG_T.DLG_FORMAT[]=antw[]
        $MSG_T.VALID=TRUE
       WHILE  $MSG_T.VALID
            WAIT SEC 0.05
       ENDWHILE
       WAIT SEC 0.2
       ANSWER=$MSG_T.ANSWER
  WAIT SEC 0.2
  $MSG_T=EMPTY_MSG
  WAIT SEC 0.2
  return answer
ENDFCT

Alles anzeigen

Diese Wait sec da unten sind zum Teil überflüssig, aber der Kuka hat kriegt manchmal die Änderungen nicht so schnell mit.
Könnte man alles noch etwas schöner machen und in einer zusammenfassen, egal, später....

Grüße,
Michael

Ragnar · 23. September 2010

Vielen Dank ich versuch das jetzt erstmal alles nachzuvollzihen und da durchzuwusseln!
btw was macht das SWRITE?!
Vielleich hat jemand ja noch schöneren Code?! :laugh:

LG
Ragnar

Stethi · 23. September 2010

hier mal die Doku..

Programmiersklave · 23. September 2010

Danke, das hätte ich mal vor ein paar Jahren gebraucht :laugh:
SWRITE ist ein Formatierungsbefehl. Meine Doku dazu ist wohl auch nicht mehr ganz taufrisch, aber man muss nehmen, was man kriegen kann:

Grüße

Ragnar · 23. September 2010

Programmiersklave

könntest du deinen Code mal als ganzes Posten und evtl. kommentieren? ich blick da noch net so ganz durch..sry is fast 2 jahre her, dass ich n bisl programmiert hab..und auch nur n bisl c ..ein hoch auf n BSc

Programmiersklave · 24. September 2010

Ach herrjeh.
Das war ja an sich schon die ganze Wahrheit.
Ich habe mir halt eine oder mehrere Funktionen gemacht, die als global deklariert und in irgendeiner externen *.SRC untergebracht. Beide hier geposteten Funktionen tun sinngemäß dasselbe, nur dass ich bei einer auch noch eine (Integer-)Zahl in die Ausgabe des Textes integrieren kann. Für die einfache Entscheidung, wenn nur Text übergeben wird, tut es auch die andere.
Nehmen wir mal jene:

Code

GLOBAL deffct int frage(fragetxt[]:in, antw[]:in)
;obiges die Deklaration der Funktion.
;Sie gibt einen INT zurück und erwartet zwei Strings als Parameter.
;Im Prinzip habe ich hier die KUKA-Programmierbeispiele verhunzt.


;hier sind die Deklarationen der beiden uebergebenen Strings
  DECL CHAR fragetxt[]
  DECL CHAR antw[]
;das hier brauchen wir intern
  DECL INT ANSWER
;die Typen STATE_T und MSG_T sind von KUKA vordefiniert, siehe DOKU
  DECL STATE_T STATE
  DECL MSG_T EMPTY_MSG
;wir initialisieren die Variable EMPTY_MSG. Diese Leermeldung brauchen wir, um dieses unsaegliche System sauber zu bekommen.
  EMPTY_MSG={MSG_T: VALID FALSE,RELEASE FALSE,TYP #NOTIFY,MODUL[] " ",KEY[] " ",PARAM_TYP #VALUE,PARAM[] " ",DLG_FORMAT[] " ",ANSWER 0}
  $MSG_T=EMPTY_MSG ;hier belegen wir die KUKA-Systemvariable, die am Ende die Frage enthält, mit unserer Leermeldung.
  wait sec 0.3 ;der Kuka scheint im Hintergrund eine Winzigkeit zu brauchen, um diese Tatsache zu akzeptieren. 0.3 muessen es nicht sein
;jetzt werden die einzelnen Teile der Struktur $MSG_T sinnvoll belegt, siehe die Doku, die Stethi geschickt hat       
  $MSG_T.MODUL[]=" " 
  MSG_T.KEY[]=fragetxt[] ;hier kommt in dem Fall die Frage rein
  $MSG_T.PARAM[]="  "
  $MSG_T.RELEASE=FALSE
  $MSG_T.PARAM_TYP=#KEY
  $MSG_T.TYP=#DIALOG ;es soll ein Dialog werden, kein Monolog :-) 
  $MSG_T.DLG_FORMAT[]=antw[] ;hier kommen die Antwortmoeglichkeiten rein, als String formatiert, getrennt durch den senkrechten Balken, warum auch immer.
  $MSG_T.VALID=TRUE ;hier machen wir die Meldung gueltig -> in dem Moment erscheint sie im Meldungsfenster (und verdraengt andere selbsterzeugte Meldungen, also Vorsicht!)
  ;Die Meldung wartet jetzt (auf Systemebene) auf die Betaetigung eines Softkeys. Sobald man einen drueckt, wird VALID wieder FALSE
  WHILE  $MSG_T.VALID
      WAIT SEC 0.05
  ENDWHILE
  WAIT SEC 0.2 ;wie gesagt, diese Zeiten...
  ANSWER=$MSG_T.ANSWER ;hier haben wir die Antwort vom System in Form eines Integers, durchgezaehlt. Die erste Antwortmoeglichkeit hat die 1 usw.
  WAIT SEC 0.2
  $MSG_T=EMPTY_MSG ;saubermachen
  WAIT SEC 0.2
  ;und die Antwort zurueckgeben an das aufrufende Programm
  return answer
ENDFCT

Alles anzeigen

So, jetzt können wir an beliebiger Stelle im Programm eine Auswahl treffen, indem wir jene Funktion verwenden.
Zum Beispiel, wenn es darum geht, einen Greifer zu öffnen:

Code

DEF machwas.src ()


int dummy


PTP sonstwohin
;wenn noch ein Teil im Greifer haengt (Eingang 111)
IF $IN[111] then
     dummy=frage("Teil ist noch gegriffen. Sofort loesen?","Loesen|Entn.Pos.")
     IF  dummy==2 THEN
          ;wenn der Bediener auf Entnahmeposition drueckt
          PTP entnahmeposition ;fahren
          $OUT[113]=TRUE ;loslassen
          PTP sonstwohin ;zurueck
     ELSE
          ;wenn er was anderes drueckt: fallen lassen
          $OUT[113]=TRUE ;loslassen
     ENDIF
ENDIF
END

Alles anzeigen

Oder wir verwenden die Frage nur für Bestätigungen, der Wartemechanismus ist ja eingebaut:

Code

DEF machnix.src ()


int dummy
bool bumm


PTP sonstwohin
dummy=frage("Vorsicht, gleich knallt es!", "Okay")
bumm=TRUE


END

Alles anzeigen

Oder wir koennen bis zu 7 (Anzahl der Buttons) Auswahlmöglichkeiten für irgendwas treffen.

Code

DEF waehlwas.src ()


int auswahl
ind dummy


PTP startposition


auswahl=frage("Welches Programm soll gefahren werden?","Bearb.|Reinig.|Wartung|Kalibr.|Home|Demo")
;jetzt mit einer Switch-Case-Verzweigung:
switch auswahl
     case 1
          ;Bearbeiten aufrufen
          machwasgescheites()
     case 2
          ;Reinigen aufrufen
          abblasen()
     case 3
          ;Wartungsposition anfahren
          PTP wartungsposition
          halt
     case 4
          ;irgendwelche Sensoren kalibrieren
          kalibriermich(1)
          kalibriermich(2)
          kalibriermich(3)
     case 5
          ;Home anfahren
          PTP home
     case 6
          ;so tun, als würde man arbeiten
          loop
               PTP linksrum
               PTP rechtsrum
               PTP rauf
               LIN runter
          endloop
     default
          ;Wenn eine andere Zahl zurueckkommen sollte
          dummy=frage("Fehlbedienung!", "Okay")
          halt
endswitch
end

Alles anzeigen

Ohne Gewähr für Schäden an Mensch und Maschine

Grüße,
Michael

Ragnar · 27. September 2010

Danke sehr klappt wunderbar

Pausenbrot8000 · 4. September 2012

Zitat von Programmiersklave

Ich mach das immer ungefähr so:
und dann die zugehoerigen Funktionen.

Code

GLOBAL deffct int frage(fragetxt[]:in, antw[]:in)


  DECL CHAR fragetxt[]
  DECL CHAR antw[]
  DECL INT ANSWER
  DECL STATE_T STATE
  DECL MSG_T EMPTY_MSG
  EMPTY_MSG={MSG_T: VALID FALSE,RELEASE FALSE,TYP #NOTIFY,MODUL[] " ",KEY[] " ",PARAM_TYP #VALUE,PARAM[] " ",DLG_FORMAT[] " ",ANSWER 0}
  	$MSG_T=EMPTY_MSG
  	wait sec 0.3
        $MSG_T.MODUL[]=" "
        $MSG_T.KEY[]=fragetxt[]
        $MSG_T.PARAM[]="  "
        $MSG_T.RELEASE=FALSE
        $MSG_T.PARAM_TYP=#KEY
        $MSG_T.TYP=#DIALOG
        $MSG_T.DLG_FORMAT[]=antw[]
        $MSG_T.VALID=TRUE
       WHILE  $MSG_T.VALID
            WAIT SEC 0.05
       ENDWHILE
       WAIT SEC 0.2
       ANSWER=$MSG_T.ANSWER
  WAIT SEC 0.2
  $MSG_T=EMPTY_MSG
  WAIT SEC 0.2
  return answer
ENDFCT


GLOBAL deffct int frageint(fragetxt[]:in, zahl:in, antw[]:in)


  DECL CHAR fragetxt[]
  DECL CHAR antw[]
  INT zahl
  DECL INT ANSWER, OFFSET
  DECL STATE_T STATE
  DECL MSG_T EMPTY_MSG
  EMPTY_MSG={MSG_T: VALID FALSE,RELEASE FALSE,TYP #NOTIFY,MODUL[] " ",KEY[] " ",PARAM_TYP #VALUE,PARAM[] " ",DLG_FORMAT[] " ",ANSWER 0}
  	$MSG_T=EMPTY_MSG
  	wait sec 0.3
        offset=0
        $MSG_T.MODUL[]=" "
        $MSG_T.KEY[]=fragetxt[]
        $MSG_T.PARAM[]="  "
        SWRITE($MSG_T.PARAM[],STATE,OFFSET,"%d",zahl)
        $MSG_T.RELEASE=FALSE
        $MSG_T.PARAM_TYP=#VALUE
        $MSG_T.TYP=#DIALOG
        $MSG_T.DLG_FORMAT[]=antw[]
        $MSG_T.VALID=TRUE
       WHILE  $MSG_T.VALID
            WAIT SEC 0.05
       ENDWHILE
       WAIT SEC 0.2
       ANSWER=$MSG_T.ANSWER
  WAIT SEC 0.2
  $MSG_T=EMPTY_MSG
  WAIT SEC 0.2
  return answer
ENDFCT

Alles anzeigen

Hm, ich hab das jetzt so Versucht, aber er bringt für die Zeilen:
$MSG_T.KEY[]=fragetxt[] und $MSG_T.DLG_FORMAT[]=antw[]

-> Feld unzulässig
Jemand eine Idee warum?

Textausgabe programmieren

Erstelle ein Benutzerkonto oder melde dich an um zu kommentieren

Gebrauchtroboter kaufen - Was ist zu beachten. Die Checkliste zum kauf von gebrauchten Robotern

Was macht ein Roboterprogrammierer genau und was verdient er?

Vernetzen, referenzieren, kollaborieren: Das B2B Portal für die Produktionsautomatisierung

Sie wollen Ihr Stellenangebot im Roboterforum schalten? Ab 149€

Werde Roboterprogrammierer bei ROBTEC GmbH in Mainburg / Bayern

Teilen

Wieviele Mitglieder waren heute eingeloggt?