ARM MIKSOWANIE C z ASM - własny sprintf()

[virtualny]

Kiedyś wpadłem na pomysł jak skonwertować 32bitową (i większe też można) liczbę do dziesiętnego stringu ASCII. Przede wszystkim - zapewne nie pierwszy wymyśliłem ten algorytm i oczywiście niejedyny. Algo jest niebywale prosty - wystarczy zadaną liczbę do konwersji ciągle dzielić przez 10 i zapisywać po każdym dzieleniu resztę z dzielenia jako kolejną cyfrę dziesiętną. Przykładowo sprawdźmy na kalkulatorze wartość 0xFFFF FFFF = ...

Skoro tak łatwo można skonwertować taką liczbę do dziesiętnego ciągu ASCII, to postanowiłem napisać program w ASSEMBLERZE, który będzie przeliczał/konwertował zadaną liczbę i zapisywał do bufora NULL terminated string będący dziesiętną reprezentacją uint32_t. Żeby wszystko było łatwe do prześledzenia i podglądania potrzeba zrobić kilka dodatkowych sztuczek:

1. Dodać kilka linii kodu w startup assemblerze, który wypełni CAŁY RAM gwiazdkami (0x2A), dzięki temu będzie widać jakich obszarów używa nasz program, który jest generalnie w C i wywołuje z parametrami program konwersji (my_sprintf), oraz odbiera z wykonanego wartość długości zwracanego stringu.

Reset_Handler:
  ldr   r0, =_estack
  mov   sp, r0          /* set stack pointer */
/* Call the clock system initialization function.*/
//  bl  SystemInit
    ldr r0, = 0x20000000
    mov r1, 0
    mov r2, 0x2a
filling:
    strb r2, [r0, r1]
    add  r1, r1, #1
    cmp r1, 0x5000
    bne filling

2. Dodać 3 linie w pliku main.c, które zdefiniują sposób wywołania zewnętrznej funkcji assemblera oraz chociaż nie jest to takie proste, to dla naszej wygody umieszczą dwa robocze bufory tekstowe pod wskazanymi adresami - 0x20000000 i 0x20000010. Parametry wywoływanej funkcji to

- wskaźnik na tekstowy bufor wyjściowy, w którym zostanie zwrócona skonwertowana wartość

- liczba uint32_t przeznaczona do konwersji

- wskaźnik na tekstowy bufor roboczy dla procedury assemblera.

 extern int my_sprintf(char* out_buff, uint32_t num, char* int_buff);

__attribute__ ((section(".outBuffer"), used)) char OUT_BUFFER[11];
__attribute__ ((section(".intBuffer"), used)) char INT_BUFFER[10];

 

Żeby nasze bufory zostały umieszczone tam, gdzie chcemy musimy jeszcze dopisać sekcję do skryptu linkera:

  .my_Buffers(NOLOAD) :
  {
    . = ALIGN(1);
    . = ABSOLUTE (0x20000000);
    *(.outBuffer)

    . = ABSOLUTE (0x20000010);
    *(.intBuffer)

  } >RAM

 

Ponieważ nasze bufory wstawiamy na samym początku RAM, nasz dodatkowy skrypt linkera musi być także pierwszym skryptem opisującym zmienne w RAM u mnie jest to miejsce zaraz za sekcją

  .fini_array :
  {
    . = ALIGN(4);
    PROVIDE_HIDDEN (__fini_array_start = .);
    KEEP (*(SORT(.fini_array.*)))
    KEEP (*(.fini_array*))
    PROVIDE_HIDDEN (__fini_array_end = .);
    . = ALIGN(4);
  } >FLASH

Uffffff...

