Przykłady procedur realizujących podstawowe działania
arytmetyczne w języku Asembler ST7.
Podstawą działań wielu programów są różne operacje arytmetyczne wykonywane czy to na zmiennych wejściowych,
czy to na zmiennych wewnętrznych. W tym artykule opiszę propozycje procedur wykonujących podstawowe działania
arytmetyczne takie jak: dodawanie, odejmowanie, mnożenie i dzielenie, porównanie liczb oraz konwersja liczb
binarnych na dziesiętne. Artykuł napisano na podstawie noty aplikacyjne firmy STMicroelectronics  ST7 Math Utility
Routines .
Dzielenie całkowite dwóch liczb 1-bajtowych bez znaku
Na rysunku 1 przedstawiono schemat podprogramu dzielenia dwóch liczb 1-bajtowych zamieszczonego na listingu 1.
Obie liczby muszą być większe od 0. Funkcja nie sygnalizuje faktu błędnej operacji dzielenia, to jest dzielenia przez 0.
W przypadku, gdy dzielna lub dzielnik nie są właściwe, wynikiem działania jest 0 i funkcja kończy pracę. Wykonywana
jest operacja dzielenia liczb całkowitych liczba_a / liczba_b. Rezultatem działania jest wynik zapamiętany w
zmiennych iloraz i reszta.
Rysunek 1. Schemat działania podprogramu dzielenia liczb 1-bajtowych.
J.Bogusz  Podstawowe działania arytmetyczne w asemblerze ST7 str. 1/16
 ;*******************************************************
;dzielenie liczba_a / liczba_b
;argumenty:
; - liczba_a = dzielną
; - liczba_b = dzielnik
; - liczba_a i liczba_b `" 0
; - cnt (jako licznik działań)
;rezultaty:
; - iloraz zawiera część całkowitą z ilorazu liczb
; - reszta zawiera resztę z dzielenia
;modyfikowane:
; - zmienna licznikowa cnt
; - flagi Z, C
;
;PRZYKA
AD UŻYCIA
; ld A,#$E7
; ld liczba_a,A
; ld A,#$10 |
; ld liczba_b,A
; call div_ab
;*******************************************************
.div_ab
;inicjacja zmiennych
push A ;zapamiętanie akumulatora
clr iloraz ;część całkowita = 0
clr reszta ;reszta z dzielenia = 0
;sprawdzenie, czy liczba_a i liczba_b `" 0
ld A,liczba_b
jrugt dziel0 ;jeśli liczba_b `" 0, to sprawdzenie liczba_a
end_dziel
pop A ;koniec pracy podprogramu, odtworzenie akumulatora
ret
dziel0
ld A,number_a ;jeśli A=0, to wynik również = 0
jreq end_div ;jeśli A`"0, to wykonaj działania
;podprogram wykonujący dzielenie
rcf ;flaga C=0
ld A,#$08 ;inicjacja licznika przesunięć liczby
ld cnt,A
ld A,liczba_a
rlc A ;przesunięcie w lewo i zapamiętanie rezultatu
ld iloraz,A
dziel1
ld A,reszta
rlc A ;resztę z dzielenia w lewo, aby uwzględnić flagę C
ld reszta,A
sub A,liczba_b
jrc dziel2 ;kontynuacja pracy?
ld reszta,A
dziel2
ld A,iloraz
rlc A ;przesunięcie w lewo ilorazu
ld iloraz,A
dec cnt
jreq dziel3 ;jeśli licznik przesunięć=0, to koniec pracy
jra dziel1
dziel3
cpl A ;negowanie wyniku (ilorazu)
ld iloraz,A ;zapamiętanie ilorazu
jra end_dziel ;koniec pracy funkcji
Listing 1. Podprogram dzielenia dwóch liczb 1-bajtowych.
J.Bogusz  Podstawowe działania arytmetyczne w asemblerze ST7 str. 2/16
Mnożenie całkowitych liczb 1-bajtowych bez znaku
Prezentowany na listingu 2 podprogram mnoży przez siebie dwie liczby 1-bajtowe. ST7 zawiera na swojej liście
rozkazów polecenie mnożenia dwóch liczb, jednak trzeba pamiętać o tym, że wynik mnożenia (iloczyn) może być
liczbą 2-bajtową, inaczej niż czynniki. W związku z tym polecenie mnoży zawartość rejestru indeksowego X lub Y
(opB) przez zawartość akumulatora (A), a wynik umieszcza w parze rejestrów: odpowiednio X i Y, lub Y i A.
Akumulator zawiera mniej znaczący bajt iloczynu, natomiast rejestr indeksowy  bardziej znaczący. Uproszczony
schemat funkcjonowania polecenia MUL umieszczono na rysunku 2.
symbol X, oznacza polecenie MUL
A (akumulator)
(z listy rozkazów ST7) mnożące
dwie liczby 1-bajtowe
X
opB (X lub Y)
opB X A
{opB : A}
Rysunek 2. Uproszczony schemat funkcjonowania polecenia MUL.
;*******************************************************
;mnożenie liczba_a x liczba_b
;argumenty:
; - liczba_a, liczba_b (czynniki)
;rezultaty:
; - liczba_a (młodszy bajt iloczynu)
; - liczba_b (starszy bajt iloczynu)
;modyfikowane:
; - flagi H, C
;
;PRZYKA
AD UŻYCIA:
; ld A,#$A0
; ld liczba_a,A
; ld A,#$10
; ld liczba_b,A
; call mul_ab
;*******************************************************
.mul_AB
;zapamiętanie modyfikowanych rejestrów
push X
push A
;załadowanie zmiennych
ld X,liczba_A
ld A,liczba_B
mul X,A
ld liczba_a,A
ld liczba_b,X
;odtworzenie rejestrów
pop A
pop X
;powrót z podprogramu
ret
Listing 2. Podprogram mnożenia dwóch liczb 8-bitowych
J.Bogusz  Podstawowe działania arytmetyczne w asemblerze ST7 str. 3/16
Mnożenie całkowitych liczb 2-bajtowych bez znaku
Prezentowany na listingu 3 podprogram mnoży przez siebie dwie liczby 2-bajtowe. Używane są operacje mnożenia
liczb 8 bitowych oraz dodawania z przeniesieniem. Wynik mnożenia umieszczany jest w zmiennej iloczyn o długości 4
bajtów. Uproszczony schemat działania podprogramu zamieszczono na rysunku 3.
symbol X, oznacza polecenie MUL
{opA} {opA+1}
(z listy rozkazów ST7) mnożące
dwie liczby 1-bajtowe
X
{opB} {opB+1}
dodawanie z przeniesieniem {opB+1} X {opA} {opB+1} X {opA+1}
+
opB X opA {opB} X {opA+1}
{iloczyn} {iloczyn+1} {iloczyn+2} {iloczyn+3}
Rysunek 3. Uproszczony schemat działania podprogramu mnożącego 2 liczby 2-bajtowe.
J.Bogusz  Podstawowe działania arytmetyczne w asemblerze ST7 str. 4/16
 ;*******************************************************
