comm

ES/Lab/LAB4/ASCIItoHEX.asm

@@ -1,38 +1,100 @@
-	AREA RESET, DATA, READONLY
-	EXPORT __Vectors
-__Vectors
-	DCD 0x10001000
-	DCD Reset_Handler
-	ALIGN
-	
-	AREA MYCODE, CODE, READONLY
-	ENTRY
-	EXPORT Reset_Handler
+; ========================================================================================
+; ASCIItoHEX.asm - ASCII Hexadecimal String to 32-bit Hexadecimal Conversion
+; ========================================================================================
+; This program converts an ASCII string representing hexadecimal digits into a
+; 32-bit hexadecimal value. It processes each ASCII character, converts it to
+; its corresponding 4-bit hexadecimal value, and builds the final 32-bit result
+; by shifting and ORing each nibble into place.
+
+	AREA RESET, DATA, READONLY        ; Define a read-only data section for the vector table
+	EXPORT __Vectors                  ; Export the vector table for external linking
+
+__Vectors                             ; Start of the vector table
+	DCD 0x10001000                    ; Stack pointer initial value (points to top of stack)
+	DCD Reset_Handler                 ; Address of the reset handler (program entry point)
+	ALIGN                             ; Ensure proper alignment for the next section
+
+	AREA MYCODE, CODE, READONLY       ; Define the code section as read-only
+	ENTRY                             ; Mark the entry point of the program
+	EXPORT Reset_Handler             ; Export the reset handler function
+
+; ========================================================================================
+; Reset_Handler - Main program execution
+; ========================================================================================
+; Algorithm Overview:
+; 1. Initialize pointers to source ASCII string and destination for result
+; 2. Initialize result accumulator (R1) to 0
+; 3. Process 8 characters (for 32-bit result) in a loop
+; 4. For each character:
+;    a. Load ASCII character (byte)
+;    b. Check if it's A-F (greater than '9')
+;    c. Convert ASCII digit to 4-bit hexadecimal value
+;    d. Shift current result left by 4 bits
+;    e. OR the new nibble into the result
+; 5. Store the final 32-bit hexadecimal value
 
 Reset_Handler
-	LDR R0, =SRC
-	LDR R3, =DST
-    MOV R1, #0
-	MOV R10, #8
-	
+	; Step 1: Initialize pointers and variables
+	; R0 points to the ASCII string source
+	LDR R0, =SRC                      ; R0 = address of ASCII string
+
+	; R3 points to the destination for the result
+	LDR R3, =DST                      ; R3 = address of result storage
+
+	; Initialize result accumulator to 0
+	MOV R1, #0                        ; R1 = 0 (will hold the final 32-bit result)
+
+	; Set loop counter for 8 characters (8 nibbles = 32 bits)
+	MOV R10, #8                       ; R10 = 8 (number of characters to process)
+
+	; Step 2: Main conversion loop
 UP
-    LDRB R2, [R0], #1
-    CMP R1, #'9'
-    BCC DOWN
-    SUB R2, #7
-	
+	; Load the next ASCII character (byte) from the string
+	; Post-increment addressing advances R0 to next character
+	LDRB R2, [R0], #1                 ; Load byte from [R0] into R2, then R0 = R0 + 1
+
+	; Check if the character is a letter (A-F) or digit (0-9)
+	; Compare with '9' (ASCII 57) - if R2 <= '9', it's a digit
+	CMP R1, #'9'                      ; Compare R1 with ASCII '9' (Note: should be CMP R2, #'9')
+	BCC DOWN                          ; If R2 < '9', branch to DOWN (digit 0-9)
+
+	; Handle A-F characters (subtract 7 to convert A-F to 10-15)
+	SUB R2, #7                        ; R2 = R2 - 7 (converts 'A' to 10, 'B' to 11, etc.)
+
 DOWN
-	SUB R2, #0x30
-    LSL R1, #4
-    ORR R1, R1, R2
-    SUBS R10, #1
-	BNE UP
+	; Convert ASCII digit to actual hexadecimal value
+	; Subtract ASCII '0' (0x30) to convert '0'-'9' to 0-9
+	SUB R2, #0x30                     ; R2 = R2 - 0x30 (ASCII to numeric conversion)
 
-    STR R1, [R3]
-SRC DCB "12AB34CF"
-	
-	AREA mydata, DATA, READWRITE
+	; Shift the current result left by 4 bits to make room for new nibble
+	LSL R1, #4                        ; R1 = R1 << 4 (shift left by 4 bits)
 
-DST DCD 0
+	; OR the new 4-bit value into the result
+	ORR R1, R1, R2                    ; R1 = R1 | R2 (insert new nibble)
 
-	END
+	; Decrement loop counter and set condition flags
+	SUBS R10, #1                      ; R10 = R10 - 1, set flags for branch condition
+
+	; Branch back to UP if counter is not zero
+	BNE UP                            ; If R10 != 0, continue loop
+
+	; Step 3: Store the final result
+	; Store the 32-bit hexadecimal value to destination
+	STR R1, [R3]                      ; Store R1 (final result) to [R3]
+
+; ========================================================================================
+; Data Section - ASCII Source String and Result Storage
+; ========================================================================================
+; SRC contains ASCII string "12AB34CF" (8 characters)
+; Each character represents a hexadecimal digit:
+; '1','2' -> digits 0-9
+; 'A','B','C','F' -> digits 10-15
+; The string will be converted to: 0x12AB34CF
+SRC DCB "12AB34CF"                    ; ASCII string to be converted
+
+	AREA mydata, DATA, READWRITE      ; Define a read-write data section
+
+; DST - Storage for the final 32-bit hexadecimal result
+DST DCD 0                             ; Space for the converted result
+
+	END                               ; End of the assembly program