Atmega8515 programmieren?

[dg2ygq]

Na, ich werds Forum wohl doch voll kriegen *lach

Gut, die Tips und Links werde ich mir gleich zu Gemüte führen

Ich habe mich heute ein wenig mit der Hardware beschäftigt, also eine Platine zusammen gelötet.
Nun läuft aber das Proggy nicht auf meiner Platine (blinkende LED), sondern nur auf dem STK500.
Wie ist das mit dem Reset-Pin ? Muss der high oder low stehen? (Ich hab ihn offen)
Ich habe einen Quarz (10Mhz) zwischen XTal1 und XTal2, jeweils mit 27pF gegen Masse (Keinen Quarzoszillator), Richtig?
Wenn ich keinen Quarz einsetzen will, also die 1Mhz des 8515 nutze, gibt es da etwas zu beachten?
Die Ausgänge (In meinem Fall PortA und PortB) gehen je auf einen ULN2803, weiter über Widerstände zur 7Segment (Die funktionieren: wenn ich die Eingänge auf high lege (Widerstand auf Plus (ohne dem 8515 drin))!
Habe ich noch was vergessen zu beachten ?

Den 8515 habe ich auf meiner Platine jedenfalls (noch) nicht geschrottet, im STK500 läuft alles wie es soll ?!

 

[Dirk]

Ich denke mal es liegt daran ...

In der Standardkonfiguration wird der Ziel-Mikrocontroller, also in deinem Fall der ATmega8515, über den kleinen Mikrocontroller auf dem Entwicklungsboard mit einem Takt versorgt. Du hast wahrscheinlich dann auch im Dialog der Programmiersoftware externen Oszillator eingestellt. Der Takt muss dann an XTAL1 anliegen, XTAL2 bleibt offen. Wenn du nun auf deiner gelöteten Platine einen Quarz anschließt, schwingt er nicht, da der interne Oszillator des Mikrocontrollers ausgeschaltet ist.

Ich würde folgendermaßen vorgehen. Stecke den AVR wieder auf das STK500, und stelle über die Programmiersoftware (AVR Studio starten) bei den Fuses erst einmal wieder auf internen Oszillator um (die AVRs werden in dieser Einstellung ausgeliefert). Der AVR läuft nun mit knapp 1MHz.

Setze auf dem STK500 einen Quarz ein und stelle die entsprechenden Jumper so ein, dass der AVR am Quarz (10MHz) angeschlossen ist (das müsste eigentlich gehen). Nun die Fuses auf Ext. Crystal/Resonator high Freq. einstellen und erneut programmieren. Vorsicht: Wenn du hier eine falsche Einstellung machst und die entsprechende Takterzeugung nicht hast, kann es passieren dass du den AVR nicht mehr programmieren kannst. Also nicht auf Ext. RC-Oszillator oder Low Freq. Crystal Oszillator schalten. Ich kann dir für meine Tipps leider keine Erfolgsgarantie oder Gewähr geben, da ich mich mit dem Board nicht gut genug auskenne, es müsste aber so funktionieren.

Nun müsste dein AVR auf dem STK500 und auf deiner Platine mit dem Quarz laufen.

Den RESET-Pin kannst du offen lassen, im AVR ist ein Pullup-Widerstand, der dafür sorgt, dass der Pin auf high gezogen wird. (Ich verwende immer einen Unterspannungssensor am Reset-Eingang, der mir bei zu niedriger Betriebsspannung einen schönen Reset mit Hysterese und TimeDelay erzeugt, lass den Pin einfach erst mal offen).

Die Beschaltung von ULN2803 und Anzeige scheint ja zu funktionieren. Wenn du auf dem PortA etwas ausgeben möchtest, nicht vergessen den Port noch als Ausgang zu schalten (wie PortB).

Nachtrag:

Wenn ich keinen Quarz einsetzen will, also die 1Mhz des 8515 nutze, gibt es da etwas zu beachten?

Da gibt es nichts zu beachten, allerdings ist die Frequenz des internen RC-Oszillators nicht exakt 1MHz, die Frequenz läßt sich aber über die Programmiersoftware kalibrieren.

Also viel Erfolg!

 

[dg2ygq]

Tja, der Fehler lag an Mir! Mit offenen Lötstellen klappt das nicht so gut
Den Reset-Pin habe ich über 10kÖhmer auf +5V gelegt (vorsichtshalber halt).

Also nochmal zur externen Frequenz : MUSS ich einen Oszillator, der dann nur an XTal1 angeschlossen wird, oder tut es auch ein einfacher Quarz der zwischen XTal1 und XTal2 angeschlossen wird nehmen?
Ich habe jetzt keinen Quarz oder Osz. angeschlossen, läuft also mit int. Takt.

Assembler ist ne Menge Stoff zum lernen, aber durchaus lohnenswert.
Durch Zufall bin ich auf die Demoversion von BascomAVR gestossen. Ich denke zum rein versetzen ist Basic doch etwas übersichtlicher als Assembler.

Nun habe ich mich ein wenig mit Bascom beschäftigt, und soweit klappt das recht gut.... bis auf meine Data-Zeilen

Aber hierzu werde ich mal einen Neuen Beitrag unter Software eröffnen.

Bis auf die externe Taktfrequenz habe ich ja nun soweit alles mit deiner Hilfe, Dirk, zum laufen bekommen.
Assembler werde ich mir mal das eine oder andere Buch anschaffen, ich bin noch aus der Generation, die lieber die Seiten eines Buches (ggf. auch mal im Bett) umblättert *lach

Nochmals recht herzlichen Dank für deine Mühe(n) !

 

[Dirk]

MUSS ich einen Oszillator, der dann nur an XTal1 angeschlossen wird, oder tut es auch ein einfacher Quarz der zwischen XTal1 und XTal2 angeschlossen wird nehmen?

Du kannst natürlich einen Quarz an XTAL1/XTAL2 anschließen, Du musst nur darauf achten, daß die entsprechenden Fusebits programmiert werden.

Durch Zufall bin ich auf die Demoversion von BascomAVR gestossen...

Es ist schon sinnvoll, Bascom zu verwenden, da du dich ja bereits vom C64 mit Basic auskennst. Ich habe zwar auch einmal Basic auf einem C64 programmiert, müsste mich aber jetzt wieder in Bascom reinarbeiten, um dir weiterhelfen zu können.

Vielleicht hilft die dies aber weiter:
Prinzipiell müsstest du eine Zählvariable (0..99, 1Byte reicht) nach unten und oben begrenzen. Für die Anzeige ermittelst Du aus der Zählvariablen zwei BCD Zahlen (10er und 1er), diese Zahlen "wandelst" du (z.B. über Tabellenadressierung, Dekodierung) in entsprechende PortA/B-Werte (Segmente a...g) und gibst diese an den Ports aus. Dann verwendest du die Zählvariable erneut, um die Werte für PortC zu erzeugen, ebenfall zum Beispiel über Tabellenadressierung, wenn keine einfache mathematische Beziehung zwischen Zählvariablen und PortC-Wert zu finden ist.

 

[dg2ygq]

Naja, C64-Basic ist schon etwas ganz anderes, nicht nur die Anzahl der Befehle. Grundsätzlich ist schon eine gewisse Ähnlichkeit vorhanden, aber ich habe schon bei den einfachsten Aufgaben meine Probleme damit.


Noch mal auf die Speicherbereiche zurück zu kommen.

Was für Daten kann ich im eeprom ablegen? Auch ProgrammCode?
Welchen Vor-/Nachteil hat es, Daten im Flash- oder eeprom abzulegen?

Die Datei "8515def.inc", belegt die einen bestimmten Speicherbereich, der nur für bestimmte Dateien vorbehalten ist?

Gibt es ein ROM-Bereich, oder Bereiche wo man bloß nix hin schreiben sollte?

Sonstige "Fallen" beim Daten übertragen usw, in die der Anfänger tappen könnte?

 

[Dirk]

Im EEPROM kann man keinen Programmcode ablegen, der Programmcounter adressiert den Flash-Speicher, das Programm befindet sich also ausschließlich im Flash. Wobei ich anmerken muss, dass es möglich ist, dass sich der AVR selber blockweise flashen kann. Theoretisch könnte man so Programmteile im EEPROM ablegen und die durch eine Art Bootloader in den Flash speichern und ausführen lassen, aber stopp, viel zu kompliziert, ausserdem haben wir ja bei den AVRs reichlich Flash

Nachteile Flash:

• es ist etwas komplizierter Flash zu beschreiben
• Flash kann man bei AVRs etwa 1.000mal beschreiben (flashen)

Vorteile Flash:

• viel mehr Flash als EEPROM
• hier kann man Programmcode UND Daten ablegen
• schnell

Nachteile EEPROM:

• beschreiben dauert lange
• weniger EEPROM als Flash
• insgesamt langsamer
• kein Programmcode ausführbar

Vorteile EEPROM:

• unkompliziertes Speichern
• Anzahl der Schreibzyklen bei 100.000mal

Die Datei "8515def.inc" belegt keinen Speicher, sie definiert zum Beispiel Register, Ports, Speichergrößen usw.

Im EEPROM kannst Du hinschreiben wohin du möchtest. Im Flash darf man nicht in die ersten Adressbereiche schreiben, bei Adresse 0 (Reset) steht in der Regel ein Sprungbefehl zu dem Programmanfang im Flash. Direkt nach Adresse 0 kommen die Einsprungadressen für die Interrupts, dort darfst du nicht hinschreiben, wenn du entsprechende Interrupts nutzt. Wenn man das aber so betrachtet, darfst du auch dort nichts hinschreiben, wo sich dein Programm im Flash befindet
Wenn Du ein Programm schreibst, weiß der Compiler oder Assembler ob Daten in das EEPROM oder in den Flash geschrieben werden sollen.

 

[dg2ygq]

Supi, das hilft mir schon wesenlich weiter !

Also wäre es doch recht interessant, die Daten für die 7-Segments und dem "Ausgang" in das eeprom zu stopfen?!
Wäre es Möglich eine Hex-Datei zu mit den Daten zu erstellen, und einfach mit Hilfe des AVR-Studio`s diese Datei (gleich an den Anfang) des eeprom`s zu schreiben?

Um meine beiden 7-Segments an zusteuern, könnte ich doch auch zwei "BCD-IC" verwenden? Würde doch eine Menge programmierarbeit ersparen, da die 8 Bits eines Ports gleich in "Klarschrift" angezeigt werden würden?!
Wenn Ja, welches IC würde dafür in Betracht kommen? (Anzeige mit geminsamer Katode). Ich habe leider keine Tabellen.

Michael.

 

[Dirk]

Es ist besser, eine Tabelle mit den Daten im Flash zu erstellen, da man die einzelnen Einträge schön adressieren kann.

Man könnte zwei BCD-nach-7Segment Dekoder nehmen, da würde man nur einen Port (2x4 Bit) belegen. Wenn man an Ports "sparen" müsste, würde ich aber die Anzeige multiplexen.

Da du aber einen Mikrocontroller hast, ist es besser, wenn man so viel wie möglich per Software löst und genau so eine Anzeigenansteuerung ist hier sehr gut realisierbar.

Wenn du eine Lösung in Assembler brauchst, kann ich dir eine Routine schreiben, die dir beide 7Segmentanzeigen ansteuert und dir ein Bitmuster am PortC ausgibt (Bitmuster müsstest du hier selber eintragen), ich bräuchte dafür nur die genaue Belegung der Portpins. Also zum Beispiel

Anzeige1:
Port Segment
PA0 a1
PA1 b1
...
PA6 g1

Anzeige2:
PB0 a2

...
PB6 g2

Interessant wäre auch an welchem Pin du die Taster angeschlossen hast.

Hast Du Anzeigen mit gemeinsamer Katode, du meinst Anode, weil du ja ULN2803 verwendest (schaltet gegen GND)?

 

[dg2ygq]

Ups, ja natürlich mit gemeinsamer Anode

PortB ist für die Zehnerstelle zuständig, PortA für die Einer.
p0 = a, p1 = b, p2 = c usw ...

(PortD p0 und p1 sollen dann up/down abfragen)


Stimmt schon, hier noch ein IC-chen, dort noch eins, schon erreicht das Board
die Dimensionen eines Autos
Bei mir ist eben noch das Problem bei der programmierung: was ich Soft-mäßig nicht weiss, löte ich als Hardware ein *schäm*

 

[Dirk]

Gut, die Infos reichen mir.

Bei mir ist eben noch das Problem bei der programmierung: was ich Soft-mäßig nicht weiss, löte ich als Hardware ein *schäm*

Ist doch nicht schlimm, immerhin weißt du dir zu helfen.

Ich schreib dir dann ein kleines Programm, allerdings in Assembler nicht in Bascom-Basic, weiß aber nicht ob ich morgen schon dazu komme.

 

[dg2ygq]

Guten Morgen Dirk.

Ich hab da mal ne Frage, du schirebst in deinem Beispiel:

ldi RegA, 0b11111111 ; Initialize PortA
out PORTA, RegA
ldi RegA, 0b00000000
out DDRA, RegA

ldi RegA, 0b11111111 ; Initialize PortB
out PORTB, RegA
ldi RegA, 0b11111111
out DDRB, RegA

wäre es nicht einfacher so:

ldi RegA,0b11111111
ldi RegB,0b00000000
out PortA,RegA
out DDRA,RegB

out PortB,RegA
out DDRB,RegA

RegA wurde ja 11111111, und RegB 00000000 zugeteilt, bleiben diese Werte nicht so lange bestehen, bis man sie wieder überschreibt?
Oder hatte das einen anderen Grund warum du RegA immer wieder neu aufegfüllt hattest, obwohl das schon drin stand?

Was schreibe ich denn vor den Wert, wenn ich ihn in Hex angeben will? einfach nur
ldi var , ff ???

/edit: ldi var,0xFF wärs gewesen

 

[Dirk]

Hallo Michael!

RegA wurde ja 11111111, und RegB 00000000 zugeteilt, bleiben diese Werte nicht so lange bestehen, bis man sie wieder überschreibt?

Ja, der Inhalt des Registers RegA bleibt erhalten, solange, bis er überschrieben wird.

Oder hatte das einen anderen Grund warum du RegA immer wieder neu aufegfüllt hattest, obwohl das schon drin stand?

Ja, ich hatte die Register immer wieder mit den selben Werten beschrieben, damit es übersichtlicher wird. Es ist oft auch so, dass die Ports nicht alle immer gleich definiert werden, so dass man sowieso die Register neu beschreiben muss. Die Routine InitPorts hatte ich aus einem meiner Projekte übernommen und die meisten Ports dann als Eingang mit PullUp geschaltet. Du verlierst dadurch kaum Speicherplatz und da die Routine eigentlich nur einmal aufgerufen wird, auch nicht viel Zeit.

Was schreibe ich denn vor den Wert, wenn ich ihn in Hex angeben will?

"0x00" für hexadezimale Zahlen, "0b00000000" für binäre Zahlen.

 

[Dirk]

Ich habe ein kleines Programm geschrieben, dass dir erst einmal die 7Segmentanzeige ansteuert, indem der Inhalt einer Variablen (0...99) auf der Anzeige ausgegeben wird. Für die Tastenabfrage und die Codetabelle (PortC-Werte) hatte ich leider noch keine Zeit. Du kannst das ja vielleicht erst ausprobieren, ich konnte es leider bei mir nicht testen.

Die für die Anzeige wichtigen Routinen sind hier aufgelistet, das komplette Programm ist im Anhang.

;*********************************************************************************
;*  LEDDisplay
;*
;*  Gibt den Inhalt des Registers DisplayNumber als 7SegmentAnzeigewerte an den
;*  Ports PortA und PortB aus.
;* 
;*********************************************************************************

LEDDisplay:

   mov RegA, DisplayNumber
   rcall ConvertToBCD3       ; Ergebnis steht in Result (3Byte SRAM)

   ;************************************************
   ;*** 10er Stelle ausgeben ***********************
   lds RegA, Result+1        ; das sind die 10er
   rcall LED_DecodeDigit1
   
   in RegB, PortA
   andi RegB, 0b10000000     ; das hier nur weil du eventuell den Portpin7 anders
   or RegA, RegB             ; nutzt, damit das Bit nicht geändert wird. 
   out PortA, RegA           ; ansonsten oberen 3 Zeilen weglassen. 


   ;************************************************
   ;*** 1er Stelle ausgeben ************************
   lds RegA, Result+0        ; das sind die 1er
   rcall LED_DecodeDigit1
   
   in RegB, PortA
   andi RegB, 0b10000000     ; das hier nur weil du eventuell den Portpin7 anders
   or RegA, RegB             ; nutzt, damit das Bit nicht geändert wird. 
   out PortA, RegA           ; ansonsten oberen 3 Zeilen weglassen. 

ret

;*********************************************************************************
;*  ConvertToBCD3
;*
;*  Wandelt eine 8bit Zahl in eine aequivalente BCD-Zahl mit 3 Stellen um
;*  Quelle = RegA
;*  Ziel   = Result  (3Byte SRAM)
;*
;*********************************************************************************

; Bemerkung zur Variablen "Result" im SRAM, die Variable ist hier 3Byte groß,
; man kann die einzelnen Bytes folgendermaßen adressieren:

; lds RegA, Result    ; das ist das erste Byte (LSB)
; lds RegA, Result+1  ; das ist das mittlere
; lds RegA, Result+2  ; das ist das höchstwertige (MSB)

; Man hätte auch einzelne Variablen definideren können,
; anstelle "Result:  .byte 3" also
; "Result1:   .byte 1"
; "Result2:   .byte 2"  und
; "Result3:   .byte 3"

ConvertToBCD3:

   ldi RegC, 0

   ;*************************************
   ;*** 100 abspalten *******************
coto_bcd3a_loop: ldi RegD, 100
   cp RegA, RegD
   brcs coto_bcd3a_end
   subi RegA, 100
   inc RegC
   rjmp coto_bcd3a_loop

coto_bcd3a_end: sts Result+2, RegC     ; Das sind die 100er, die brauchen wir ja nicht, da
                                       ; deine Zahl < 100 ist.
   ;*************************************
   ;*** 10 abspalten ********************

   ldi RegC, 0
coto_bcd3b_loop: ldi RegD, 10
   cp RegA, RegD
   brcs coto_bcd3b_end
   subi RegA, 10     
   inc RegC
   rjmp coto_bcd3b_loop

coto_bcd3b_end: sts Result+1, RegC     ; Das sind die 10er

   ;*************************************
   ;*** 1 abspalten *********************
   sts Result+0, RegA                  ; das sind die 1er

ret

;*********************************************************************************
;* LCD_DecodeNumber1
;*
;* Description: Decodes Segments of Number1
;* Arguments  : RegA
;* Results    : RegA
;*
;*********************************************************************************

LED_DecodeDigit1:

   cpi RegA, 10
   brlo leddecdig1_start
   ldi RegA, 0xFF            ; alles aus, digit unterdrücken
   ret

leddecdig1_start:
   ldi r30, LOW(2*LEDSegmentTable1) 
   ldi r31, HIGH(2*LEDSegmentTable1)

   add r30, RegA             ; hier den Offset bilden
   clr RegA
   adc r31, RegA

   lpm                       ; load program memory (Byte aus Flash lesen, 
                             ; lpm nimmt die Adresse im z-Register (r30, r31)
   mov RegA, r0              ; Ergebnis ist im Register r0

   com RegA                  ; invertieren der Bits, da LEDs active low

ret

LEDSegmentTable1:            ; Das ist die Code-Tabelle für die 7SegmentAnzeige
   ;  Segmente   
   ;  -gfedcba    -gfedcba     ; Ziffern
.db 0b00111111, 0b00000110     ; 0, 1
.db 0b01011011, 0b01001111     ; 2, 3
.db 0b01100110, 0b01101101     ; 4, 5
.db 0b01111101, 0b00000111     ; 6, 7
.db 0b01111111, 0b01101111     ; 8, 9

 

[dg2ygq]

Boar ist das nen Code, da brauch ich ja Tage oder Wochen um da rein zu finden *lach

Naja, erstmal habe ich den Code aus den Fenster kopiert ....
Dann meckerte mich AVR-Studio gewaltig an : hier nicht deffiniert, und da nicht ....
Gut denke ich , deffinierste halt mal selber .... klappte noch garnicht ....
bis ich dann sah :

das komplette Programm ist im Anhang

Naja, irgendwas komisches wird schon angezeigt : die Zehnerstellen bleiben sturr auf 8, und die Einerstellen "bewegen" sich und zeigen recht merkwürde Dinge an. Der Dezimalpunkt leuchtet durchweg ?!

Die "Data`s" (LEDSegmentTable1) habe ich schon mal grob durch geschaut, stehen aber alle mit "0" am Anfang, somit dürfte der dp gar nicht leuchten?!

Na ich wurschtel mich da mal rein, vielleicht finde ich ja schon den Fehler?! Dank der super Erklärungen dabei könnte ich evtl. was finden
(Wär übrigends für "später" ne tolle Übung: In diesem Code sind 5 Fehler versteckt ..... *lach)

 

[Dirk]

Ach, den DP hattest du auch angeschlossen, den habe ich nicht berücksichtigt. Der jeweilige Pin7 von PortA und PortB wird durch die Displayroutinen nicht geändert, das ist Absicht, da ich gedacht habe, der wird nicht für das Display verwendet.

Was mir gerade einfällt, du hast ja die LED-Anzeige über einen ULN2803 angeschlossen, dann sind die Signale der Portpins für die Segmente natürlich nicht invertierend. Kommentiere die Zeile "com RegA" aus.

Und was ich noch gesehen habe, die 10er Stellen müssen an PortB ausgegeben werden, im Moment geht alles an PortA, so ist es richtig:

   ;************************************************
   ;*** 10er Stelle ausgeben ***********************
   lds RegA, Result+1        ; das sind die 10er
   rcall LED_DecodeDigit1
   
   in RegB, PortB
   andi RegB, 0b10000000     ; das hier nur weil du eventuell den Portpin7 anders
   or RegA, RegB             ; nutzt, damit das Bit nicht geändert wird. 
   out PortB, RegA           ; ansonsten oberen 3 Zeilen weglassen.

 

[dg2ygq]

Supi, nun läuft es, ABERRRRRR die Anzeige ist invertiert

Statt 1 zeigt die LED E an, statt 0 zeigt sie - an, usw usw. (Dezimalpunkt der Einerstelle leuchtet)

Ist das nun meine Hardware? Das Segment leuchtet, wenn der betreffend Pin des Ports high ist.

 

[Dirk]

Hast du das "com RegA" auskommentiert oder entfernt? Die Zeile befindet sich am Ende der Routine LED_DecodeDigit1. Wenn du die Anzeige direkt an den AVR anschließen würdest, müsstest du die Zeile stehen lassen.

Der Dezimalpunkt der Einerstelle wird durch die Displayroutinen nicht angesteuert. Er leuchtet, weil der Portpin als Input mit Pullup definiert ist, das reicht um den Eingang des ULN2803 auf high zu setzen.

Ändere die Richtung des PortPins PA7 in der Routine InitPorts als Ausgang.

   ldi RegA, 0b11111111   ; Initialize PortA
   out PORTA, RegA
   ldi RegA, 0b11111111
   out DDRA, RegA

   ldi RegA, 0b11111111   ; Initialize PortB
   out PORTB, RegA
   ldi RegA, 0b11111111
   out DDRB, RegA

DP kannst Du dann einfach so ansteuern:

sbi PortA, PA7    ; DP an
cbi PortA, PA7    ; DP aus

 

[dg2ygq]

Jawoll, nun seh ich wieder richtig !

Fein, dann werde ich mich mal in dieses Beispiel rein arbeiten, um es vollständig verstehen zu können!

Die nächsten Fragen kommen dann "später"

Danke und schönen Sonntag erstmal ...

 

[Dirk]

Ok

Ebenfalls noch einen schönen Sonntag!

 

[dg2ygq]

Puhhh, das wird noch Ewigkeiten dauern bis selber was in Assembler auf die Reihe bekomme.

Das Beispiel, wie die 7-Segmente gesteuert werden, ist mir noch einfach zu hoch, vielleicht fehlt mir heute auch nur die Konzentration ?!

Ich habe heute Abend mal selber versucht, Port`s abzufragen, und das auf einen anderen Port aus zugeben.

in portd,rega
out porta,rega

geht das so? oder gibt es da "feinere" Lösungen für ?

Einlesen des Port`s geht mit "in rega,portd" ?
Irgendwo stand das auch wie man nur ein Bit des Port`s ansprechen konnte?

Warten darauf, dass eine Taste an PortD gedrückt (low) wird, geht mit ???

Verzweigung, wenn PortD-Pin0 Low, bzw wenn Portd-Pin1 Low ist?

Wenn ich nun Addition / Subtration mit dem "Rega" anstellen will (also + bzw - 1), was mach ich da ? Mit "add" berechne ich gleich 2 Byte, oder?

Ich habe nun zwar eine Tabelle mit den Befehlen, die es überhaupt gibt, gefunden.
Aber das ist mehr als mühsehlig, den passenden Befehl für meinen "Wunsch" heraus zu finden