;mnożenie liczba_a * liczba_b
;czynniki są 2-bajtowe, iloczyn jest 4-bajtowy
;argumenty:
; - liczba_a, liczba_b (czynniki)
;rezultaty:
; - 4-bajtowa zmienna iloczyn
;modyfikowane:
; - flagi C, Z
;
;PRZYKA
AD UŻYCIA:
; ld A,#$F3
; ld liczba_a,A
; ld A,#$D3
; ld {liczba_a+1},A
; ld A,#$FC
; ld liczba_b,A
; ld A,#$C3
; ld {liczba_b+1},A
; call mulw_ab
;*******************************************************
.mulw_ab
push A ;zapamiętanie na stosie modyfikowanych rejestrów
push X
ld X,liczba_b ;załadowanie liczb do mnożenia, bardziej znaczący
ld A,liczba_a ;bajt
mul X,A ;mnożenie liczb
ld iloczyn,X ;zapamiętanie iloczynu starszych bajtów
ld {iloczyn+1},A
ld X,{liczba_a+1} ;teraz mnożenie młodszych bajtów
ld A,{liczba_b+1}
mul X,A
ld {iloczyn+2},X ;zapamiętanie iloczynu młodszych bajtów
ld {iloczyn+3},A
ld X,liczba_a
ld A,{liczba_b+1} ;teraz mnożenie  na krzyż (patrz rysunek 3)
mul X,A
add A,{iloczyn+2} ;dodanie do poprzednio otrzymanych wartości
ld {iloczyn+2},A
ld A,X
adc A,{iloczyn+1}
ld {iloczyn+1},A
ld A,iloczyn
adc A,#0
ld iloczyn,A
ld X,liczba_b
ld A,{liczba_a+1} ;ponownie (następne bajty) mnożenie  na krzyż
mul X,A
add A,{iloczyn+2} ;dodanie do poprzedniego wyniku
ld {iloczyn+2},A
ld A,X
adc A,{iloczyn+1}
ld {iloczyn+1},A
ld A,iloczyn
adc A,#0
ld iloczyn,A
pop X ;odtworzenie wartości rejestrów sprzed wywołania
pop A
ret ;koniec
Listing 3. Podprogram mnożenia dwóch liczb 2-bajtowych
J.Bogusz  Podstawowe działania arytmetyczne w asemblerze ST7 str. 5/16
Dzielenie całkowite liczby 4-bajtowej przez 2-bajtową
Na rysunku 4 przestawiono schemat podprogramu dzielenia liczby 4-bajtowej przez 2-bajtową. Iloraz otrzymany w
wyniku dzielenia zapisywany jest w zmiennej 2 bajtowej, więc tak naprawdę funkcja znajdzie zastosowanie tylko w
przypadkach, gdy iloraz jest mniejszy od 65536. Zmienne nazywają się tak, jak składniki operacji: dzielna, dzielnik,
iloraz. Pozwoli to na ich łatwe rozróżnienie. Podprogram umieszczono na listingu 4.
Rysunek 4. Schemat podprogramu dzielenia liczby 4-bajtowej przez 2-bajtową
J.Bogusz  Podstawowe działania arytmetyczne w asemblerze ST7 str. 6/16
 ;*******************************************************
