InLine Assembler ARM M0+
Micropython bietet die Möglichkeit InLine Assembler für ARM Cortex M CPU's direkt ins Script zu schreiben. Hier wird dieses Thema am Raspberry Pi Pico erarbeitet.
Bei Thonny funktioniert der Inline Assembler nicht in der REPL! Assembler Code muss in einem Script stehen!
Die CPU des Pico[Bearbeiten | Quelltext bearbeiten]
Der Raspberry Pi Pico enthält 2 ARM Cortex M0+ CPU's.
Für die beiden M0+ CPU's gilt das, was ARM in die M0+ CPU's eingebaut hat. Deshalb wird zuerst das Wichtigste zum M0+ vorgestellt. Dabei wird aber z.T. auch auf Besonderheiten des Micropython Inline Assemblers eingegangen.
Anschließend wird der Micropython Inline Assembler für den M0+, also den Raspberry Pi Pico besprochen.
Schließlich wird auf die Raspberry Pi Pico Besonderheiten eingegangen und einige kleine Programmbeispiele präsentiert.
Das ARM Cortex M0+ Prozessormodell[Bearbeiten | Quelltext bearbeiten]
Der ARM Cortex M0+ besitzt 16 allgemeine Register und 3 Spezialregister.
REGISTER | Bezeichnung |
---|---|
r0 | Low Register
können von allen Befehlen verwendet werden.
|
r1 | |
r2 | |
r3 | |
r4 | |
r5 | |
r6 | |
r7 | |
r8 | High Register
können nur von 32-Bit-Befehlen verwendet werden.
|
r9 | |
r10 | |
r11 | |
r12 | |
r13 | Stack Pointer (MSP/PSP) |
r14 | Link Register (LR) |
r15 | Programm Counter (PC) |
REGISTER | Bezeichnung |
---|---|
xPSR | Kombiniertes Programm Status Register |
PRIMASK | Interrupt Maskierung Spezialregister |
CONTROL | Control Spezialregister |
Hier ist nur das xPSR von interesse. Es enthält u.a. das Application Prozessor Status Register (APSR). Dieses wird für bedingte Sprünge benötigt.
Bit | Flag |
---|---|
31 | N |
30 | Z |
29 | C |
28 | V |
Hier ist nur das Flag und dessen Bedeutung für die Assemblerprogrammierung interessant:
- N
- Wird 1 wenn das Ergebnis negativ ist.
- Z
- Wird 1 wenn das Ergebnis 0 ist.
- C
- Wird bei unsigned Werten 1, wenn ein Überlauf entsteht.
Bei Shift- und Rotate-Befehlen wird ein Bit aus dem Register ins Carry geschoben. - V
- Wird bei signed Werten 1, wenn ein Überlauf entsteht.
Das ARM Cortex M0+ Speichermodell[Bearbeiten | Quelltext bearbeiten]
Die ARM Cortex M Prozessoren können 4 GB Speicher adressieren. Dieser ist in Bereiche für unterschiedliche Verwendungen unterteilt:
Adresse | Verwendung |
---|---|
0xFFFFFFFF | System 0.5GB |
0xE0000000 | |
0xDFFFFFFF | External Device 1GB |
_ | |
_ | |
0xA0000000 | |
0x9FFFFFFF | External RAM 1GB |
_ | |
_ | |
0x60000000 | |
0x5FFFFFFF | Peripherals 0.5GB |
0x40000000 | |
0x3FFFFFFF | SRAM 0.5GB |
0x20000000 | |
0x1FFFFFFF | Code 0.5GB |
0x00000000 |
Stack[Bearbeiten | Quelltext bearbeiten]
Der Stack liegt üblicherweise am oberen Ende des RAM-Bereichs und breitet sich nach unten aus. Der Stackpointer (r13) wird dann mit der letzten Adresse +1 geladen.
Memory Map des Raspberry Pi Pico[Bearbeiten | Quelltext bearbeiten]
Der Befehlssatz des M0+[Bearbeiten | Quelltext bearbeiten]
Die Key features des Cortex-M0+ core sind:
ARMv6-M architecture 2-stage pipeline (one fewer than Cortex-M0) Instruction sets: (same as Cortex-M0) Thumb-1 (most), missing CBZ, CBNZ, IT Thumb-2 (some), only BL, DMB, DSB, ISB, MRS, MSR 32-bit hardware integer multiply with 32-bit result 1 to 32 interrupts, plus NMI
Quelle: https://en.wikipedia.org/wiki/ARM_Cortex-M
Hier geht's zum Befehlssatz des RP2040.
Links:[Bearbeiten | Quelltext bearbeiten]
- https://wordpress-courses1920.wolfware.ncsu.edu/ece-461-001-sprg-2020/wp-content/uploads/sites/106/2020/01/ARM-ISA-and-Cortex-M0.pdf
- https://www.keil.com/dd/docs/datashts/arm/cortex_m0p/r0p0/dui0662a_cortex_m0p_r0p0_dgug.pdf
- https://developer.arm.com/documentation/dui0662/b/The-Cortex-M0--Instruction-Set
- https://developer.arm.com/documentation/dui0662/b/The-Cortex-M0--Instruction-Set/Instruction-set-summary?lang=en
- https://os.mbed.com/media/uploads/4180_1/cortexm0_instructions.htm
InLine Assembler schreiben[Bearbeiten | Quelltext bearbeiten]
Die Schreibweise der Assemblerbefehle in Micropython unterscheidet sich von der der üblichen Assembler. In Micropython werden die Assembler-Befehle als Funktionen eingegeben, um der Python-Syntax zu entsprechen, obwohl MicroPython sie direkt in Assembler kompiliert.
Das Einfügen von Assemblercode in ein Micropythonscript ist ganz einfach. Dem Assemblercode Block muss nur der Dekorator @micropython.asm_thumb voran gestellt werden:
Allerdings funktioniert der Inline Assembler nicht in der REPL! Assembler Code muss in einem Script stehen!
@micropython.asm_thumb def fun(): mov(r0, 42) print(fun())
Die Ausgabe:
>>> %Run -c $EDITOR_CONTENT MPY: soft reboot 42 >>>
Hurra es funktioniert!
Parameter Übergabe[Bearbeiten | Quelltext bearbeiten]
Als Parameter können Integer übergeben werden.
Als Eingangsregister für die Übergabe von Parametern können nur r0 ... r3 benutzt werden:
@micropython.asm_thumb def test(r0, r1, r2, r3, r4): mov(r0, r4) print(test(1,2,3,4,5)) >>> %Run -c $EDITOR_CONTENT MPY: soft reboot Traceback (most recent call last): File "<stdin>", line 2, in test SyntaxError: can only have up to 4 parameters to Thumb assembly >>>
Außerdem müssen die Register in aufsteigender Reihenfolge eingesetzt werden:
@micropython.asm_thumb def test(r1, r0, r2, r3): mov(r0, r4) print(test(1,2,3,4)) >>> %Run -c $EDITOR_CONTENT MPY: soft reboot Traceback (most recent call last): File "<stdin>", line 2, in test SyntaxError: parameters must be registers in sequence r0 to r3 >>>
Beispiel für eine korrekte Anwendung:
@micropython.asm_thumb def test(r0, r1, r2, r3): add(r0, r0, r1) add(r0, r0, r2) add(r0, r0, r3) print(test(1,2,3,4)) >>> %Run -c $EDITOR_CONTENT MPY: soft reboot 10 >>>
Zurückgegeben wird immer der Inhalt von r0.
Es ist nicht möglich Micropython und Assembler in einer Funktion zu mischen.
Einschränkungen des Micropython Inline Assembler[Bearbeiten | Quelltext bearbeiten]
Es gibt keine Befehl um ein Register mit einer 32-Bit Zahl zu laden. Deshalb besitzen Assemblerprogramme den Pseudobefehl LDR. Dieser wird vom Assembler in vorhandene Befehle übersetzt. Beim Micropython Inline Assembler ist dieser Pseudobefehl leider nicht vorhanden:
@micropython.asm_thumb def pseudo(): ldr(r1, 42) ldr(r0, 0x12345678) # unsupported Thumb instruction 'ldr' with 2 arguments
LDR funktioniert nur mit Registern.
https://forum.micropython.org/viewtopic.php?f=21&t=9896
Label funktionieren nur mit Branch-Befehlen[Bearbeiten | Quelltext bearbeiten]
Label werden so erzeugt:
label(label_name)
Der Labelname wird nicht in Anführungszeichen gesetzt. Es ist kein String!
Konstruktionen wie diese:
mov(r0, =label_name)
funktionieren dagegen nicht! Es wird ein Syntaxfehler gemeldet.
.data funktioniert[Bearbeiten | Quelltext bearbeiten]
Im Micropython Inline Assembler werden Data-Zeilen wie folgt geschrieben:
label(my_data) data(4, 0x12345678) data(2, 0x1234)
Mit label wird die Adresse des Datenfeldes erfasst.
Das erste Argument von data gibt die Größe der Zahl in Byte an.
Wie kommen wir nun an die Daten?
mov(r0, =my_data)
funktioniert ja nicht.
Im Internet habe ich dazu folgenden Vorschlag gefunden (https://github.com/orgs/micropython/discussions/12257):
import micropython @micropython.asm_thumb def test_asm() -> uint: align (4) # DO NOT MODIFY mov (r7, pc) # PC points to the table, so does r7 now b (func_entry) # DO NOT MODIFY # embedded table align (4) data (2, 0x1122) # 0 data (2, 0x3344) # 2 data (2, 0x7788) # 4 data (2, 0x5566) # 6 data (4, 0x3abbccdd) # 8 four byte data (only with two upper bits cleared) data (4, 0x3fffffff) # 12 that's the maximum align (2) label (func_entry) # ldrb (r0, [r7, 0]) # gets 0x22 into r0 # ldrb (r0, [r7, 1]) # gets 0x11 into r0 # ldrh (r0, [r7, 0]) # gets 0x1122 into r0 # ldrh (r0, [r7, 2]) # gets 0x3344 into r0 # ldr (r0, [r7, 0]) # gets 0x33441122 into r0 ldr (r0, [r7, 4]) # gets 0x55667788 into r0 # ldr (r0, [r7, 8]) # gets 0x3abbccdd into r0 # ldr (r0, [r7,12]) # gets 0x3fffffff into r0 # when fuction returns, r0 is the return value rc = test_asm() print(f'rc = 0x{rc:0x}')
Hier wird kein Label angelegt, der hilft uns ja nicht weiter.
Statt dessen wird in der Speicherzugriff auf Wordgröße ausgerichtet,
der Programmzähler in r7 geladen
und dann das Datenfeld übersprungen und das eigentliche Programm abgearbeitet.
Nun haben wir einen Zeiger auf den Anfang unserer Daten in r7.
Dann folgen die Daten - Der RP2040 arbeitet mit little Endian.
Schließlich sind verschiedene Möglichkeiten des Zugriffs über den Offset in Byte-, Halbword- und Wordlänge demonstriert.
Datenaustausch über Array[Bearbeiten | Quelltext bearbeiten]
32-bit Werte in Array tun und die Array-Adresse als Parameter an die Funktion übergeben.
Raspberry Pi Pico GPIO Programmierung[Bearbeiten | Quelltext bearbeiten]
Die GPIO's des Pico sind alle in 32-bit-Registern zusammengefasst.
Es gibt folgende Register zum Umgang mit den GPIO's:
- GPIO_OUT
- Setzt den Ausgangspegel der GPIO's.
- GPIO_OE
- Aktiviert den Ausgangstreiber der GPIO's. 0 = hochohmig, 1 = Ausgang aktiv.
- GPIO_IN
- Enthält den aktuellen Status der GPIO's.
Links:[Bearbeiten | Quelltext bearbeiten]
- https://docs.micropython.org/en/latest/reference/asm_thumb2_index.html
- Hier ist die offizelle Micropython Thumb2 Inline Assembler Dokumentation
- https://smist08.wordpress.com/2022/02/18/adding-assembly-language-to-micropython/
- https://github.com/orgs/micropython/discussions/10401
- https://docs.micropython.org/en/v1.9.3/pyboard/pyboard/tutorial/assembler.html
- https://docs.micropython.org/en/latest/reference/asm_thumb2_hints_tips.html
- https://forum.micropython.org/viewtopic.php?t=9896
- https://docs.micropython.org/en/v1.9.3/pyboard/reference/asm_thumb2_index.html#asm-thumb2-index
- https://www.mikrocontroller.net/topic/515210
- https://ioprog.com/2022/11/21/speeding-up-some-micropython-with-a-touch-of-inline-assembly-on-the-raspberry-pi-pico/
- https://developer.arm.com/documentation/ddi0484/b/Programmers-Model/Processor-core-registers-summary
- https://en.wikipedia.org/wiki/ARM_architecture_family
- https://developer.arm.com/documentation/ddi0486/b/?lang=en
- https://developer.arm.com/documentation/dui0662/b
- https://docs.micropython.org/en/latest/reference/asm_thumb2_hints_tips.html#
- https://forum.micropython.org/viewtopic.php?f=21&t=12931&sid=25de8871fa9cfcf8cafb6318f9d8ba3a
- https://github.com/orgs/micropython/discussions/12257
- https://forums.raspberrypi.com/viewtopic.php?t=344701
- https://people.ece.cornell.edu/land/courses/ece4760/RP2040/index_rp2040_Micropython.html
- https://www.youtube.com/watch?v=G64GegkxW84
- https://www.youtube.com/watch?v=FV6P5eRmMh8
- https://awesome-micropython.com/
- https://docs.micropython.org/en/v1.9.3/pyboard/reference/asm_thumb2_str.html
- https://docs.micropython.org/en/v1.9.3/pyboard/reference/asm_thumb2_mov.html
- https://docs.micropython.org/en/v1.9.3/pyboard/reference/asm_thumb2_directives.html
- https://docs.micropython.org/en/v1.9.3/pyboard/reference/asm_thumb2_misc.html
- https://docs.micropython.org/en/v1.9.3/pyboard/reference/asm_thumb2_ldr.html
- https://docs.micropython.org/en/v1.9.3/pyboard/reference/asm_thumb2_index.html#asm-thumb2-index
- https://docs.micropython.org/en/v1.9.3/pyboard/pyboard/tutorial/assembler.html#
- https://www.codeinsideout.com/blog/stm32/intro/#stm32-microcontrollers
- https://lorenz-ruprecht.at/docu/pico-sdk/1.4.0/html/modules.html
- https://lorenz-ruprecht.at/docu/pico-sdk/1.4.0/html/group__hardware__gpio.html#gaacde9174277ca40aa7b6fdd341bb2b8c
- https://lorenz-ruprecht.at/docu/pico-sdk/1.4.0/html/group__hardware__base.html
[Bearbeiten | Quelltext bearbeiten]
zurück zu Micropython_Kurs_2025
zurück zu Kurse
Zurück zur Hauptseite