SPIN2 und Propeller P2

Das DEBUG-System

1 - DEBUG - System einschalten

Der Spin2-Compiler enthält ein Debugger-Programm, das automatisch mit einer Anwendung geladen werden kann. Es verwendet die letzten 16 KB RAM plus ein paar Bytes für jede Spin2 DEBUG-Anweisung.

DEBUG-Anweisungen werden in einer Anwendung platziert. Wird während der Programmausführung auf eine DEBUG-Anweisung gestoßen, wird der Debugger aufgerufen, der dann die Nachricht für diese Anweisung im DEBUG-Fenster anzeigt.

Im Propeller-Tool (ab Vers. > 2.6) kann der Debugger über STRG-D oder das Hauptmenü

• RUN - Enable Debug

aufgerufen werden.

F10 kompiliert eine Anwendung mit allen DEBUG-Anweisungen und öffnet das DEBUG-Ausgabefenster.

2 - Was man beim DEBUG-System beachten sollte (Auszug)

• Der Systemtakt muss mindestens 10-MHz betragen. RCFAST oder RCSLOW können nicht verwendet werden.
• Der Debugger belegt die oberen 16 KB des Hub-RAM, neu zugeordnet auf $FC000..$FFFFF und ist schreibgeschützt. Der Hub-RAM bei 7C000..$7FFFF wird nicht mehr verfügbar sein.
• Wird nicht für den DEBUG-Modus kompiliert, ignoriert der Compiler die DEBUG-Anweisungen im Programmcode. Sie müssen nicht auskommentiert werden.
• Das Debugging wird aufgerufen mit STRG+D oder über das Hauptmenü mit RUN - Enable Debug.
• Während der Ausführung werden beim Auftreten von DEBUG-Anweisungen Textnachrichten seriell an P62 mit 2 MBaud im 8-N-1-Format gesendet.
• DEBUG-Meldungen beginnen immer mit „CogN“, wobei N die Cognummer ist, gefolgt von zwei Leerzeichen, und sie enden immer mit CR+LF (Zeilenrücksprung und neue Zeile).
• Eine Anwendung darf bis zu 255 DEBUG-Anweisungen enthalten.
• In Spin2 können DEBUG-Anweisungen Ausdrucks- und Variablenwerte, Hub-Byte-/Word-/Long Arrays und Register-Arrays ausgeben.
• In PASM können DEBUG-Anweisungen Registerwerte/Arrays, Hub-Byte/Wort/Long  Arrays und Konstanten ausgeben. PASM-Syntax: impliziertes Register oder # für unmittelbar.
• DEBUG-Ausgangsdaten können als Fließkomma, Dezimal, Hex oder Binär angezeigt und in Byte, Wort, Long oder Auto skaliert werden. Hub-Zeichenfolgen werden ebenfalls unterstützt.
• DEBUG-Ausgabebefehle zeigen sowohl die Quelle als auch den Wert an: „DEBUG(UHEX(x))“ könnte „x = $123“ ausgeben.
• DEBUG-Befehle, die Daten ausgeben, können mehrere durch Komma getrennte Parametersätze haben: SDEC(x,y,z) und LSTR(ptr1,size1,ptr2,size2)
• Komma werden automatisch zwischen Daten ausgegeben: "DEBUG(UHEX_BYTE(d,e,f), SDEC(g))" könnte in der Ausgabe so aussehen: "d = $45, e = $67, f = $89, g = -1_024".
• Alle DEBUG-Ausgabebefehle haben alternative Versionen, die mit „_“ enden und nur den Wert ausgeben: DEBUG(UHEX_BYTE_(d,e,f)) könnte sein: „$45, $67, $89“ .
• DEBUG-Anweisungen können IF()- und IFNOT()-Befehle enthalten, um weitere Ausgaben innerhalb der Anweisung zu steuern. Ein anfängliches IF/IFNOT wird die gesamte Nachricht durchgehen.
• DEBUG-Anweisungen können einen abschließenden DLY(Millisekunden)-Befehl enthalten, um die Nachrichtenübermittlung eines Cogs zu verlangsamen, da Nachrichten mit einer Rate von ~10.000 pro Sekunde gestreamt werden können.
• DEBUG-Anweisungen können PC_KEY()- und PC_MOUSE()-Befehle enthalten, um den Status von Tastatur und Maus des Hosts in DEBUG-Anzeigen zu dokumentieren.

CON-Bezeichner für DEBUG-Oberfläche

In einer ersten Übung machen wir uns mit dem SPIN2 DEBUG-System vertraut.

Übung 1 - Registerinhalte von DIRA und OUTA auslesen

Schaltskizze und Schaltungsaufbau

Das Programm Pinadressierung_REG_A.spin2

Darstellung im DEBUG-Fenster

3 - Die verfügbaren Speicherbereiche in einem Propeller P2 (Theorie)