;Dzielenie liczby typu LONG przez liczbę typu WORD
;argumenty:
; - dzielna (4 bajty)
; - dzielnik (2 bajty)
;rezultaty:
; - 2-bajtowa zmienna iloraz
;modyfikowane:
; - flagi C, Z
; - wewnętrzna zmienna tmp
;
;PRZYKA
AD UŻYCIA:
; ld A,#$0E
; ld dzielna,A
; ld A,#$DC
; ld {dzielna+1},A
; ld A,#$BA
; ld {dzielna+2},A
; ld A,#$98
; ld {dzielna+3},A
; ld A,#$AB
; ld dzielnik,A
; ld A,#$CD
; ld {dzielnik+1},A
; call div_lw |
;*******************************************************
.div_lw
push A ;zapamiętanie rejestrów roboczych na stosie
push X
ld X,#32 ;inicjacja zmiennych
ld A,#0 ;instrukcja LD zajmuje więcej miejsca, niż CLR
ld iloraz,A ;jednak działa znacznie szybciej
ld {iloraz+1},A
ld tmp,A
ld {tmp+1},A
ld {tmp+2},A
ld {tmp+3},A
.wykonaj
sla {dzielna+3} ;przesunięcie dzielnej w lewo bez C
rlc {dzielna+2}
rlc {dzielna+1}
rlc dzielna
rlc {tmp+3} ;przesunięcie w lewo zmiennej pomocnicznej
rlc {tmp+2}
rlc {tmp+1}
rlc tmp
sla {iloraz+1} ;wynik nie może mieć więcej, niż 16 bitów, więc
rlc iloraz ;można przesuwać w prawo iloraz
ld A,tmp ;sprawdzenie, czy dzielna jest większa, czy równa
;od dzielnika
or A,{tmp+1}
jrne div_lw_odejmij
ld A,{tempquot+2}
cp A,divisor
jrugt divlw_odejmij
jrult divlw_bez_odejmowania
ld A,{tmp+3}
cp A,{dzielnik+1}
jrult divlw_bez_odejmowania
.divlw_odejmij ;odejmowanie dzielnika od dzielnej
ld A,{tmp+3}
sub A,{dzielnik+1}
ld {tmp+3},A
ld A,{tmp+2}
sbc A,dzielnik
ld {tmp+2},A
ld A,{tmp+1}
J.Bogusz  Podstawowe działania arytmetyczne w asemblerze ST7 str. 7/16
 sbc A,#0