Teraz nasze bufory będą pod adresami 0x20000000 (wyjściowy) i 0x20000010 - wewnętrzny (WIEMY GDZIE ICH SZUKAĆ). Bufory są dwa, ponieważ ciąg generowany przez procedurę jest w odwrotnej kolejności i na końcu zostaje do wyjściowego bufora przepisany  "wspak". Nasza funkcja przyjmuje te 3 parametry w rejestrach R0, R1, R2 zgodnie z ARM Application Procedure Call Standard (AAPCS), wchodzący w skład Application Binary Interface (ABI). Na końcu w rejestrze R0 zwraca długość ciągu (zgodnie z AAPCS). Poniżej owa procka. Jeszcze jedno - ten bufor wewnętrzny można było również zdefiniować w sekcji .bss i przyjmować dwa zamiast trzech parametrów - kod za to odpowiedzialny "zaremowałem". I tak wygląda nasza procedura:

 

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

    .thumb
    .thumb_func
    .syntax unified
    .global my_sprintf
    .type   my_sprintf, %function

    .text
    .align    2

//========================================================
// DECIMAL CONVERSION OF ANY UNSIGNED VALUE UP TO 32 BIT
//========================================================
       // INPUT:
       //    R0, =  ; POINTER TOOUTPUT DATA BUFFER ADDRESS
       //    R1, =  ; VALUE TO DECIMAL CONVERT
       //    R2, =  ; pointer to internal working asm buff

       // OUTPUT: R0 = LENGTH OF PRODUCED BYTES OF STRING
//========================================================
my_sprintf:

        PUSH {R1-R5}

//        LDR   R2, = INT_BUFF //; TEMP BUFFER ADDRES

        MOV   R5, #0  // LENGTH OF STRING
CALC01:
        LDR   R3, = 0xCCCCCCCD
        UMULL R4,R3,R3,R1
        LSR   R4,R3, #3
        PUSH  {R4}
        MOV   R3, #0x0A
        MUL   R4, R4, R3
        SUB   R4, R1, R4 //; CALCULATE THE REST
        ORR   R4, R4, #0x30
        STRB  R4, [R2,R5]
        ADD   R5, R5, #1
        POP   {R1}
        CMP   R1, #0
        BNE   CALC01
CALC02:
        SUB   R5, R5, #1
        LDRB  R4, [R2, R5] //; GET DATA FROM THE END
        STRB  R4, [R0, R1] //; R1 = 0 AT THE END CALC01
        ADD   R1, R1, #1   // now R1 counting length of string
        CMP   R5, #0
        BNE   CALC02
        STRB  R5, [R0, R1] //; STORE NULL TERMINATE STRING
        MOV   R0, R1    // OUTPUT: R0 = LENGTH OF PRODUCED BYTES OF STRING

        POP {R1-R5}

        BX LR  // ADIOS :)

//================================
        // OUTPUT: R0 = LENGTH OF PRODUCED BYTES OF STRING
//================================
//    .bss
//INT_BUFF:
// .byte 0,0,0,0,0,0,0,0,0,0,0,0
//===================================================================

 

Procedura nie jest zbyt zagmatwana i rzekłbym że piękno leży w prostocie ALE... Gdyby ktoś uważnie się przyjrzał, to zauważy że nigdzie bezpośrednio nie wykonuje się w tej procedurze dzielenia przez 10 (!!!) innymi słowy zwycięzcą tej zagadki będzie ten, kto nie popuka się w czoło na wniosek: ABY PODZIELIĆ TRZEBA POMNOŻYĆ ... taka ciekawostka do własnych rozważań i właśnie w mojej ocenie taki niuans tej procedury dodaje jej piękności!

 

No dobrze, a tak wygląda cały plik main.c - nie jest on zbyt obszerny.

/**
 ******************************************************************************
 * @file           : main.c
 ******************************************************************************
 */

#include <stdint.h>



extern int my_sprintf(char* out_buff, uint32_t num, char* int_buff);

__attribute__ ((section(".outBuffer"), used)) char OUT_BUFFER[11];
__attribute__ ((section(".intBuffer"), used)) char INT_BUFFER[10];
int main(void)
{
    uint32_t i;
    uint32_t datalength;

    i = 0xFFFFFFFF;
    datalength = my_sprintf((char*)&OUT_BUFFER, i, (char*) &INT_BUFFER);


	return datalength;
}
//==================================================

 

No i żeby ktoś się nie przeraził że 

	return datalength;