Jeder der acht Kerne(Cogs) eines Propeller P2 verfügt über einen internen RAM-Bereich. Er wird verwendet, um den Programmcode  auszuführen und Daten unabhängig von den anderen Kernen zu speichern und zu verändern. Dieser interne RAM-Bereich ist in zwei zusammenhängenden Blöcken von je 512 x 32 Bit organisiert:

• Register-RAM, Adressbereich: $00_000 bis $00_1FF mit
• acht Dual-Purpose- ($00_1F0 bis $00_1F7)  und
• acht Spezialregistern ($00_1F8 bis $00_1FF), sowie einem
• Lookup-RAM, Adressbereich: $00_200 bis $00_3FF.

Register-RAM-Bereich

Der 512 x 32-Bit-Dual-Port-Register-RAM-Bereich (kurz: Reg-RAM) jedes Kerns sorgt u.a. für die Programm-Codeausführung und schnellen direkten Registerzugriff. Es wird mit Variablen des Typs  Long (4 Bytes oder 32 Bit) gelesen und beschrieben und enthält Allzweck-, Dual-Purpose- und Spezialregister.

• Allzweck-Register
  Die Register im RAM-Bereich von $000 bis $1EF sind Allzweckregister für Code- und Datennutzung.
• Dual-Purpose-Register
  Die Register im RAM-Bereich von $1F0 bis $1F7 können entweder als Allzweckregister oder als Spezialregister verwendet werden, wenn ihre zugeordneten Funktionen freigegeben sind.
• Spezial-Register
  Die Register im RAM-Bereich von $1F8 bis $1FF geben zugeordneten Zugriff auf acht Spezialregister; unter anderem zu:
• DIRA mit der COG-RAM Adresse $1FA,
  DIRB mit der COG-RAM Adresse $1FB
  OUTA mit der COG-RAM Adresse $1FC 
  OUTB mit der COG-RAM Adresse $1FD
  INA mit der COG-RAM Adresse $1FE
  INB mit der COG-RAM Adresse $1FF.

4 - Einige Formatierungsanweisungen für DEBUG (Theorie)

5 - Wie arbeitet das Programm Pinadressierung_REG_A.spin2 ?

Im CON-Block (Programmzeilen (PZ) 10 - 24) werden die im Programm benutzten Größen mit Werten belegt. Die PZ 13, 17 und 18 beziehen sich bereits auf die Übung 2 und haben in dieser Übung keine Bedeutung.

Für das Richtungs- und Ausgangsregister DIRA und OUTA sind in den PZ 19 und 20 die COG-Adressen im Hex-Format angegeben.

Die Hauptmethode umfasst die PZ 34 bis 56.

Zuerst werden die Pullup-Widerstände für die drei LEDs eingeschaltet (PZ 36).

Anschließend wird der Inhalt des DIRA-Registers im Debug-Fenster im vorzeichenlosen Binärformat ausgegeben (PZ 37) und ein Zeilenrücksprung erfolgt, bevor in PZ 38 die LED an P15 auf HIGH gezogen und eine kurze Pause von 1 sec eingelegt wird.

Auf diese Art und Weise werden nacheinander die drei LEDs ein- und wieder ausgeschaltet und der jeweilige Zustand der Register DIRA und OUTA im Debug-Fenster angezeigt.

6 - Die Darstellung im Debug Output Fenster

Nach dem Start des Programms wird der Spin2 Setup-Code von Kern0 (Cog0) ab der Speicherstelle $00000 geladen.

In Zeile 2 wird der Spin2 Interpreter ab $0_0D8C gestartet, wobei sein Stack-Speicherplatz bei $0_1344 beginnt.

In Zeile 3 wird der Inhalt des 32-Bit Registers DIRA ausgegeben. Dazu muss im Programmcode eine Debug-Anweisung erscheinen:

• debug(u_bin_reg_array(DIR_A,1), 13)

Alle Bits sind auf 0 gesetzt. Nachdem P15 in PZ 38 auf HIGH gezogen wurde, zeigt der nachfolgende Registerinhalt in den Zeilen 4 und 5 für DIRA und OUTA an der 15. Bitstelle jeweils eine 1.

Das LSB ist 0, das MSB ist 31, deshalb entspricht der 15. Bitstelle die 16. Position im Register.

Übung 2 - Registerinhalt OUTA beim Mod 6 Zähler auslesen

Aufgabe

• Im Kapitel I/O Pin - Teil 4 wird in Übung 3 ein Modulo 6 - Zähler aufgebaut und programmiert. Ergänze das Programm in Abb. 10 dort so, dass der Registerinhalt von OUTA im Debug-Fenster angezeigt wird.

Lösung

Im Debug-Fenster sollte die folgende Darstellung angezeigt werden.

DEBUG-Nachrichten können zusätzlich spezielle grafische Anzeigen aufrufen, die in einem  gesonderten Fenster dargestellt werden. Um welche grafischen Anzeigen es sich handelt und wie man sie aufruft wird im folgenden Kapitel beschrieben.