ld {tmp+1},A
ld A,tmp
sbc A,#0
ld tmp,A
inc {iloraz+1} ;zwiększenie ilorazu
jrne divlw_bez_odejmowania
inc iloraz
.divlw_bez_odejmowania
dec X ;zmniejszenie licznika  przejść pętli
jrne wykonaj ;jeśli licznik = 0,to koniec inaczej kontynuacja
pop X ;odtworzenie wartości rejestrów
pop A
ret ;koniec
Listing 4. Podprogram dzielenia liczby 4-bajtowej przez 2-bajtową.
J.Bogusz  Podstawowe działania arytmetyczne w asemblerze ST7 str. 8/16
Dodawanie dwóch liczb 2-bajtowych bez znaku
Dodawanie dwóch liczb bez znaku, nawet o dużej liczbie bajtów, jest bardzo proste. Wystarczy dodawać bajt po
bajcie poczynając od najmłodszego bajtu, uwzględniając przeniesienie. Do zapamiętania wyniku dodawania
wystarczająca jest taka liczba bajtów, jakiej jest długość najdłuższego ze składników i flaga przeniesienia. Dla
opisywanego podprogramu są to dokładnie 2 bajty i flaga C (maksimum to $FFFF+$FFFF=$1FFFE, cyfra 1 może być
reprezentowana przez flagę przeniesienia C). Podprogram umieszczono na listingu 5. Suma zapamiętywana jest w
zmiennej sumaw, ale równie dobrze można wykorzystać do zapamiętania wyniku jeden ze składników.
;*******************************************************
;Dodawanie 2 liczb 2-bajtowych bez znaku
;argumenty:
; - add_a (2 bajty)
; - add_b (2 bajty)
;rezultaty:
; - wynik zapamiętywany w sumaw
;modyfikowane:
; - flaga C
;
;PRZYKA
AD UŻYCIA:
; ld A,#$F3
; ld add_a,A
; ld A,#$D3
; ld {add_a+1},A
; ld A,#$FC
; ld add_b,A
; ld A,#$C3
; ld {add_b+1},A
; call addw
;*******************************************************
.addw
push A ;zapamiętanie rejestrów roboczych
push X
ld A,{add_a+1} ;pobranie młodszego liczby a
add A,{add_b+1} ;dodanie młodszego liczby b
ld {sumaw+1},A ;zapamiętanie młodszego bajtu sumy
ld A,add_a ;pobranie starszego bajtu liczby a
adc A,add_b ;dodanie przeniesienia i starszego bajtu liczby b
ld sumaw,A ;zapamiętanie starszego bajtu sumy
pop X ;odtworzenie rejestrów
pop A
ret
Listing 5. Podprogram dodawania dwóch liczb 2-bajtowych bez znaku.
J.Bogusz  Podstawowe działania arytmetyczne w asemblerze ST7 str. 9/16
Odejmowanie dwóch liczb 2-bajtowych bez znaku
Przy odejmowaniu liczb o większej liczbie bajtów należy postępować dokładnie tak samo, jak w przypadku
dodawania. Począwszy od najmłodszego bajtu odejmować z pożyczką bajt po bajcie. Rozmiar wyniku ponownie jest
taki sam, jak długość najdłuższej liczby. Flaga przeniesienia sygnalizuje, czy odjemna jest większa odjemnika, czy też
mniejsza. Przykładowy podprogram odejmowania umieszczono na listingu 6.
;*******************************************************
;Odejmowanie 2 liczb 2-bajtowych bez znaku
;argumenty:
; - sub_a (odjemna,2 bajty)
; - sub_b (odjemnik,2 bajty)
;rezultaty:
; - wynik zapamiętywany w roznicaw
;modyfikowane:
; - flaga C
;
;PRZYKA
AD UŻYCIA:
; ld A,#$F3
; ld sub_a,A
; ld A,#$D3
; ld {sub_a+1},A
; ld A,#$FC
; ld sub_b,A
; ld A,#$C3
; ld {sub_b+1},A
; call subw
;*******************************************************
.subw
push A ;zapamiętanie rejestrów roboczych
push X
ld A,{sub_a+1} ;pobranie młodszego liczby a
sub A,{sub_b+1} ;dodanie młodszego liczby b
ld {roznicaw+1},A ;zapamiętanie młodszego bajtu różnicy
ld A,sub_a ;pobranie starszego bajtu liczby a
sbc A,sub_b ;odjęcie przeniesienia i starszego bajtu liczby b
ld roznicaw,A ;zapamiętanie starszego bajtu roznicy
pop X ;odtworzenie rejestrów
pop A
ret
Listing 6. Podprogram odejmowania dwóch liczb 2-bajtowych bez znaku.
J.Bogusz  Podstawowe działania arytmetyczne w asemblerze ST7 str. 10/16
Sprawdzenie, czy liczba 2-bajtowa bez znaku mieści się w podanym zakresie
Podprogram sprawdza, czy liczba 2-bajtowa znajduje się w zadanym zakresie wartości. Zmienna data zawiera liczbę
do przetestowania, zmienna min określa wartość minimalną a max  maksymalną. Stan flagi C po opuszczeniu
podprogramu jest zależny od rezultatu testu. Wartość logiczna flagi C równa  0 oznacza, że testowana zmienna
mieści się w zakresie od min do max, natomiast wartość  1 oznacza, że leży poza nim. Na rysunku 7 umieszczono
schemat podprogramu testującego, natomiast listing 7 zawiera jego kod z
ródłowy.
Rysunek 7. Schemat podprogramu testującego, czy zmienna leży w zakresie od min do max
J.Bogusz  Podstawowe działania arytmetyczne w asemblerze ST7 str. 11/16
;*******************************************************
;Testowanie, czy zmienna (data > min) i (data < max)
;argumenty:
; - data (2 bajty,testowana liczba)
; - min (wartość minimalna,2 bajty)
; - max (wartość maksymalna, 2 bajty)
;rezultaty:
; - C=0, gdy min < data < max inaczej C=1
;modyfikowane:
; - flaga C
;
;PRZYKA
AD UŻYCIA:
; ld A,#$25
; ld data,A
; ld A,#$00
; ld {data+1},A
; ld A,#$00
; ld min,A
; ld A,#$C3
; ld {min+1},A
; ld A,#$CC
; ld max,A
; ld A,#$05
; ld {max+1},A
; call check_min_max
;*******************************************************
.check_min_max
push A ;zapamiętanie rejestrów roboczych
push X
ld X,data ;pobranie do X bardziej znaczącego bajtu do testu
ld A,{data+1} ;pobranie do A mniej znaczącego bajtu
cp X,max ;porównanie bardziej znaczącego bajtu z max (maksimum)
jrugt out_of_range ;jeśli większy, to wyjście
jrne comp_min ;jeśli równy, to porównanie mniej znaczącego bajtu
cp A,{max+1}
jrugt out_of_range ;mniej znaczący bajt większy - wyjście
comp_min
cp X,min ;to samo dla wartości minimalnej min
jrult out_of_range
jrne in_range
cp A,{min+1}
jrult out_of_range
in_range
rcf ;zmienna mieści się w zakresie  C=0
jra check_exit
out_of_range
scf ;zmienna poza zakresem  C=1
check_exit
pop X ;odtworzenie rejestrów roboczych
pop A
ret
Listing 7. Podprogram testujący, czy liczna mieści się w zakresie od min do max
J.Bogusz  Podstawowe działania arytmetyczne w asemblerze ST7 str. 12/16
Sprawdzenie odchylenia od środkowej liczby 2-bajtowej
Funkcjonalnie podprogram jest bardzo zbliżony do poprzednio prezentowanego. Poprzedni testował, czy zmienna
mieści się w zakresie min  max, ten sprawdza  po podaniu parametrów: środkowa, delta (odchylenie) i zmiennej
data  czy zmienna nie przekracza zadanego odchylenia delta. Podprogram kończy pracę sygnalizując rezultat testu
przy pomocy flagi przeniesienia C. Gdy ta jest ustawiona, to zmienna przekracza zadane odchylenie, natomiast gdy
jest zerem, to zmienna mieści się w zakresie srodkowa-delta < data < srodkowa+delta.
Rysunek 8. Schemat podprogramu testującego, czy zmienna mieści się w zakresie odchyłki środkowa ą "
J.Bogusz  Podstawowe działania arytmetyczne w asemblerze ST7 str. 13/16
 ;*******************************************************
