Programowanie STM32L4 w asm (CubeIDE)

[ReniferRudolf]

Interesuje mnie najlepsza ścieżka postępowania w środowisku CubeIDE, aby tworzyć i debugować proste projekty w assemblerze. Jeśli taka wiedza jest na forum 🙂, to będę wdzięczy za jakieś (wystarczą całkiem ogólne) inspiracje. Być może powinienem użyć innych środowisk/narzędzi?

PS.
Na razie po wstępnym szybkim przejrzeniu forum st.com znalazłem pewien bardzo konkretny przykład postępowania w CubeIDE, jednak dla nieco innej płytki (F446RE): https://community.st.com/s/question/0D53W00001cGGtBSAW/how-to-run-assembly-code-in-stm32-cube-ide-nucleo-f446re

W projekcie w języku C znajduje się wyłącznie funkcja main() użytkownika nie zawierająca nic poza wywołaniem procedury assemblerowej. Zaś procedura assemblerowa zawiera (!!) jakiś kluczowy kod inicjalizacyjny. Jeszcze tego nie wiem, ale zakładam, że ten kod inicjalizacyjny to jest właśnie absolutnie minimalna konfiguracja rejestrów, tak aby ARM core na płytce w ogóle podjął wykonywanie instrukcji (z opisu wynika, że to jest przykład projekt w "czystym" assemblerze, czyli taki który zadziała bez jakiekolwiek dodatkowego kodu dodawanego przez środowisko CubeIDE).

[Treker (Damian Szymański)]

@ReniferRudolf witam na forum! Osobiście w tej w kwestii nic nie podpowiem, może @Elvis będzie mógł coś podpowiedzieć 😉 

Zapytam tylko z ciekawości - dlaczego assembler? Już dawno nie słyszałem, aby ktoś podczas nauki nowej rodziny mikrokontrolerów zaczynał w asm. Nie lepiej zacząć chociaż od bibliotek Low Layer, jeśli HAL całkiem odpada?

[ReniferRudolf]

3 godziny temu, Treker napisał:

Zapytam tylko z ciekawości - dlaczego assembler? Już dawno nie słyszałem, aby ktoś podczas nauki nowej rodziny mikrokontrolerów zaczynał w asm. Nie lepiej zacząć chociaż od bibliotek Low Layer, jeśli HAL całkiem odpada?

Jasne - jeśli chodzi o przerobienie kursu, naukę mikrokontrolera z całym otoczeniem, realizację własnych projektów itp. - oczywiście wyborem jest język C. Natomiast chciałbym mieć środowisko do poćwiczenia/przypomnienia sobie programowania w architekturze ARM (robiłem te rzeczy lata temu...), to może mi się przydać w przyszłości w jakiś niszowych zastosowaniach. Chciałbym więc do tego teraz wrócić mając na biurku procesor ARM, do którego mógłbym wgrać sobie dowolny kod bez żadnych "otoczek".

[Elvis]

Jak chodzi o naukę asemblera to chyba najłatwiej zacząć od projektu wygenerowanego przez CubeMX i do kodu w C dodawać własne wstawki asemblerowe.