zawiesi proca, czy wywoła wyjątek, ponieważ funkcja

int main(void)

została wywołana z kodu pliku startup'owego:

//=====================================================================
/* Call the application's entry point.*/
  bl main

LoopForever:
  b LoopForever
//=====================================================================

 

Także wszystko zatrzyma się w LoopForever 🙂

 

komu się zechce debugować powinien zobaczyć taki efekt działania programu:

 

Dla leniwych po zaprogramowaniu procka (BLUEPILL) można podejrzeć RAM poprzez STM32 ST-LINK Utility tak wygląda początek pamięci i nasze bufory:

oraz koniec RAM gdzie widać stack

I dla łatwiejszego rozeznania - gwiazdki to nieużywane bajty RAM'u

 

W załączeniu program. Został wygenerowany dla STM32F103C8T6 jako pusty projekt bez narzutów HAL, LL itp. Skompilowana binka zajmuje "asz" 620 bajtów 🙂

C_MIXED_ASM.ZIP

[bjrk]

Podoba mi się! Może kiedyś wreszcie sam sięgnę po pisanie w assemblerze - na razie tylko czytam.

Jedna uwaga, aby odwrócić kolejność bajtów nie potrzebujesz drugiego bufora, a tylko jeden dodatkowy bajt. Wymieniasz pierwszy z ostatnim, drugi z przedostatnim itd... Choć przy małym buforze dodatkowy kod może być dłuższy od zysku z pozbycia się jednego bufora. A może druga funkcja odwracająca ciąg "w miejscu"?

[ethanak]

38 minut temu, bjrk napisał:

tylko jeden dodatkowy bajt.

Da się i bez niego, podobno procek ma jakieś rejestry... a nawet bez nich się da. Proponuję spróbować - to może być ciekawe zadanie!

Poza tym można jeszcze inaczej: umieszczać znaki w buforze od ostatniej pozycji, a po zakończeniu przesunąć zawartość bufora na właściwe miejsce.

A tak dla formalności: ta funkcja nazywa się "utoa" a nie "sprintf". Również potrzebna, ale robi zupełnie coś innego. Pisanie sprintfa w asemblerze pozostawmy masochistom, ale utoa i itoa (mam nadzieję że będzie następna?) jak najbardziej mogą się przydać.

[virtualny]

Dzięki za reakcję.

Dwa bufory VS 1 bufor - bardziej fascynowało mnie ustawianie zmiennych w porządku jakim ja chcę, a nie linker czy kompilator...

"utoa" unsigned to ASCII? racja - to mój skrót myślowy, kiedy wykonywałem "sprintf(&buffor, %d, x)" 🙂

Następne itoa? Myślałem że następne ma być odwrotne działanie, żeby string decymalny skonwertować do uint32_t... Sklecenie itoa na bazie tego, co jest powinno być proste - zobaczymy...

Napisałem wersję z jednym buforem i nie było to wcale takie proste - myślę że bjrk nie zastanawiał się jakie implikacje przy takim przepisywaniu rodzi fakt stringu o długości parzystej i nieparzystej.

 

Program w wersji dla leniwych pozwala konwertować zadane wartości poprzez wpisywanie ich bezpośrednio do zmiennej za pomocą STM32 ST-LINK Utility.

 

Plik main.c wygląda obecnie tak:

/**
 ******************************************************************************
 * @file           : main.c
 ******************************************************************************
 */

#include <stdint.h>



extern int my_sprintf(char* out_buff, uint32_t num);

__attribute__ ((section(".outBuffer"), used)) char OUT_BUFFER[11];     // at 0x20000000

__attribute__ ((section(".Var_value"),  used)) uint32_t value;         // at 0x20000010
__attribute__ ((section(".Var_length"), used)) uint32_t datalength;    // at 0x20000014

int main(void)
{
    uint32_t i;
    value = 0xc000;


    while(1){
        datalength = my_sprintf(OUT_BUFFER, value);
        while(i == value);
        i = value;
    }
}
//==========================================================================

 

Sekcja w skrypcie dla linkera:

//======================================
  .my_Buffers(NOLOAD) :
  {
    . = ALIGN(1);
    . = ABSOLUTE (0x20000000);
    *(.outBuffer)
   
    . = ABSOLUTE (0x20000010);
    *(.Var_value)
    . = ABSOLUTE (0x20000014);
    *(.Var_length)

  } >RAM
//==================================

I funkcja w ASM:

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

    .thumb
    .thumb_func
    .syntax unified
    .global my_sprintf
    .type   my_sprintf, %function

    .text
    .align    2

//========================================================
// DECIMAL CONVERSION OF ANY UNSIGNED VALUE UP TO 32 BIT
//========================================================
       // INPUT:
       //    R0, =  ; POINTER TO OUTPUT char DATA BUFFER
       //    R1, =  ; VALUE TO DECIMAL CONVERT


       // OUTPUT: R0 = LENGTH OF PRODUCED BYTES OF STRING
//========================================================
my_sprintf:

        PUSH {R1-R5}  // store registers


        MOV   R5, #0  // LENGTH OF STRING
CALC01:
        //------------------
        //- R4 = R1 DIV 10 -
        //------------------
        LDR   R3, = 0xCCCCCCCD // MAGIC VALUE (!!!)
        UMULL R4,R3,R3,R1      // this three lines looks a bit strange
        LSR   R4,R3, #3        // but here we gotta divide by 10 (seriously!)
        //----------------------------------------------
        MOV   R2, R4         // R2 = R1 div by 10 without the rest
        MOV   R3, #0x0A      // R3 = 10
        MUL   R4, R4, R3     // R4 = R4 * 10

        // mod 10 calculate
        // R4 = R1 mod 10
        SUB   R4, R1, R4     // CALCULATE THE REST r4 = r1 - r4

        ORR   R4, R4, #0x30  // CHANGE TO ASCII NUMBER VALUE "0..9"
        STRB  R4, [R0,R5]    // store next decimal row
        ADD   R5, R5, #1     // R5 = length of string
        MOV   R1, R2         // R1 = before stored value in R2 = (R1 div 10)
        CMP   R1, #0         // R1 = 0? (that was last one operation?)
        BNE   CALC01         // if R1 != 0 then continue CALC01 loop

        // R1 = 0            // R1 = 0, R5 = length of produced string
        STRB  R1, [R0, R5]   // FIRST TIME R1 = 0 SO NULL TERMINATED STRING MAKE NULL
        PUSH  {R5}           // TEMPRARY STORE LENGTH OF STRING
        SUB   R5, R5, #1     // SET OFFSET AT THE END OF STRING (BACKWARD POSSITION)

        // R0 = POINTER TO OUTPUT NULL TERMINATED STRING
        // R5 = OFFSET TO THE END OF STRING (BACKWARD POSSITION)
        // R1 = OFFSET TO THE START OF STRING (FORWARD POSSITION) R1 = 0 AT THE END CALC01 ROUTINE
        // R4 = BACKWARD BYTE (BYTE FROM "RIGHT SIDE")
        // R2 = FORWARD  BYTE (BYTE FROM "LEFT  SIDE")
CALC02:
        LDRB  R4, [R0, R5] // GET DATA FROM THE END (FROM RIGT SIDE)
        LDRB  R2, [R0, R1] // GET DATA FROM THE START (LEFT SIDE)
        STRB  R2, [R0, R5] // GET DATA FROM THE "LEFT  SIDE INTO THE RIGHT SIDE"
        STRB  R4, [R0, R1] // GET DATA FROM THE "RIGHT SIDE INTO THE LEFT  SIDE"
        ADD   R1, R1, #1   // ACTUALIZE STRING FORWARD POSSITION
        SUB   R5, R5, #1   // ACTUALIZE STRING BACKWARD POSSITION
        CMP   R5, R1       // R5 =< R1 ?
        BEQ   END_CALC     // if R5 = R1 go to finish
        BGT   CALC02       // if R5 > R1 continue loop - otherway finish (R5 < R1)