;Testowanie, czy zmienna (data > środkowa-delta) i
;(data < środkowa+delta)
;argumenty:
; - data (2 bajty,testowana liczba)
; - delta (wartość odchylenia,2 bajty)
; - srodkowa (wartość środkowa, 2 bajty)
;rezultaty:
; - C=0, gdy zmienna nie przekracza odchylenia, inaczej C=1
;modyfikowane:
; - flaga C
;
;PRZYKA
AD UŻYCIA
; ld A,#$25
; ld data,A
; ld A,#$00
; ld {data+1},A
; ld A,#$00
; ld delta,A
; ld A,#$23
; ld {delta+1},A
; ld A,#$CC
; ld srodkowa,A
; ld A,#$05
; ld {srodkowa+1},A
; call check_range
;*******************************************************
.check_range
push X ;zapamiętanie rejestrów roboczych
push A
ld A,srodkowa ;pobranie starszego bajtu wartości środkowej i
ld add_a,A ;zapamiętanie jej w zmiennych add_a i sub_a
ld sub_a,A ;dla podprogramów addw i subw
ld A,{srodkowa+1} ;to samo dla młodszego bajtu
ld {add_a+1},A
ld {sub_a+1},A
ld A,delta ;to samo dla delta, ale w zmiennych add_b i sub_b
ld add_b,A
ld sub_b,A
ld A,{delta+1}
ld {add_b+1},A
ld {sub_b+1},A
call addw ;obliczenie sumy srodkowa + delta
jrnc no_ovfmax ;jeśli przekroczono zakres,to ustaw wartość MAX na
ld A,#$FF ;$FFFF (maksymalna dla 2 bajtów)
ld max,A
ld {max+1},A
no_ovfmax
ld A,res_add ;jeśli nie ma przekroczenia zakresu, to wówczas
ld max,A ;za maksimum przyjmij wyliczoną wartość
ld A,{res_add+1}
ld {max+1},A
call subw ;obliczenie wartości srodkowa-delta
jrnc no_ovfmin ;jeśli wystąpiło przeniesienie, to wartość minimum
clr A ;ustaw na 0
ld min,A
ld {min+1},A
no_ovfmin
ld A,res_sub ;jeśli nie ma przeniesienia,to za minimum przyjmij
ld min,A ;wyliczoną w wyniku odejmowania wartość
ld A,{res_sub+1}
ld {min+1},A
call check_min_max ;wywołaj podprogram i sprawdz
, czy zmienna jest w
;zakresie ustalonym przez MIN i MAX
pop A ;odtworzenie rejestrów roboczych
pop X
ret
J.Bogusz  Podstawowe działania arytmetyczne w asemblerze ST7 str. 14/16
Listing 8. Podprogram sprawdzający, czy zmienna mieści się w zakresie środkowa ą "
Konwersja liczb binarnych na dziesiętne.
Podprogram wykonuje konwersję liczby binarnej bez znaku zawartej w akumulatorze, to jest z zakresu od 0 do 255,
na liczbę dziesiętną. Po zakończeniu zmienne setki i dziesiatki zawierają wartości w kodzie BCD otrzymane w wyniku
konwersji (zmienna setki zawiera cyfrę setek, zmienna dziesiatki cyfry dziesiątek i jedności). Schemat funkcjonowania
podprogramu umieszczono na rysunku 9, a listing 9 zawiera jego kod z
ródłowy.
Rysunek 9. Schemat podprogramu konwersji liczby binarnej na dziesiętną
J.Bogusz  Podstawowe działania arytmetyczne w asemblerze ST7 str. 15/16
 ;*******************************************************
