+1 (315) 557-6473 

Program To Calculate Hamming Code in X86 Assembly Language Assignment Solution.


Write a program to calculate Hamming code in x86 Assembly language.

Requirements and Specifications

Write an x86 assembler program that will use the Hamming Code to analyze a given 32 bit hex word (though only the first 31 bits are relevant) and identify what, if any, bit is in error. This 32-bit word will include both data and parity bits. The parity bits are in positions: 1, 2, 4, 8, 16 and 32; all other bits are data bits. The program will work for either an even or odd parity scheme (to be determined by the user). Examples of program sessions are given below.
Keep the following things in mind:
  • The LSB is the rightmost bit; the MSB is the leftmost bit. Given this, three of the first four low order bits are parity bits (1, 2, and 4).
  •  While Hamming codes are typically covered in CSPC 141, I will do a quick review of the topic in class. I have also provided the related slides in the Zip file. Obviously, you can also Google the topic.
  • The 32-bit word input may be up to eight (8) hex digits.
  •  Only one bit can be in error (data or parity bit).
  • Since bit 32 is a parity bit with no data bits. While I could insist that it be set based on the parity type (0 for even, 1 for odd), that would open up the possibility that multiple bits may be in error. Given this, it is best to just ignore it. Note that it is zero in all my sample test cases.
  • You should be able to reuse the code in Programming Assignment #4 to help solve this problem (yes—that was intentional). However, if your PA #4 solution did not work perfectly, be sure to fix it in order to use it on this problem.
  • Hint: the LSB of an integer determines if it is even or odd.
Calculate Hamming code in x86 Assembly language Calculate Hamming code in x86 Assembly language 1 Calculate Hamming code in x86 Assembly language 2 Calculate Hamming code in x86 Assembly language 3

Source Code

TITLE Hamming code analyzer

; This program asks the user to enter a 32-bit word, up

; to eight hex digists. Then the program determins the powers

; of two that contribute to every set bit in that number.

INCLUDE Irvine32.inc


Proginfo BYTE "CPSC 232 - Hamming code analyzer", 0

PromptParity BYTE "Input the parity type (0-even, *-odd) >> ", 0

PromptWord BYTE "Input the received word (8 hex digits) >> ", 0

NoError BYTE "No bits in error", 0

Error BYTE "The bit in error is: ", 0

Corrected BYTE "The corrected word is: ", 0

parity DWORD 0

number DWORD 0

position DWORD 0

parity1 DWORD 55555555h

parity2 DWORD 66666666h

parity4 DWORD 78787878h

parity8 DWORD 7F807F80h

parity16 DWORD 7FFF8000h


; Number is in eax, parity to use is in ebx, returns the bit error in eax, 0 if no error

getHammingError PROC

          sub esp, 4

          mov edi, ebx ; copy parity to edi

          mov esi, OFFSET parity1 ; point to start of parities

          mov edx, 0 ; clear edx to use for error bits

          mov ecx, 1 ; check the 5 parities


          mov ebx, [esi] ; check for parity 1

          and ebx, eax ; isolate bits

          mov [esp], ebx ; save result in stack

          xor bl, [esp + 1] ; test 32 bit parity

          xor bl, [esp + 2]

          xor bl, [esp + 3]

          cmp edi, 0 ; if even parity

          jne chkOdd ; if not, check odd

          or bl, bl

          jp next ; if parity is ok, go to next

          or edx, ecx ; else set error in current bit

          jmp next


          or bl, bl

          jnp next ; if parity is ok, go to next

          or edx, ecx ; else set error in current bit


          add esi, 4 ; advance to next parity entry

          shl ecx, 1 ; increment parity to check

          cmp ecx, 16 ; see if it's the last parity

          jle chkloop ; if not, keep checking

          mov eax, edx ; return found error

          add esp, 4


getHammingError ENDP

; Corrects bit in word eax, bit is in ebx, returns corrected word

correctBit PROC

          mov ecx, ebx ; copy bit number to ecx

          dec ecx ; decrement bit number

          mov ebx, 1 ; load 1 in ebx

          shl ebx, cl ; shift 1 to bit position

          xor eax, ebx ; invert bit to correct it


correctBit ENDP

main PROC

  mov edx, OFFSET Proginfo

  call WriteString

  call Crlf

  call Crlf

     mov edx, OFFSET PromptParity

  call WriteString

  call ReadChar

  call WriteChar

          call Crlf

          cmp al, '0' ; compare input with '0'

          je start ; if 0, parity is even, start calculation

          mov DWORD PTR [parity], 1 ; else, set odd parity


  mov edx, OFFSET PromptWord

  call WriteString

  call ReadHex

          mov [number], eax ; save number

          mov ebx, [parity]

          call getHammingError ; calculate hamming error

          mov [position], eax ; save position in variable

          cmp eax, 0 ; see if there were errors

          je parityOk ; if not, go to ok

  mov edx, OFFSET Error ; if error, print error

  call WriteString

          call WriteDec ; print position

          call CrLf

          mov eax, [number] ; load original number

          mov ebx, [position] ; load error position

          call correctBit ; correct the bit

  mov edx, OFFSET Corrected ; print corrected message

  call WriteString

          call WriteHex ; print corrected word

          jmp done


  mov edx, OFFSET NoError

  call WriteString


          call CrLf


main ENDP

END main