Niejako kolejny krok to utworzenie własnego, oddzielnego pliku źródłowego - to zostało opisane w podlinkowanym artykule (https://stcommunity.st.com/t5/stm32cubeide-mcu/how-to-run-assembly-code-in-stm32-cube-ide-nucleo-f446re/m-p/139119)

Natomiast jeśli motywacją jest pozbycie się otoczek to proponuję zacząć od pozbycia się CubeIDE. Program w asm można sobie pisać w notatniku, kompilować z linii poleceń i uruchamiać za pomocą gdb.

[Polecacz 101]

Produkcja i montaż PCB - wybierz sprawdzone PCBWay!
   • Darmowe płytki dla studentów i projektów non-profit
   • Tylko 5$ za 10 prototypów PCB w 24 godziny
   • Usługa projektowania PCB na zlecenie
   • Montaż PCB od 30$ + bezpłatna dostawa i szablony
   • Darmowe narzędzie do podglądu plików Gerber
Zobacz również » Film z fabryki PCBWay

[virtualny]

No nie mogę się powstrzymać żeby nie napisać jako wielki miłośnik assemblera.

 

Na początek link do mojego repo w ASM - black pill mruganie diodą plus co każdy reset naprzemiennie program się przepisuje i uruchamia się z ROM albo RAM... Jak poszukasz to i wersję dla bluepill'a znajdziesz.

https://github.com/wegi1/BLACK_PILL_RAM_BLINK_EXECUTE

 

/******************************************************
 * @file      startup_stm32f401cdux.s
 * BLACK PILL LED BLINKING IN ASSEMBLER 52 BYTES LONG
 *******************************************************/

// A FEW DEFINITIONS


#define TOP_OF_STACK              0x20000700
#define CHECK_BYTE                0x20000710

#define RCC_AHB1_ADDR             0x40023800
#define RCC_AHB1_EN_OFFSET        0x30
#define ENABLE_GPIOC_VALUE        0x04

#define GPIOC_MODER_REG_ADDR      0x40020800
#define GPIOC_PUPDR_REG_OFFSET    0x0C
#define GPIOC_ODR_REG_OFFSET      0x14
#define BIT_13_REGVALUE_SETUP     (1UL << 26)
#define BIT_13_VALUE              (1UL << 13)

#define ROM_START                 0x08000000
#define RAM_START                 0x20000000
#define PROGRAM_LENGTH            END_LOOP - ROM_START

#define RAMCODE2                  ram_code - ROM_START

#define RAM_CODE_2                RAMCODE2 + RAM_START +1 // thumb MODE --> +1


#define COUNTER_DELAY_OFFSET      0x08
#define RCC_ADDR_OFFSET           0x0C
#define RAM_START_OFFSET          0x10
#define PROGRAM_LENGTH_OFFSET     0x14
#define RAM_CODE_OFFSET           0x18
#define ROM_START_OFFSET          0x1C
#define CHECK_BYTE_OFFSET         0x20

/******************************************************************************
*  VECTORS
******************************************************************************/
// ARM ASSEMBLER ATTRIBUTES
.syntax unified
.cpu cortex-m4
/*********************************************************************
*  VECTORS SECTION START
**********************************************************************/
  .section .vector_table

  .word TOP_OF_STACK            // DOESN'T MATTER WE DON'T USE STACK HERE
  .word Reset_Handler           // RESET HANDLER VECTOR


  .word 500000                  // counter delay value for ROM execute
  .word RCC_AHB1_ADDR           // BASE ADDRESS OF RCC
  .word RAM_START               // 0x20000000
  .word PROGRAM_LENGTH          // length of program
  .word RAM_CODE_2              // start addres in ram
  .word ROM_START               // = 0x08000000
  .word CHECK_BYTE              // = 0x20000710 indicator to run program after reset in ROM or RAM

/*********************************************************************
*  VECTORS END
**********************************************************************/

  .thumb_func
  .text
/***********************************************************
* RESET CODE - BLINKING LED PC13
********************************************************************/


Reset_Handler:

  mov  r7, 0x08000000                          // * [r7 = 0x08000000] --> [VECTOR TABLE START ADDRESS]

  // init values in registers to copy data from FLASH into RAM
  ldr  r0, [R7, #RAM_START_OFFSET]             // * [r0 = 0x20000000] --> = RAM_START
  ldr  r1, [R7, #PROGRAM_LENGTH_OFFSET]        // * how many bytes to copy into RAM
  ldr  r2, [R7, #ROM_START_OFFSET]             // r2 = 0x08000000 --> start of ROM
  movs r3, #0                                  // r3 = 0 = initial value to count copied bytes


Copy_Data:
  ldr  r4, [r2, r3]                             // copy 32bit word from ROM
  str  r4, [r0, r3]                             // and store this 32bit word into RAM
  adds r3, r3, #4                              // count copied bytes
  cmp  r3, r1                                   // compare copied bytes with length of program
  bcc  Copy_Data                                // test

  ldr  r4, [r7, #COUNTER_DELAY_OFFSET]          // r4 = 500000
  lsr  r4, 2                                    // r4 = 500000/4 = 125000
  str  r4, [r0, #COUNTER_DELAY_OFFSET]          // store in RAM lower value for faster led blinking


  ldr  r5, [R0, #RAM_CODE_OFFSET]               // R5 = start addres in RAM

  ldr  r4, [R2, #CHECK_BYTE_OFFSET]             // our control byte address
  ldr  r3, [r4]                                 // get our control byte into r3 from RAM
  eor  r3, #0x01                                // toggle lowest bit
  ands r3, #0x01                                // check lowest bit to execute place
  str  r3, [r4]                                 // store our check byte after change

  beq  ram_code    // if 0 go to flash execute, if 1 = RAM execute

  mov  pc, r5                                   // GO TO RAM EXECUTE !!!

//****************************************************************************************************/

/* 1. ENABLE RCC CLOCK FOR GPIOC (0x40023830 ADDRESS) */
/* 2. SET GPIOC BIT 13 TO OUTPUT  IN GPIOC->MODER REGISTER (0x40020800  ADDRESS) */
/* 3. SET GPIOC BIT 13 AS PULL UP IN GPIOC->PUPDR REGISTER (0x4002080C  ADDRESS) */
/* 4. TOGGLE BIT 13 IN GPIOC->ODR REGISTER (0x40020814  ADDRESS)  */
/* 5. A SMALL DELAY LOOP */
/* 6. GO BACK TO TOGGLE BIT 13 IN GPIOC->ODR REGISTER */


ram_code:
  mov  r7, pc                                  // check program counter where is - in RAM or ROM?
  and r7, 0x28000000                           // and make ADDRES to DATA_TABLES now we got
                                               // R7 = RAM or ROM START ADDRESS 0x20000000 or 0x08000000

//**********************************************************************************************************

/* 1. ENABLE RCC CLOCK FOR GPIOC (0x40023830 ADDRESS) */

  LDR    R0, [R7, #RCC_ADDR_OFFSET]           // R0 = RCC_AHB1_BASE_ADDRES (R7 = 0x08000000 or 0x20000000)  12 = RCC_AHB1_BASE_ADDRES
  LDR    R1, [R0, #RCC_AHB1_EN_OFFSET]        // R1 = RCC_AHB1_EN VALUE
  ORR.W  R1,  R1, #ENABLE_GPIOC_VALUE         // ENABLE GPIOC
  STR    R1, [R0, #RCC_AHB1_EN_OFFSET]        // STORE NEW VALUE WITH GPIOC RUNNING CLK

/* 2. SET GPIOC BIT 13 TO OUTPUT  IN GPIOC->MODER REGISTER (0x40020800  ADDRESS) */
/* 3. SET GPIOC BIT 13 AS PULL UP IN GPIOC->PUPDR REGISTER (0x4002080C  ADDRESS) */
  MOV    R1, BIT_13_REGVALUE_SETUP            // R1 = 0x04000000
  SUB    R0, 0x3000                           // 2 BYTEST SHORT INSTEAD "LDR    R0, =GPIOC_MODER_REG_ADDR"
  STR    R1, [R0]                             // INITIAL VALUE GPIOC_MODER_REGISTER = BIT13 SET TO OUTPUT
  STR    R1, [R0, #GPIOC_PUPDR_REG_OFFSET]    // INITIAL VALUE GPIOC_PUPDR_REGISTER = BIT13 PULL_UP

  //LDR    R1, [R0, #GPIOC_ODR_REG_OFFSET]    // UNNEECESSARY

LOOP01:
/* 4. TOGGLE BIT 13 IN GPIOC->ODR REGISTER (0x40020814  ADDRESS)  */
  EOR.W  R1,  R1,BIT_13_VALUE                 // TOGGLE BIT 13
  STR    R1, [R0, #GPIOC_ODR_REG_OFFSET]      // STORE VALUE WITH TOGGLED BIT 13 INTO GPIOC_ODR_REGISTER

  LDR R2, [R7, #COUNTER_DELAY_OFFSET]         // SIMPLE DELAY LOOP  R2 = 500000 or 500000/4


LOOP02:

/* 5. A SMALL DELAY LOOP */
  SUBS   R2,#1                                // DECREMENT REGISTER WITH FLAGS UPDATE (ZERO FLAG WE USED)
  BNE    LOOP02                               // REGISTER NOT 0? SO STILL DECREMENT

/* 6. GO BACK TO TOGGLE BIT 13 IN GPIOC->ODR REGISTER */
  BEQ    LOOP01
END_LOOP:                         // DELAY END GO BACK TO BLINKING LOOP
/*****END OF FILE****/

 

Jeżeli chcesz pisa w ASM, najwygodniej oferuje to KEIL i do 32KB kodu jest darmowy, a na asm 32KB to dość sporo. Jeżeli wybierasz CubeIDE,  i  w ogóle STM'y to masz szczęście, że ST jeszcze nie odpłynęło tak daleko jak co niektórzy i startupy mają napisane w ASM a nie w C. Generalnie jest to dość proste - dodajesz do plików swój plik z rozszerzeniem "s" i w nim piszesz swoje procedury. Kursów asm - odradzam na UDemy wszystkie kursy z udziałem Israel Gbati, są niepokończone, poprzerywane i z błędami. Książka o ASM sympatyzująca z Keilem to wydawnictwa Helion William Wohl "Asembler dla procesorów ARM podręcznik programisty"

Listę opcodów znajdziesz wszędzie.

Stronę mogę polecić Azeria LABS:
https://azeria-labs.com/writing-arm-assembly-part-1/

 

Kran Nayak - na jego kanale YT  znajdziesz dobre filmy jak gadać z linkerem, jak deassemblować kolejne pliki obiektowe, jak kompilować i dekompilować. Za każdy jego kurs na UDemy mogę ręczyć że jest znakomity.

Musisz się nauczyć czy przypomnieć sobie jak pisać w ASM, jakie używać dyrektywy dla CM no i wielka pułapka, to THUMB - wszędzie w skokach musisz dodawać 1, żeby był adres nieparzysty, no i przestrzegać takich właśnie sztuczek z dopełnianiem bajtów do modulo 4 czy stosu mod8. ..

 

Dla miłośników C - podam przykład jak kompilator tworzy kod, który najnormalniej w świecie jest i będzie nieoptymalny. Każdy kto zna assembler, jak zobaczy ten kod stwierdzi, że nikt dobrze programujący nie mógł napisać czegoś takiego. Oto przykład krytycznej czasowo procedury przełączania kontekstu w MI-ROS MiroSamek RealTime Operating System (Quantum Leap, LLC youtube - bardzo dobry kurs embedded) - utworzonej przez kompilator:

   /* __disable_irq(); */
    CPSID         I

    /* if (OS_curr != (OSThread *)0) { */
1.  LDR           r1,=OS_curr
2.  LDR           r1,[r1,#0x00]
3.  CBZ           r1,PendSV_restore

    /*     push registers r4-r11 on the stack */
    PUSH          {r4-r11}       // just added by MMS and that's way this function was recreated to assembler

    /*     OS_curr->sp = sp; */
4.  LDR           r1,=OS_curr    // !!! oversize code and wasting time - the pointer to OS_curr was load into register a few codelines before
5.  LDR           r1,[r1,#0x00]  // !!! oversize code and wasting time - variable OS_curr was load into register a few codelines before
6.  STR           sp,[r1,#0x00]
    /* } */

PendSV_restore
    /* sp = OS_next->sp; */
7.  LDR           r1,=OS_next
8.  LDR           r1,[r1,#0x00]
9.  LDR           sp,[r1,#0x00]

    /* OS_curr = OS_next; */
10. LDR           r1,=OS_next    // !!! oversize code and wasting time - the pointer to OS_next was load into register a few codelines before
11. LDR           r1,[r1,#0x00]  // !!! oversize code and wasting time - variable OS_next was load into register a few codelines before
12. LDR           r2,=OS_curr    // !!! oversize code and wasting time - the pointer to OS_curr was load into register a few codelines before
13. STR           r1,[r2,#0x00]

    /* pop registers r4-r11 */
    POP           {r4-r11}      // just added by MMS and that's way this function was recreated to assembler

    /* __enable_irq(); */
    CPSIE         I

    /* return to the next thread */
    BX            lr

A to działająca wersja poprawiona, z uwagami co było źle. Przypominam, że nie jest to jakaś inicjalizacja wywoływana na starcie programu, tylko wywoływana 1000 razy na sekundę procedura przełączania wątków.

__asm

void PendSV_Handler(void)

{ IMPORT OS_curr /* extern variable */

IMPORT OS_next /* extern variable */

//r0 = &OS_curr

//r1 = OS_curr

//r2 = &OS_next

//r3 = OS_next

/* __disable_irq(); */

CPSID I

/* if (OS_curr != (OSThread *)0) */

LDR r0,=OS_curr

LDR r1,[r0,#0x00]

CBZ r1,PendSV_restore

/* push register r4-r11 on the stack */

PUSH {r4-r11}

/* OS_curr->sp = sp; */

STR sp,[r1,#0x00]

PendSV_restore

/* sp = OS_next->sp; */

LDR r2,=OS_next

LDR r3,[r2,#0x00]

LDR sp,[r3,#0x00]

/* pop register r4-r11 */

POP {r4-r11}

/* OS_curr = OS_next; */

STR r3,[r0,#0x00]

/* __enable_irq(); */

CPSIE I BX lr

}

PendSV_Handler

Podana oryginalna procedura nie jest jakimś wyjątkiem - tak działa i "myśli" kompilator. 

Edytowano Czerwiec 19, 2023 przez virtualny

[ReniferRudolf]

W tej chwili najbardziej interesujący dla mnie jest wybór środowiska / zestawu narzędzi, z którym jako "targetu" do programowania i debugowania będę mógł używać płytki STM.

Zgrubsza widzę już z powyższych odpowiedzi kilka możliwych ścieżek, które będę za jakiś czas sprawdzał / wdrażał. Z całą pewnością na początku zastosuję ten sposób (z wykorzystaniem CubeIDE i standardowego projektu w C):

3 godziny temu, virtualny napisał:

Generalnie jest to dość proste - dodajesz do plików swój plik z rozszerzeniem "s" i w nim piszesz swoje procedury.

 

Edytowano Czerwiec 19, 2023 przez ReniferRudolf

[virtualny]

Dodam, że KEIL i EWARM mają niebagatelny ficzer, którego nie ma w CubeIDE. Jest to symulator ARM. Peryferiów chyba nie wyemulują, ale kod krok po kroku ze śledzeniem flag bardzo dobrze. Jeżeli naprawdę chcesz tylko pisać w ASM, to najbardziej przyjazny będzie KEIL - tam nawet nie musisz plików assemblera tworzyć, wystarczy w pliku C dyrektywa "__asm" jak widać powyżej. W GCC pisanie z dyrektywą ASM w plikach C wygląda jak dowcip, czy utrudnienie, żeby każdą jedną linię umieszczać w cudzysłowiu... Albo każdą linię budować w taki sposób:

__ASM volatile ("cpsid i" : : : "memory");

Szkoda czasu i nerwów. No i musisz pamiętać wszystkie assemblerowe niuanse jak eksportować zmienną, procedurę, określić składnię, rdzeń itp.

  .syntax unified
  .cpu cortex-m3
  .fpu softvfp
  .thumb

.global g_pfnVectors
.global Default_Handler

/* start address for the initialization values of the .data section.
defined in linker script */
.word _sidata
/* start address for the .data section. defined in linker script */
.word _sdata
/* end address for the .data section. defined in linker script */
.word _edata
/* start address for the .bss section. defined in linker script */
.word _sbss
/* end address for the .bss section. defined in linker script */
.word _ebss

.equ  BootRAM, 0xF108F85F
/**
 * @brief  This is the code that gets called when the processor first
 *          starts execution following a reset event. Only the absolutely
 *          necessary set is performed, after which the application
 *          supplied main() routine is called.
 * @param  None
 * @retval : None
*/

  .section .text.Reset_Handler
  .weak Reset_Handler
  .type Reset_Handler, %function
Reset_Handler:

 

[ReniferRudolf]

Zrobiłem trochę eksperymentów, które pozwoliły zorientować się, co gdzie można znaleźć w obszernej dokumentacji, w środowisku CubeIDE, w generowanym kodzie itp. Kilka wniosków, gdyby ktoś chciał bawić się w uruchamianie na Nucleo-L476R kodu w assemblerze.

1. Odnośnie znalezionego wcześniej przykładu:

Dnia 16.06.2023 o 15:59, ReniferRudolf napisał:

Na razie po wstępnym szybkim przejrzeniu forum st.com znalazłem pewien bardzo konkretny przykład postępowania w CubeIDE, jednak dla nieco innej płytki (F446RE): https://community.st.com/s/question/0D53W00001cGGtBSAW/how-to-run-assembly-code-in-stm32-cube-ide-nucleo-f446re
 

Przykład w tym linku jest zgrubną ilustracją ogólnej idei, jak utworzyć projekt assembler w CubeIDE. Natomiast treść kodu w ASM w tym przykładzie nie jest ani poprawna (inicjalizacja clock-ów) ani kompletna (wycięte fragmenty), aby na płytce Nucleo-L476R uruchomić mruganie wbudowaną diodą, tak że proszę nie tracić czasu na wklejanie go do swoich projektów. 

2. Domyślne wartości rejestrów mikrokontrolera po sygnale Reset nie wymagają żadnej zmiany, aby Core pobierał i wykonywał kolejne rozkazy z pamięci. Jest to w sumie dość logiczne... Jeżeli utworzymy nowy pusty projekt w CubeIDE, to śledząc debuggerem funkcje HAL_Init() i SystemClock_Config() zobaczymy, że wprawdzie zapisują one kilka rejestrów związanych z konfiguracją linii zegarowych, ale zapisywane wartości są identyczne z wartościami po Resecie, albo nie dotyczą działania podstawowych podsystemów mikrokontrolera, więc można je pominąć z całą pewnością w programach typu Hello World.

Odpada więc w zasadzie pytanie o potrzebę jakiejś "ogólnej" inicjalizacji w ASM podstawowego systemu mikrokontrolera. 

3. Interesujący jest rzut oka na zawartość pliku Core/Startup/startup_xxxx.s, który jest linkowany z każdym projektem w języku C. Ten plik startup_xxxx.s zawiera de facto pierwsze instrukcje, które Core wykona natychmiast po włączeniu zasilania, jeszcze przed funkcją main(). Jest to między innymi: inicjalizacja wskaźnika stosu (SP), ustawienie domyślnej "procedury obsługi" dla wszystkich ewentualnych przerwań (po prostu... pętla nieskończona, aby złapać w debuggerze stan programu) oraz oczywiście skok do funkcji main().

Z tego kodu możemy (najpewniej, choć nie sprawdzałem, czy trzeba coś zmienić przy budowaniu projektu etc.) skoczyć bezpośrednio do początku naszego kodu w ASM. Albo możemy zastosować prostą sztuczkę opisaną w p. 1 - czyli wyciąć WSZYSTKO, co CubeIDE wygeneruje w pliku main.c i umieścić w funkcji main() wywołanie naszej funkcji zaimplementowanej w ASM.

Załączony poniżej kod zawiera dwa "punkty wejścia", czyli globalnie widoczne etykiety, które nazwałem sobie ASM_Init oraz ASM_Function i które mogą być wywoływane jako funkcje z main.c. Poniższy kod uruchamia się i działa prawidłowo na płytce Nucleo-L476R dołączonej do kursu - zapala i gasi diodę podłączoną do pinu PA oznaczonego stałą PIN_NUM (dla wbudowanej diody LD2 trzeba ustawić "5").

/*
 * assembler.s
 *
 */

  .syntax unified

  .text
  .global ASM_Init
  .global ASM_Function
  .thumb_func

  .equ  RCC_BASE_ADDR,  0x40021000
  .equ  o_RCC_CR,       0x00
  .equ  o_RCC_AHB2ENR,  0x4C
  .equ AHB2ENR_GPIOAEN, 0x01

  .equ  PIN_NUM,       11                              // GPIO-A pin number
  .equ  GPIO_BASE_ADDR,   0x48000000
  .equ  o_GPIOA_ODR,      0x14
  .equ  o_GPIOA_MODER,    0x00
  .equ  MODER_PINMODE_OUTPUT,   1 << (PIN_NUM * 2)     // value for bits[2*PIN_NUM+1 : 2*PIN_NUM]
  .equ  MODER_PINMODE_MASK,    ~(3 << (PIN_NUM * 2))   // mask for bits[2*PIN_NUM+1 : 2*PIN_NUM]

  .equ  COUNTER_ON,        300000    // period of delay for output high state
  .equ  COUNTER_OFF,       300000    // period of delay for output low state

ASM_Init:
  // Enable GPIO port A clock; RCC_AHB2ENR reg, Bit 0 (GPIOAEN) = 1
  ldr r1, =RCC_BASE_ADDR
  ldr r0, [r1, o_RCC_AHB2ENR]
  orr r0, AHB2ENR_GPIOAEN
  str r0, [r1, o_RCC_AHB2ENR]
  ldr r0, [r1, o_RCC_AHB2ENR]      // delay after writing AHB2ENR

  // Set GPIO port A pin X as output; GPIOA_ODR reg
  ldr r1, =GPIO_BASE_ADDR
  ldr r0, [r1, o_GPIOA_MODER]
  and r0, MODER_PINMODE_MASK
  orr r0, MODER_PINMODE_OUTPUT
  str r0, [r1, o_GPIOA_MODER]

  bx lr   // Return from function

ASM_Function:
  ldr r0, [r1, o_GPIOA_ODR]

turn_ON:
  // Set GPIO pin high and delay
  orr r0, 1 << PIN_NUM
  str r0, [r1, o_GPIOA_ODR]
  ldr r2, =COUNTER_ON
  bl delay

turn_OFF:
  // Set GPIO pin low and delay
  and r0, ~(1 << PIN_NUM)
  str r0, [r1, o_GPIOA_ODR]
  ldr r2, =COUNTER_OFF
  bl delay

  b turn_ON   // Never-ending loop

delay:    // r2 contains the delay counter
  subs r2, r2, #1
  bne delay
  bx lr

 

Edytowano Lipiec 5, 2023 przez ReniferRudolf

[virtualny]

Przykład odejmowania w ASM liczb 64 bitowych:


 

;r0 11 lsw of 1st 64bit number
;r1 22 msw of 1st 64bit number
;r2 ab lsw of 2nd 64bit number
;r3 cd  msw of 2nd 64bit number


subs r4, r0, r2      ; First subtract the lsb's and update cpsr      ; r4 = r0 - r2
sbc r5, r1, r3      ; Now subtract the msb's                                ; r5 = r1 - r3 - ~C

 

Poniżej 3 procedury, pierwsza mnożenie dwóch 32 bitowych liczb z wynikiem 64bit, oraz 2 osobne procedury dzielenia liczby 32 bitowej przez 16 bitowe (dla poprawnego działania 16bit).

 

Stack_Size      EQU     0x00000400

                AREA    STACK, NOINIT, READWRITE, ALIGN=3
Stack_Mem       SPACE   Stack_Size
__initial_sp


; <h> Heap Configuration
;   <o>  Heap Size (in Bytes) <0x0-0xFFFFFFFF:8>
; </h>

Heap_Size       EQU     0x00000200

                AREA    HEAP, NOINIT, READWRITE, ALIGN=3
__heap_base
Heap_Mem        SPACE   Heap_Size
__heap_limit

                PRESERVE8
                THUMB


; Vector Table Mapped to Address 0 at Reset
                AREA    RESET, DATA, READONLY
                EXPORT  __Vectors
                EXPORT  __Vectors_End
                EXPORT  __Vectors_Size

__Vectors       DCD     __initial_sp               ; Top of Stack
                DCD     Reset_Handler              ; Reset Handler

__Vectors_End

__Vectors_Size  EQU  __Vectors_End - __Vectors

                AREA    |.text|, CODE, READONLY

; Reset handler
Reset_Handler    PROC
                 EXPORT  Reset_Handler             [WEAK]


;***********************************************************
var_lo      RN 0 
var_hi      RN 1
var3        RN 2
cnt_lop     RN 3


           MOV R0, #1

           LDR var_lo, = 0xFFFFCCCC
           LDR var3,   = 0xCCCCFFFF
           
           SUB var_hi, var_hi, var_hi
           MOV  cnt_lop, #33
           CMP  cnt_lop, #44
           
mul_lop           
           BCC  mul32_ror
           
           ADDS var_hi, var_hi, var3

mul32_ror           
           RRXS  var_hi, var_hi
           RRXS  var_lo, var_lo
           
           MRS r4, APSR
           
           
           SUBS cnt_lop, cnt_lop, #1;
           BEQ end_m32        

           MSR  APSR, r4
           B mul_lop
           
end_m32
           
           
           NOP
           
           

;***********************************************************

; $Bot — Rejestr zawierajacy DZIELNIK.
; $Top — Rejestr, w którym przechowywana jest DZIELNA przed wykonaniem instrukcji. Po wykonaniu instrukcji przechowuje reszte.
; $Div - Rejestr, w którym umieszczony jest iloraz dzielenia. Moze to byc NULL (""), jesli wymagana jest tylko reszta.
; $Temp - Rejestr tymczasowy uzywany podczas obliczen.


Top      RN 5 ; DZIELNA NA KONCU RESZTA
Bot      RN 4 ; DIVISOR - DZIELNIK
Div      RN 0 ; REMAINDER OF QUOTIENT RESZTA Z DZIELENIA
Temp     RN 2 ; TEMPORARY VALUE

        LDR Top, =0xFFFFFFF6
        MOV Bot, #0x0A

        MOV     Temp, Bot              ; Put divisor in $Temp
        CMP     Temp, Top, LSR #1      ; double it until
LPX0    
        MOVLS   Temp, Temp, LSL #1   ; 2 * $Temp > $Top
        CMP     Temp, Top, LSR #1
        BLS     LPX0                   ; The b means search backwards

        MOV Div, #0                    ; Initialize quotient

LPX1    CMP     Top, Temp         ; Can we subtract $Temp?
        SUBCS   Top, Top, Temp    ; If we can, do so is null
        ADC     Div, Div, Div  ; Double $Div
        MOV     Temp, Temp, LSR #1  ; Halve $Temp,
        CMP     Temp, Bot           ; and loop until
        BHS     LPX1                  ; less than divisor
        
;***************************************************************

         
VAR1        RN 0 ;DZIELNA 
VAR2        RN 1 ;DZIELNIK
MOD10       RN 2 ;
LC          RN 3 ;


         LDR VAR1, = 0xFFFFFFF6 
        MOV VAR2, #0xFFFA
        MOV MOD10, #0
        MOV LC, #32
        
LP01
        LSLS    VAR1, #1
        LSL     MOD10, #1
        RRX     MOD10, MOD10
        ROR     MOD10, MOD10, #31
        CMP     MOD10, VAR2
        BCC     LP02
        ORR     VAR1, #1
        SUB     MOD10, MOD10, VAR2
LP02
        SUBS LC, LC, #1;
        BNE LP01

LOOP
        B        LOOP

        ENDP

 

Jeżeli chodzi o dzielenie, to ARM ma już własne rozkazy dzielenia dla 32 bitowych liczb, natomiast bardziej interesujące było to po prostu zrobienie tego "na piechotę, w sposób jaki rozszerzało się arytmetyką procesorów 8 bit. Do tego znalazłem 2 różne algorytmy dzielenia i musiałem sprawdzić, czy obydwa działają (tak - działają!). Bardzo pouczające i pomocne jest obserwowanie działania znaczników i zawartości poszczególnych rejestrów procesora - sprawdzałem to w KEIL ARM simulator. Poniżej widok debugu w KEIL:

[virtualny]

Chciałem zobaczyć jak kompilowana jest dyrektywa "switch-case" - używając polecenia:

arm-none-eabi-objdump.exe TIMERS_TRY.elf -d --source > deas.txt

otrzymałem disassemblację (wyciąłem inne polecenia ograniczając się do zobrazowania "switch-case":

    switch(lcdprop.pFont->Height){
 8003870:    4ba0          ldr    r3, [pc, #640]    ; (8003af4 <Draw_Char+0x2c0>)
 8003872:    689b          ldr    r3, [r3, #8]
 8003874:    88db          ldrh    r3, [r3, #6]
 8003876:    3b08          subs    r3, #8
 8003878:    2b10          cmp    r3, #16
 800387a:    d834          bhi.n    80038e6 <Draw_Char+0xb2>
 800387c:    a201          add    r2, pc, #4    ; (adr r2, 8003884 <Draw_Char+0x50>)
 800387e:    f852 f023     ldr.w    pc, [r2, r3, lsl #2]
 8003882:    bf00          nop
 8003884:    080038c9     .word    0x080038c9
 8003888:    080038e7     .word    0x080038e7
 800388c:    080038e7     .word    0x080038e7
 8003890:    080038e7     .word    0x080038e7
 8003894:    080038cf     .word    0x080038cf
 8003898:    080038e7     .word    0x080038e7
 800389c:    080038e7     .word    0x080038e7
 80038a0:    080038e7     .word    0x080038e7
 80038a4:    080038d5     .word    0x080038d5
 80038a8:    080038e7     .word    0x080038e7
 80038ac:    080038e7     .word    0x080038e7
 80038b0:    080038e7     .word    0x080038e7
 80038b4:    080038db     .word    0x080038db
 80038b8:    080038e7     .word    0x080038e7
 80038bc:    080038e7     .word    0x080038e7
 80038c0:    080038e7     .word    0x080038e7
 80038c4:    080038e1     .word    0x080038e1
    case 8:
        fontsize = 8;
 80038c8:    2308          movs    r3, #8
 80038ca:    623b          str    r3, [r7, #32]
        break;
 80038cc:    e00b          b.n    80038e6 <Draw_Char+0xb2>
    case 12:
        fontsize = 12;
 80038ce:    230c          movs    r3, #12
 80038d0:    623b          str    r3, [r7, #32]
        break;
 80038d2:    e008          b.n    80038e6 <Draw_Char+0xb2>
    case 16:
        fontsize = 32;
 80038d4:    2320          movs    r3, #32
 80038d6:    623b          str    r3, [r7, #32]
        break;
 80038d8:    e005          b.n    80038e6 <Draw_Char+0xb2>
    case 20:
        fontsize = 40;
 80038da:    2328          movs    r3, #40    ; 0x28
 80038dc:    623b          str    r3, [r7, #32]
        break;
 80038de:    e002          b.n    80038e6 <Draw_Char+0xb2>
    case 24:
        fontsize = 72;
 80038e0:    2348          movs    r3, #72    ; 0x48
 80038e2:    623b          str    r3, [r7, #32]
        break;
 80038e4:    bf00          nop
    }

    fontoffset = ((s - ' ') * fontsize);
 80038e6:    78fb          ldrb    r3, [r7, #3]
 80038e8:    3b20          subs    r3, #32
 80038ea:    461a          mov    r2, r3
 80038ec:    6a3b          ldr    r3, [r7, #32]

Na co warto zwrócić uwagę - tablica adresów skoków przełącznika case (0x08003884) zawiera:

1. Adresy do warunków switch powiększone o 1 (nieparzysty adres - THUMB) na przykład nie 0x080038c8 tylko 0x080038c9 (!!!) - tutaj dba i pamięta o tym kompilator, pisanie tego samemu w asm bywa już nieco problematyczne...

2. Adresy warunków niespełnionych  (0x080038e7 faktycznie wskazujące na 0x080038e6)

 

Przydatne polecenia i metody działania dla deassemblacji pliku/funkcji/polecenia C dla GCC:

arm-none-eabi-gcc.exe -O2 -c main.c -o main.o

kompiluje main.c do main.o


arm-none-eabi-gcc.exe -O2 -c main.c -S

konwertuje main.c do assemblera w pliku main.s


arm-none-eabi-as.exe  source.s -o source.o
kompiluje źródło assemblera do obiektu

arm-none-eabi-objdump.exe -D source.o 
deassembluje obiekt

arm-none-eabi-ld.exe main.o function.o -o program.elf
linkuje podane pliki obiektowe do pliku elf


arm-none-eabi-objdump elf_file.elf -D --source > deas.txt

wyprowadza deassemblację pliku do pliku tekstowego zpokazaniem  i translacją do asm

 

Mały trening... Mając 2 pliki:

 

"main.c"

void MSR_MSP(int a);

void main()
{

 MSR_MSP(44UL);
for(;;);

}

 

oraz "functions.s"

    .cpu cortex-m3
    .arch armv7-m
    .fpu softvfp  

    .thumb
    .thumb_func
    .global MSR_MSP
    .type   MSR_MSP, %function
    
    .text
    .align    2
    .global    MSR_MSP
    .syntax unified
    .thumb
    .thumb_func
    .type    MSR_MSP, %function
_start = 0x08000000
MSR_MSP:
    MSR MSP, r0             //set Main Stack value
    BX LR

 

Używam następującego łańcucha poleceń, aby podejrzeć, do jakiej wynikowej postaci generuje to kompilator:

arm-none-eabi-gcc.exe  -mcpu=cortex-m3 -g3 -DDEBUG -c main.c -o main.o 
arm-none-eabi-as.exe  functions.s -o functions.o 
arm-none-eabi-ld.exe main.o functions.o -o program.elf

arm-none-eabi-objdump.exe program.elf -d --source > deas.txt
arm-none-eabi-objdump.exe main.o -d --source > deas2.txt
arm-none-eabi-gcc.exe -mcpu=cortex-m3  -DDEBUG  -c main.c -S 

 

Otrzymuję plik "main.s" - warto zwrócić uwagę na szereg nieużytych przeze mnie atrybutów, które kompilator "z urzędu" generuje w kodzie.

    .cpu cortex-m3
    .arch armv7-m
    .fpu softvfp
    .eabi_attribute 20, 1
    .eabi_attribute 21, 1
    .eabi_attribute 23, 3
    .eabi_attribute 24, 1
    .eabi_attribute 25, 1
    .eabi_attribute 26, 1
    .eabi_attribute 30, 6
    .eabi_attribute 34, 1
    .eabi_attribute 18, 4
    .file    "main.c"
    .text
    .align    1
    .global    main
    .syntax unified
    .thumb
    .thumb_func
    .type    main, %function
main:
    @ args = 0, pretend = 0, frame = 0
    @ frame_needed = 1, uses_anonymous_args = 0
    push    {r7, lr}
    add    r7, sp, #0
    movs    r0, #44
    bl    MSR_MSP
.L2:
    b    .L2
    .size    main, .-main
    .ident    "GCC: (GNU Tools for STM32 10.3-2021.10.20211105-1100) 10.3.1 20210824 (release)"

Oraz plik "deas.txt", który powstał z deassemblacji pliku "ELF"

program.elf:     file format elf32-littlearm


Disassembly of section .text:

00008000 <main>:

void MSR_MSP(int a);

void main()
{
    8000:    b580          push    {r7, lr}
    8002:    af00          add    r7, sp, #0

 MSR_MSP(44UL);
    8004:    202c          movs    r0, #44    ; 0x2c
    8006:    f000 f801     bl    800c <MSR_MSP>
for(;;);
    800a:    e7fe          b.n    800a <main+0xa>

0000800c <MSR_MSP>:
    800c:    f380 8808     msr    MSP, r0
    8010:    4770          bx    lr
    8012:    bf00          nop

W linku podanym przez ReniferRudolf jest kolejny dobry link na temat ARN ASSEMBLER:

https://www.mikrocontroller.net/articles/ARM-ASM-Tutorial

 

Być może moje rozwlekłe posty pomogą komuś w pracy z ARM ASM, do wielu pokazanych tutaj rzeczy dochodziłem ciężką drogą. Jest to taki skondensowany ASM-start-tut.