Skip to content

6. Programas de ejemplo

Jump to bottom
Mario Esteban Fernandez edited this page Dec 14, 2021 · 1 revision

Suma de 2 numeros

define :loop_addr 0
data :loop

zero r0
addi 0010
left
left
left
left
addi 1011
copy r0r1

#00101011 en r1

zero r0
addi 0001
left
left
left
left
addi 0111
copy r0r2

#00010111 en r2

add
:loop
    left
    right
    left
    right
    left
    right
    left
    right
    left
    right
    left
    right
    copy r0r3

    zero r0
    addi :loop_addr
    copy r0r1
    ld
    copy r0r1
    copy r3r0
    jump 8

el ensamblador nos devuelve:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 
30 22 60 60 60 60 2b 81 30 21 60 60 60 60 27 82 00 60 70 60 70 60 70 60 70 60 70 60 70 83 30 2:loop_addr 81 c0 81 8c b8 

sustituyendo constantes...
{':loop_addr': '0', ':loop': '11'}

text:
30 22 60 60 60 60 2b 81 30 21 60 60 60 60 27 82 00 60 70 60 70 60 70 60 70 60 70 60 70 83 30 20 81 c0 81 8c b8 
data:
11

Fibonacci

#valor 1 en r3

zero R0
addi 1
copy R0R3

#valor 1 en R2
copy r0r2

#r3 es el valor grande, lo paso temporalmente a r1 para sumar
#r2 es el valor pequeño
:loop
    #sumo grande + pequeño
    copy R3R1
    add
    #sobreescribo el pequeño con el grande anterior
    copy R1R2
    #sobreescribo el grande anterior con el resultado
    copy R0R3

    #ahora tengo libres r0 y r1 puedo hacer jump
    #direccion de memoria en r1
    zero R0
    addi :loop
    copy R0R1
    #salto incondicional
    jump 8

el ensamblador nos devuelve:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 
30 21 83 82 8d 00 86 83 30 2:loop 81 b8 

sustituyendo constantes...
{':loop': '4'}

text:
30 21 83 82 8d 00 86 83 30 24 81 b8
data:

Siguelíneas

define :mask_sensors 3 #0011

define :loop_addr 0
define :not_found_addr 1
define :go_right_addr 2
define :go_left_addr 3
define :found_addr 4


data :loop :not_found :go_right :go_left :found 

#pseudocodigo:
#while(true){
#   sensors=readSensors()
#   if(sensors==0)
#       not_found()
#   else if(sensors==1)
#       go_right()
#   else if(sensors==2)
#       go_left()
#   else
#       found()
#}




:loop
    #cargo sensores en r0
    io 0

    #niego la señal de los sensores
    copy r0r1
    copy r0r2
    nand
    
    #aplico mascara para quedarme con los 2 primeros bits
    copy r0r2
    zero r0
    addi :mask_sensors
    copy r0r1
    and
    copy r0r2

    #ahora tengo en r2 el estado de los sensores

    frst
    zero r1
    #comparo con 00
    cmp 

    #cargo direccion de not_found
        zero r0
        addi :not_found_addr
        copy r0r1
        ld
        copy r0r1
        #Salto a :not_found
        jump 2 #equal 
    
    frst
    zero r0
    addi 0001
    copy r0r1
    #comparo con 01
    cmp 

    #cargo direccion de go_right
        zero r0
        addi :go_right_addr
        copy r0r1
        ld
        copy r0r1
        #Salto a :go_right
        jump 2 #equal 

    frst
    zero r0
    addi 0010
    copy r0r1
    #comparo con 10
    cmp 

    #cargo direccion de go_left
        zero r0
        addi :go_left_addr
        copy r0r1
        ld
        copy r0r1
        #Salto a :go_left
        jump 2 #equal 
    
    #else
    #cargo direccion de found
        zero r0
        addi :found_addr
        copy r0r1
        ld
        copy r0r1
        #Salto a :found
        jump 8 #always


:not_found
    zero r0
    addi 0000
    #escribo el resultado en los motores
    io 1

    #return
    zero r0
    addi :loop_addr
    copy r0r1
    ld
    copy r0r1
    jump 8



:go_right
    zero r0
    addi 0001
    #escribo el resultado en los motores
    io 1

    #return
    zero r0
    addi :loop_addr
    copy r0r1
    ld
    copy r0r1
    jump 8



:go_left
    zero r0
    addi 0010
    #escribo el resultado en los motores
    io 1

    #return
    zero r0
    addi :loop_addr
    copy r0r1
    ld
    copy r0r1
    jump 8



:found
    zero r0
    addi 0011
    #escribo el resultado en los motores
    io 1
    
    #return
    zero r0
    addi :loop_addr
    copy r0r1
    ld
    copy r0r1
    jump 8

El ensamblador nos devuelve:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 

90 81 82 50 82 30 2:mask_sensors 81 40 82 e0 31 a0 30 2:not_found_addr 81 c0 81 b2 e0 30 21 81 a0 30 2:go_right_addr 81 c0 81 b2 e0 30 22 81 a0 30 2:go_left_addr 81 c0 81 b2 30 2:found_addr 81 c0 81 b8 30 20 91 30 2:loop_addr 81 c0 81 b8 30 21 91 30 2:loop_addr 81 c0 81 b8 30 22 91 30 2:loop_addr 81 c0 81 b8 30 23 91 30 2:loop_addr 81 c0 81 b8 

sustituyendo constantes...
{':mask_sensors': '3', ':loop_addr': '0', ':not_found_addr': '1', ':go_right_addr': '2', ':go_left_addr': '3', ':found_addr': '4', ':loop': '0', ':not_found': '2f', ':go_right': '38', ':go_left': '41', ':found': '4a'}

text:
90 81 82 50 82 30 23 81 40 82 e0 31 a0 30 21 81 c0 81 b2 e0 30 21 81 a0 30 22 81 c0 81 b2 e0 30 22 81 a0 30 23 81 c0 81 b2 30 24 81 c0 81 b8 30 20 91 30 20 81 c0 81 b8 30 21 91 30 20 81 c0 81 b8 30 22 91 30 20 81 c0 81 b8 30 23 91 30 20 81 c0 81 b8 

data:
0 2f 38 41 4a

Clone this wiki locally