CS061-Assignment 3 Solved

The purpose of this assignment is to give you more practice with I/O, and with left-shifting, multiplying by 2,  and useful 2’s complement logic.

 

High Level Description 

Store a number to the memory address specified in your assn 3 template​      . In your program, load​           that number in a register, and display it to the console as 16-bit two's complement binary (i.e. display the binary value stored in the register, as a sequence of 16 ascii '1' and '0' characters). Note​: Valid numbers are [#-32768, #32767] (decimal) or [x0000, xFFFF] (hex) 

 

Your Tasks 

You do not yet know how to take a multi-digit decimal number from user input and convert it to binary, so for this assignment you are going to let the assembler to do that part for you:  you will use the .FILL pseudo-op to take a literal (decimal or hex, as you wish) and translate it into 16-bit two's complement binary, which will be stored in the indicated memory location; and then you will Load that value from memory into a register.

 

You ​MUST​ use the provided assn3.asm template to set this up: it ensures that the number to be converted is always stored in the same location (the ​memory address specified in your template​) so we can test your work; make sure you fully understand the code fragment we provide.

At this point, your value will be stored in, say, R1: it is now your job to identify the 1’s and 0’s from the number and print them out to the console one by one, ​from left ​ (​ the leading bit, aka the leftmost bit, aka bit 15, aka the most significant bit)​ ​to right​ ​(the trailing bit, aka the rightmost bit, aka bit 0, aka the least significant bit)​.

Important things to consider:

●      Recall the difference between a positive number and a negative number in 2’s complement binary: if the most significant bit (MSB) is 0, the number is considered positive (or perhaps zero); if it is 1, the number is negative.

●      The ​BR​anch instruction has parameters (n, z, p) which tell it to check whether a value is n​egative, ​z​ero, or ​p​ositive (or any combination thereof). 

Hint​: what can you say about the msb of the LMR if the n branch is taken?

Review the workings of the NZP condition codes and the BR instruction ​here​ . 

●      Once you are done inspecting the MSB and printing the corresponding ascii '0' or '1', how would you shift​ ​ the next bit into its place so you could perform the next iteration?  

Hint​: the answer is in the objectives!

Pseudocode:

     for(i = 15 downto 0):           if (msb is a 1):                print a 1           else:                print a 0           shift left 

Expected/ Sample output 

In this assignment, your output will simply be the contents of R1, printed out as 16 ascii 1's and 0's, grouped into packets of 4, separated by spaces ​(as always, newline terminated, but with ​NO terminating space!) 

 

So if the hard coded value was xABCD, your output will be:

1010 1011 1100 1101 

 

  

(The value stored to memory with .FILL was xABCD)

 

Note: 

1.     There are  ​spaces​ after the first three "packets" of 4 bits (but ​no​ space character at end!) 

2.     There is a ​newline ​after the output - again, there is ​NO​ space before the ​newline 

3.     You ​must ​use the memory address specified in your template to hold  the value to be output 

 

Your code will obviously be tested with a range of different values:  Make sure you test your code likewise!

 

 

 

 

 

 

 

 

             

Uh…help? 

●      MSB

○ Stands for Most Significant Bit

■ aka “left most bit” or “leading bit” or bit 15 ○ When MSB is 0:

■ Means that the number is Not Negative​       (Positive or Zero)​        ○ When MSB is 1:

                                       ■ Means that the number is Negative​  

○ Further Reading 

■ https://en.wikipedia.org/wiki/Most_significant_bit

 

●      Left Shifting 

Left shifting means that you shift all the bits to the left by 1: so the MSB is lost, and is replaced by the bit on its right. A 0 is "shifted in" on the right to replace the previous LSB.

 

4-bit Example:

0101 ; #5 

When Left Shifted, with 0 shifted in to LSB: 

1010 <---- 0101 

1010 ; #10 

 

What happened when we left shifted? How did the number change?  

When left shifting, the number gets multiplied by 2? Why 2?  

Well, what happens when you shift a decimal​          ​ number one place to the left? Why? (Practical differences between decimal and binary numbers are that we don't usually limit decimal numbers to a specific number of places, nor do we usually pad them with leading zeros).