;Konwersja liczby 1-bajtowej, binarnej na dziesiętną
;argumenty:
; - liczba w akumulatorze
;rezultaty:
; - setki: cyfra setek
; - dziesiątki: cyfra dziesiątek i jednostek
;modyfikowane:
; - flaga C, Z, zmienne wyniku
;
;PRZYKA
AD UŻYCIA
; ld A,#$D4
; call BtoD
.BtoD
clr setki ;inicjacja zmiennych
clr dziesiatki
hund
sub A,#100 ;A = A - 100
jrc ten ;sprawdzenie, czy A < 100
inc hundreds ;jeśli nie, to zwiększanie licznika setek
jra hund ;pętla do spełnienia w/w warunku
ten
add A,#100 ;dodanie 100, aby uzupełnić A po ostatniej operacji
temp ;(nastąpiło przekroczenie zakresu)
sub A,#10 ;A = A - 10
jrc unit ;jak w przypadku setek  sprawdzenie, czy A < 10
inc tens ;i jeśli nie, to zwiększanie licznika 10-tek
jra temp ;pętla do spełnienia w/w warunku
unit
add A,#10 ;dodanie 10, aby uzupełnić A po ostatnim odejmowaniu
swap tens ;zamiana połówek bajtu tak, aby bardziej znaczący bajt
;zawierał cyfrę dziesiątek
or A,tens ;dodanie jednostek (A zawiera jednostki po odejmowaniu
ld tens,A ;setek i dziesiątek)
ret
Listing 9. Konwersja liczby 1-bajtowej w kodzie binarnym na dziesiątną.
J.Bogusz  Podstawowe działania arytmetyczne w asemblerze ST7 str. 16/16