You are to write simple MSP$430$ assembly functions for a program that will take a decimal number and a base as input and output the value in that specified base. For example:

$>2367098$

$116245$

$>132$

$1101$

$>297082$

$111010000001100$

$>581523$

$2221202210$

$>484354$

$23310303$

$>345676$

$424011$

$>510066$

$1032050$

$>515669$

$77655$

$>3760820$

$4$E$08$

$>5915630$

$25$LQ

$>244037$

$1$SZ

$>244137$

$1$Sa

$>244237$

$1$T$0$

$>2837464$

$6$xM

$>40080256$

$156\mathrm{.}144$

$>45600256$

$178\mathrm{.}32$

$>2903865$

$0$

$>1231$

$0$

$>678902$

$100100110010$

This is just example output, you should test against as many possible inputs as you can.

Your program should be able to handle all bases from $2$ to $64$ and $256.$

It must have $6$ completed assembly functions:

unsigned convert$($unsigned decimal, unsigned base$)$

unsigned other$\_$base$($unsigned decimal, unsigned base$)$

unsigned power$2\_$base$($unsigned decimal, unsigned base$)$

unsigned base$\_256($unsigned decimal, unsigned base$)$

unsigned log$\_2($unsigned value$)$

unsigned rshift$($unsigned value, unsigned amount$)$

The call graph of a possible solution program looks like:

convert

$$ power$2\_$base

$$ log$\_2$

$$ rshift

$$ other$\_$base $$

$$ umod $$

$$ udiv $$

$$ base$\_256$

$$ log$\_2$

$$ other$\_$base

Submit only the modifications to the files in the func folder

When unexpected input is given, a $0$ should be output to minicom $($see above$)$

Don't worry about overflow

Converting Integers to Characters

Think about how to use this character array:

char $*$ascii $="0123456789$ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz$+/"$;

The character $1$ is not the same as the value $1.$ If you need to know which numeric values correspond to which on screen characters, look at man ascii in your terminal.

Division & Modulo

This algorithm is suitable for any base that is not a power of two and is not base $256($other$\_$base$()$ function$).$

Let's see an example of converting the decimal number $29$ into base $5.$ How many different values are there for base $5$: $0,1,2,3$ and $4.$ So you should expect all of our digits to be one of those numbers. Get the first digit by calculating the remainder of $29/5$:

$\_\_5$

$5|29$

$25$

$\_\_\_$

$4$

The result of $29/5$ is $5$ with a remainder of $4.$

There is a special operator for this in almost all programming languages: $\%($modulo$)$ operator. This will give the remainder instead of the quotient.

$29\%5=4$

This is the first digit $($ones digit$)$ of the base $5$ number. To continue, you start from the quotient of this operation. Division in C is integer division $($just like in Python$3$ using $//),$ so the remainder is discarded when you do:

$29/5=5$

Now, continue with the algorithm:

$\_\_1$

$5|5$

$5$

$\_\_\_$

$0$

The result of $5/5$ is $1$ with a remainder of $0.$

$5\%5=0$

This is the second digit $($fives digit$)$ of the base $5$ number.

$5/5=1$

The algorithm continue until this division results in $0$:

$\_\_0$

$5|1$

$0$

$\_\_\_$

$1$

Now we have a remainder of $1$ and the result of the integer division is $0.$

The number $29$ in base $5$ is $104.$

Mask & Shift

This algorithm is suitable for any base that is a power of two and is not base $256($power$2\_$base$()$ function$).$

What if you are trying to convert the number $7$ into base $4?$ How many bit patterns are there for base $4?$

$00$

$01$

$10$

$11$

which is $0,1,2$ and $3.$ Let's see how masking works:

$0111=7$

& $0011=3$

$\_\_\_\_\_\_\_\_\_\_$

$0011=3$

You've "masked off" the first digit, which is $3,$ by using the & $($bitwise AND$)$ operator. Now you can shift those bits to the right using the $>>($bitwise RIGHT SHIFT$)$ operator like so:

$7>>2=01$

And continue with the algorithm:

$01=1$

& $11=3$

$\_\_\_\_\_\_\_\_$

$01=1$

The number $7$ in base $4$ is $13.$

Base $256$

This algorithm will only be used for base $256($base$\_256()$ function$).$

It will involve using both previous algorithms. Since this is a power of $2,$ mask & shift must be utilized. However, the values you get will be numbers between $0$ and $255.$ The ascii character array doesn't have that many different characters in it$,$ so instead you will represent base $256$ numbers in the same format as IP addresses:

$172\mathrm{.}16\mathrm{.}1\mathrm{.}255$

Each place value is separated by a $.$ character. The division & modulo algorithm will be used to calculate each digit of the decimal number for each place value.

In the above example, the ones place shows the number $255$ which would have been calculated using mask & shift from the input number. Then that value needs to be placed in the buffer as a three digit decimal number by using the division & modulo algorithm.