Computer Architecture and Assembly Language Assignment 1

Page    1 of    4
Computer    Science 230
Computer    Architecture    and    Assembly    Language
Assignment    1

Programming    environment
For    this    assignment    you    must    ensure    your    work    executes    correctly    on    the    simulator    
within AVR    Studio 7 as    installed    on    workstations    in    ECS    249.    If    you    have    installed    
AVR    Studio    on    your    own    then you    are    welcome    to    do    much    of    the    programming    
work    on    your    machine.    (The    IDE    is    available    at    no charge from    
https://bit.ly/2VIArVA but    comes    only    in    the    Windows    10    flavour.)    You    must    
allow    enough    time to    ensure    your    solutions    work    on    the    lab    machines.    If    your    
submission    fails    to    work    on    a    lab    machine,    the fault    is    very    rarely    that    the    lab    
workstations.    “It    worked    on    my    machine!”    will    be    treated    as    the    equivalent    of    “The    
dog    ate    my    homework!”
Individual    work
This    assignment    is    to    be    completed    by    each    individual    student    (i.e.,    no    group    work).    
Naturally    you    will    want    to    discuss    aspects    of    the    problem    with    fellow    students,    and    
such    discussion    is    encouraged.    However,    sharing    of    code fragments is    strictly    
forbidden    without    the    express    written    permission    of    the    course    instructor    
(Zastre). If    you    are    still    unsure    regarding    what    is    permitted    or    have    other    questions    
about    what    constitutes    appropriate    collaboration,    please    contact    me    as    soon    as    
possible.    (Code-similarity    analysis    tools    will    be    used    to    examine    submitted    work.)
The    URLs    of    significant    code    fragments    you    have    found    and    used    in    your    solution    
must    be    cited    in    comments    just    before    where    such    code    has    been    used.
Objectives    of    this    assignment
• Understand    short    problem    descriptions    for    which    an    assembly-language    
solution    is    required.
• Use    AVR    assembly    language    to    write    solutions    to    three    such    small    problem.
• Use    AVR    Studio    to    implement,    simulate    and    test    your    solution.    (We    will    not    
need    to    use    the    Arduino    mega2560    boards    for    this    assignment.)
• Hand    draw    a    flowchart    corresponding    to    your    solution    to    the    first    problem.
Page    2 of    4
Part    (a):    Computing    Hamming    distance
Digital-communication    hardware    and    software    often    includes circuity    and    code    for    
detecting    errors    in    data    transmission.    In    fact,    nearly    all    dynamic-memory    devices    
include an    error-correcting    code    called    a    Hamming    code.    While    it    may    be    a    little    
premature    to    implement    such    a    code in    our    course,    we    can    investigate    a    related    
concept    called Hamming    distance.
Consider    two    different    byte    values,    first:
0b10101100
and    then:
0b11101010
In    order    to    convert    one    of    the    byte    values    into    the    other,    we    could    flip    bits    in    specific    
positions,    i.e.,    those    positions    where the    bits    are    different    between    the    two    bytes.    In    
our    example,    the    bits    in    three    positions are different:    positions    6,    2    and    1    (i.e.,    recall    
that    bit    position    7    is    the    leftmost    bit,    while    bit    position    0    is    always    the    rightmost    
bit).    We    can    therefore    state that    the    Hamming    distance of    these    two    byte    values    is    
equal    to    three.
Your    task for    part (a) is    to    complete    the    code    in    the    file    named
hamming_distance.asm in    the    project    csc230_a1_part_a provided    to you.    Please    
read    the    ASM file    for    more    detail    on    what    is    required.    Amongst    other    AVR    machine    
instructions,    you    will    need    to    use    bit    shift,    logical    AND,    arithmetic    ADD,    and    
branching. Do    not    use    functions.    You    must    also    draw    by    hand the    flowchart    of    your    
solution    and    submit    a    scan    or    smartphone    photo    of    the    diagram    as    part    of    your    
assignment    submission;    please    ensure    this    is    a    JPEG    or    PDF    named    
“hamming_distance_flowchart.jpg”    or    “hamming_distance_flowchart.pdf”    
depending    on    the file format    you    have    chosen.
Part    (b):    Reversing    the    order    of    bits    in a    word
Recall    that    in our    course    we    define    a    word    to    be    a    16-bit    sequence    (i.e.,    two    
consecutive    bytes).    For    some    algorithms    it    is    useful    to    have    a    reversed    version    of    
that    16-bit    sequence.    (The    deeply    curious    can    read    a    brief    description about    such    
use    in    Fast    Fourier    Transform    algorithm    implementations    by    visiting Wikipedia    at
this    link:    http://bit.ly/2rnvwz6).
Your    task    for    part (b) is    to    complete    the    code    in    reverse.asm in    the    project    
csc230_a1_part_b provided    to    you.    Please    read    the    ASM    file for    more    detail    on    
what    is    required.    Amongst    other    AVR    machine    instructions,    you    will    need    to    use    bit    
shift,    logical    AND,    arithmetic    ADD,    and    branching. Do    not    use    functions.
Page    3 of    4
Part    (c):    Binary    Coded    Decimal
In    lectures    we    have    seen    that    a    number    such    as    7210 may    be    represented    in    binary    
as    0b01001000.    Another    form    of    representing    decimal    numbers that    was    once
popular    is called    binary-coded    decimal    (BCD) where    each    decimal    digit    (from    0    to    
9)    was    encoded    in    a    four-bit    field.    The    BCD    representation    of    7210 is    0b01110010,    
i.e.,    where    the    left    nibble    (0111)    represents    7    and    the    right    nibble    (0010)    represents    
2.    A    larger    decimal    number    would    therefore    require    more    groups    of    four    bits,    that    is,    
four    bits    per    decimal    digit.
Although    it    would be    fun    write    code    that converts a    binary    number    into    its    BCD    
equivalent,    for    this    assignment    you    will    instead    implement    the    other    direction (BCD    
into    its    binary    equivalent)    as    it    is    a    bit    easier    to    code.    That    is,    when    given    a    BCD    
number    such    as    0b01110010,    your    program    will    produce    the    binary-number    
equivalent    of    0b01001000.
Your    task    for    part    (c)    is    to    complete    the    code    in    bcd2binary.asm in    the    project    
csc230_a1_part_c provided    to    you.    In    that    file    there    are    some    comments    giving    
several    simplifying    assumptions.    Please    read    the    ASM    file    for    more    detail    on    what    is    
required. Amongst other    AVR    machine    instructions you    will    need    to    use    bit    shift,    
logical    AND,    arithmetic    ADD,    and    branching. Do    not    use    functions.    You    may    assume    
that    all    byte    values    used    to    test    your    submission    will    be    made    up    of    properly    formed    
BCD    numbers.
What    you    must    submit
• Your    completed    work    in    the    three    source    code    files    
(hamming_distance.asm,    reverse.asm,    bcd2binary.asm).    Do    not    change    
the    names    of    these    files! Please    do    not    submit    any    other    AVR    7    Studio    project    
files.
• Your    work    must    use    the    provided    skeleton    files.    Any    other    kinds    of    solutions    
will    not    be    accepted.
• The    scan    /    smartphone    photo    of    your    hand-drawn    flowchart    with    the    name    
of    “hamming_distance_flowchart.jpg”    or    
“hamming_distance_flowchart.pdf”    depending    on    the    format    you    have    
chosen.
Page    4 of    4
Evaluation
• 3 marks:    Hamming-distance solution    is    correct    for    a    variety    of byte    pairs
values (part    a).
• 1    mark:    Hand-drawn    flowchart    for    Hamming-distance solution    is    correctly    
prepared    (part    a).
• 3    marks:    Reverse    solution    is    correct    for    different    word    values (part    b).
• 2 marks:    BCD2binary solution    is    correct    for    different    values    BCD    values    (part    
c).
• 1    mark:    All    submitted    code    is    properly    formatted    (i.e.,    indenting    and    
comments    are    suitably used),    and    files    correctly    named.
Total    marks:    10