Bubble Sort algorithm implemented in Assembly Language for Freescale HCS08 family chips using Code Warrior.

1.
2016
Lab
1
Bubble Sort Algorithm implemented in Assembly
Language
学生姓名:ARIEL
TONATIUH
ESPINDOLA
PIZANO

2. Microcontroller Units Tongji University 2
Bubble Sort Algorithm implemented in Assembly Language
Objective
The aim of this practice is to get familiar with the developing tool CodeWarrior, the directory
structure and tools, creating a project for a Sorting Algorithm and debugging it.
Project features：
-­ Device MC9S08AW60
-­ Connections full chip simulator
-­ Absolutely assembly
Algorithm
The principle is to compare each “element” to its immediate “neighbor” moving from the left to
the right.
12 45 22 25 56 38 10 05
If the “element” is greater than “neighbor” then SWAP, otherwise go ahead to the next element.
Therefore, 12 is not greater than 45 then go ahead, advance one step and compare again.
12 45 22 25 56 38 10 05
Now 45 is greater than 22 then swap, advance one step and compare again.
12 22 45 25 56 38 10 05
It is applied the same logic in every iteration. Finally, in this case the number 56 will be floated
to the right at the end of the array (that’s why “bubble”).
12 22 25 45 38 10 05 56
𝑎"
𝑎$ 𝑎% 𝑎& 𝑎' 𝑎( 𝑎) 𝒂 𝟕
Where 𝑎, is each element of the sequence and 0 ≤ 𝑖 ≤ 𝑁 − 1
Now is sorted just one single number of the array. The last steps should be repeated for every
single element in the sequence, that means N times where N would be the length of the such
array.
element
neighbor
element
neighbor
element
neighbor

3. Microcontroller Units Tongji University 3
Algorithm step by step
1. Get the length of the sequence
2. Take the first element and compare it with the immediately neighbor to the right:
𝑎, > 𝑎,4$
-­ If true: swap and increment 𝑖 by one.
-­ If false: increment 𝑖 by one.
3. Repeat step 2, N-­1 times.
Pseudo code
While k < N
For i=0 to N-1
If a[i] > a[i+1]
Then
swap()
end
k=k+1
end
Flowchart
Start
A[i]
>
A[i+1]
i=i+1
no
yes
swap
K
<
N
i
<
N-­‐1
yes
no
yes
K=K+1
done
no

4. Microcontroller Units Tongji University 4
Complexity
In each cycle the algorithm compares every couple of consecutive elements and if they are not
ordered, then swap them.
This process is repeated N times by N elements, here it is inferred a complexity of 𝑶(𝑵 𝟐
)
The optimization would be reached by sensing if there are no swaps to do, if so then the elements
are already sorted and break.
Implementation in C
int* sort(int *x,int N){
int i = 0,j,swaps;
while(i < N){
for (int j = 0; j < N-1; j++){
if (x[j] > x[j+1]){
swaps++;
int t = x[j];
x[j] = x[j+1];
x[j+1] = t;
}
}
i++;
}
printf("swaps: %dn",swaps);
return x;
}
Implementation in Assembly
; Include derivative-specific definitions
INCLUDE 'derivative.inc'
;
; export symbols
;
XDEF _Startup
ABSENTRY _Startup
;
; variable/data section
;
ORG Z_RAMStart ; Insert your data definition here
Counter: DS.B 1
InnerCnt: DS.B 1
;
; code section
;
ORG ROMStart
_Startup:

5. Microcontroller Units Tongji University 5
LDHX #RAMEnd+1 ; initialize the stack pointer
TXS
CLI ; enable interrupts
MOV #$12,$80 ; unsorted numbers from $80 - $89
in memory
MOV #$45,$81
MOV #$22,$82
MOV #$25,$83
MOV #$56,$84
MOV #$38,$85
MOV #$10,$86
MOV #$05,$87
MOV #$12,$88
MOV #$02,$89
mainLoop:
LDA #10 ; size of the array (outer
iterations)
STA Counter
CLRA
LDHX #$0000
outerLoop: LDA #9 ; number of inner iterations
STA InnerCnt
CLRA
BSR Sort ; branch to subroutine
DBNZ Counter, outerLoop
BRA done ; end of the program
Sort:
NOP
LDX #$80
Loop:
LDA ,X ; A = X[i]
CMP $1,X ; X[i] ? X[i+1]
BLT round ; if smaller -> round again
BGT swap ; if greater, then -> SWAP
BRA round ; if not -> round again
swap: NOP
PSHA ; store t = X[i] in stack
(temp)
LDA $1,X ; X[i+1]
STA X ; X[i] = X[i+1]
PULA ; t
STA $1,X ; X[i+1] = t
round: AIX #1 ; i++; increment the
index
CLRA
DBNZ InnerCnt,Loop ; decrese counter and back to the
loop
RTS
done: feed_watchdog
STOP
;BRA mainLoop
;**************************************************************

6. Microcontroller Units Tongji University 6
;* spurious - Spurious Interrupt Service Routine. *
;* (unwanted interrupt) *
;**************************************************************
spurious: ; placed here so that security value
NOP ; does not change all the time.
RTI
;**************************************************************
;* Interrupt Vectors *
;*******************************ExampleVar*******************************
ORG $FFFA
DC.W spurious ;
DC.W spurious ; SWI
DC.W _Startup ; Reset