END_CALC:
        // acording declaration this functin is "int" and
        // acordind AAPCS should be returned int value in R0
        // simple "return datalength;" in C
        POP   {R0}         // OUTPUT: R0 = LENGTH OF PRODUCED BYTES OF STRING R0 = R5

        POP {R1-R5}        // restore registers

        BX LR  // ADIOS :)

//=====================================================

 

BIN_C_MIXED_ASM.zip C_MIXED_ASM.ZIP

[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

[bjrk]

Nie widziałem trudności, bo gdy nieparzysta długość, to centralny bajt już jest na miejscu, a ostatni (pusty) bajt jest zawsze na miejscu i można go zignorować przy odwracaniu.

Edytowano Lipiec 11, 2023 przez bjrk
Uzupełnienie

[ethanak]

23 minuty temu, virtualny napisał:

"utoa" unsigned to ASCII?

Dokładnie tak - z tą różnicą że przyjmujesz radix == 10.

A dlaczego itoa? Bo kod będzie podobny, a nawet możesz wykorzystać funkcję utoa (nawet niekoniecznie przez wywołanie a po prostu skok do jakiegoś punktu wewnątrz funkcji.

Komplementarna para (atou/atoi) to jakby następny krok, i podobnie funkcja atoi może wykorzystać kod atou.

 

[virtualny]

my_itoa został dopisany. Niewiele trzeba było do szczęścia. Plik main.c wygląda tak:

#include <stdint.h>

extern int my_itoa(char* out_buff, int32_t num);
extern int my_sprintf(char* out_buff, uint32_t num);

__attribute__ ((section(".outBuffer"), used)) char OUT_BUFFER[12];     // at 0x20000000

__attribute__ ((section(".Var_length"), used)) uint32_t datalength;    // at 0x2000000C
__attribute__ ((section(".Var_value"),  used)) uint32_t value;         // at 0x20000010

int main(void)
{
    uint32_t i;
    int x = 0x80000000;
    value = (uint32_t) x;

    while(1){
        datalength = my_itoa(OUT_BUFFER, (int32_t) value);
        while(i == value);
        i = value;
    }
}

Plik assemblera:

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

    .thumb
    .thumb_func
    .syntax unified
    .global my_sprintf
    .global my_itoa
    .type   my_sprintf, %function
    .type   my_itoa, %function

    .text
    .align    2

//========================================================
// DECIMAL CONVERSION OF ANY UNSIGNED VALUE UP TO 32 BIT
//========================================================
       // INPUT:
       //    R0, =  ; POINTER TO OUTPUT char DATA BUFFER
       //    R1, =  ; VALUE TO DECIMAL CONVERT


       // OUTPUT: R0 = LENGTH OF PRODUCED BYTES OF STRING
//========================================================
my_sprintf:

        PUSH {R1-R5}  // store registers


        MOV   R5, #0  // LENGTH OF STRING
CALC01:
        //------------------
        //- R4 = R1 DIV 10 -
        //------------------
        LDR   R3, = 0xCCCCCCCD // MAGIC VALUE (!!!)
        UMULL R4,R3,R3,R1      // this three lines looks a bit strange
        LSR   R4,R3, #3        // but here we gotta divide by 10 (seriously!)
        //----------------------------------------------
        MOV   R2, R4         // R2 = R1 div by 10 without the rest
        MOV   R3, #0x0A      // R3 = 10
        MUL   R4, R4, R3     // R4 = R4 * 10

        // mod 10 calculate
        // R4 = R1 mod 10
        SUB   R4, R1, R4     // CALCULATE THE REST r4 = r1 - r4

        ORR   R4, R4, #0x30  // CHANGE TO ASCII NUMBER VALUE "0..9"
        STRB  R4, [R0,R5]    // store next decimal row
        ADD   R5, R5, #1     // R5 = length of string
        MOV   R1, R2         // R1 = before stored value in R2 = (R1 div 10)
        CMP   R1, #0         // R1 = 0? (that was last one operation?)
        BNE   CALC01         // if R1 != 0 then continue CALC01 loop

        // R1 = 0            // R1 = 0, R5 = length of produced string
        STRB  R1, [R0, R5]   // FIRST TIME R1 = 0 SO NULL TERMINATED STRING MAKE NULL
        PUSH  {R5}           // TEMPRARY STORE LENGTH OF STRING
        SUB   R5, R5, #1     // SET OFFSET AT THE END OF STRING (BACKWARD POSSITION)

        // R0 = POINTER TO OUTPUT NULL TERMINATED STRING
        // R5 = OFFSET TO THE END OF STRING (BACKWARD POSSITION)
        // R1 = OFFSET TO THE START OF STRING (FORWARD POSSITION) R1 = 0 AT THE END CALC01 ROUTINE
        // R4 = BACKWARD BYTE (BYTE FROM "RIGHT SIDE")
        // R2 = FORWARD  BYTE (BYTE FROM "LEFT  SIDE")
CALC02:
        LDRB  R4, [R0, R5] // GET DATA FROM THE END (FROM RIGT SIDE)
        LDRB  R2, [R0, R1] // GET DATA FROM THE START (LEFT SIDE)
        STRB  R2, [R0, R5] // GET DATA FROM THE "LEFT  SIDE INTO THE RIGHT SIDE"
        STRB  R4, [R0, R1] // GET DATA FROM THE "RIGHT SIDE INTO THE LEFT  SIDE"
        ADD   R1, R1, #1   // ACTUALIZE STRING FORWARD POSSITION
        SUB   R5, R5, #1   // ACTUALIZE STRING BACKWARD POSSITION
        CMP   R5, R1       // R5 =< R1 ?
        BEQ   END_CALC     // if R5 = R1 go to finish
        BGT   CALC02       // if R5 > R1 continue loop - otherway finish (R5 < R1)

END_CALC:
        // acording declaration this functin is "int" and
        // acordind AAPCS should be returned int value in R0
        // simple "return datalength;" in C
        POP   {R0}         // OUTPUT: R0 = LENGTH OF PRODUCED BYTES OF STRING R0 = R5

        POP {R1-R5}        // restore registers

        BX LR  // ADIOS :)

//=====================================================
//========================================================
// DECIMAL CONVERSION OF SIGNED 32 BIT VALUE
//========================================================
       // INPUT:
       //    R0, =  ; POINTER TO OUTPUT char DATA BUFFER
       //    R1, =  ; VALUE TO DECIMAL CONVERT


       // OUTPUT: R0 = LENGTH OF PRODUCED BYTES OF STRING
//========================================================
my_itoa:
      CMP   R1, 0       // IS OUR VALUE NEGATIVE?
      BGE   my_sprintf  // IF IS POSSITIVE GO TO my_sprintf
      PUSH  {LR}        // PC address go back to the main function
      PUSH  {R1}        // save our value for sign print to buffer
      MOV   R1, '-'
      STRB  R1, [R0]    // STORE "-" SIGN AT THE START TEXT BUFFER
      ADD   R0, R0, #1  // MOVE UP 1 BYTE POINTER TO OUTBUFFER
      POP   {R1}
      NEG   R1, R1      // CHANGE VALUE TO POSSITIVE NUMBER
      BL    my_sprintf  // CONVERT VALUE TO DECIMAL STRING
                        // now in R0 is datalength from my_sprintf
      ADD   R0, R0, #1  // INCREASSE LENGTH OF STRING MORE 1 BYTE OF SIGN "-"
      POP   {PC}        // GO BACK TO THE MAIN FUNCTION
//======================================================

A tak wygląda działanie programu s ST-Link Utility (można zmieniać wartość do konwersji pod adresem 0x20000010):

Wartość długości stringu została przeniesiona pod adres 0x2000000c

[ethanak]

No to teraz funkcje komplementarne - atoX 🙂

A potem może wprowadzenie radix? Nie wiem jak w Twoich zastosowaniach, ale ostatnio musiałem zastosować ósemkową notację na wyjściu (tworzenie stringa rozumianego przez kompilator C). Co prawda dziś robię takie rzeczy w Pythonie, ale umiejętność zrobienia tego na najniższym poziomie czasem się przydaje... 

[virtualny]

atoX - równie prosty algorytm odwrotny do utoa: "mnóż rezultat przez 10 i dodawaj kolejną liczbę ze stringu" - tak w skrócie.

plik main.c:

#include <stdint.h>

extern int my_itoa(char* out_buff, int32_t num);
extern int my_sprintf(char* out_buff, uint32_t num);
extern int my_atoX(char* out_buff);
__attribute__ ((section(".outBuffer"), used)) char OUT_BUFFER[12];     // at 0x20000000
__attribute__ ((section(".Var_length"), used)) uint32_t datalength;    // at 0x2000000C
__attribute__ ((section(".Var_value"),  used)) uint32_t value;         // at 0x20000010
__attribute__ ((section(".Var_CMP"),  used))    int32_t compared;      // at 0x20000014

int main(void)
{
    uint32_t i;
    int x = 0x80000000;
    value = (uint32_t) x;

    while(1){
        datalength = my_itoa(OUT_BUFFER, (int32_t) value); // convert signed int 32 to ASCII
        compared = my_atoX(OUT_BUFFER);                    // convert ASCII NULL terminated string to 32bit integer
        while(i == value);
        i = value;
    }
}

 

funkcja atoX:

//========================================================
//  CONVERSION string to 32bit integer
//========================================================
       // INPUT:
       //    R0, =  ; POINTER TO OUTPUT char DATA BUFFER

       // OUTPUT: R0 = calculated integer
//========================================================
my_atoX:
      PUSH  {R1-R5}        // SAVE USED REGISTER

      LDRB  R1, [R0]       // GET THE FIRS CHAR - IS NEGATIVE SIGN?
      CMP   R1, 0x2D
      BNE   POSSITIVE

      ADD   R0,R0, #1      // MOVE UP 1 BYTE POINTER TO OUTBUFFER

POSSITIVE:

      MOV    R2, #0        // RESULT VALUE OF CONVERSION
      MOV    R3, #0        // OFFSET IN BUFFER
      MOV    R5, #0x0A

CONVERT_X:
      LDRB   R4, [R0, R3]  // LOAD ONE BYTE OF STRING
      CMP    R4, #0
      BEQ    END_ATOX      // IS THE END OF STRING?
      ANDS   R4, 0x0F      // UPDATE FLAGS AND REMOVE ASCII NUMBER 0x30..0x39
      MUL    R2, R2, R5    // R2 = R2 * 10
      ADD    R2, R2, R4    // ADD NEXT DECIMAL COLUMN
      ADD    R3, R3, #1    // OFFSET TO NEXT CHAR
      CMP    R3, #14       // IS ZERO NULL TERMINATED STRING?
      BNE    CONVERT_X     // CONTINUE CONVERT LOOP  IF NO REACHED R3 UP TO 14

CONVERT_ERROR:             // TO MANY CHAR - WE GOTTA AN STRING TERMINATE ERROR
      MOV    R0, 0xFFFFFFFF
      B      NO_NEG        // AN ERROR VALUE LOAD TO R0 ... NEVERMIND :)
END_ATOX:
      MOV    R0, R2        // RETURN OUR CALCULATED CONVERSION VALUE
      CMP    R1, #0x2D     // WAS HERE NEGATIVE SIGN?
      BNE    NO_NEG
      NEG    R0, R0        // IF SIGN WAS NEGATIVE SO DO NEG OUR VALUE
NO_NEG:
      POP    {R1-R5}       // RESTORE USED REGISTERS
      BX     LR  // GO BACK
//======================================================

Program konwertuje integera ze znakiem do stringa, a następnie wywołuje funkcję my_atoX, która na odwrót konwertuje string do binarnej liczby 32 bitowej. Tak wygląda zabawa przez ST-LINK'a:

 

W załączeniu program i osobno sama binka do wgrania.

Ufff... eot

 

 

BIN_C_MIXED_ASM.zip C_MIXED_ASM.ZIP