Descripción:

En la computadora Hack, las 16 palabras RAM principales (RAM [0] ... RAM [15] ), también se denominan R0 ... R15. Con esta terminología en mente, este programa calcula el valor R0 * R1 y almacena el resultado en R2.

El programa asume que R0 > = 0, R1 > = 0 y R0 * R1 < 32768. Su programa no necesita probar estas condiciones, sino asumir que se cumplen.

Código:

Código:

//Se inicializa en cero la memoria R2

@R2 // R2 en 0

M = 0

@R0 // Si R0 es 0, GOTO end

D=M

@END

D;JEQ

@R1 // Si R1 es 0, GOTO end

D=M

@END

D;JEQ

(LOOP)

@R0 // Toma R0 y pasa su valor a D

D=M

@R2 // Toma R2 y le suma D (Que sería R0)

M=M+D

@R1 //se resta 1 a R1

M=M-1

@R6 //para saltar a la instrucción 6

0;JMP

(END_LOOP)

@END // permanece haciendo saltos a si mismo

0;JMP // Para no recorrer el código una y otra vez

Este programa ilustra el manejo de bajo nivel de los dispositivos de pantalla y teclado, como sigue.

El programa ejecuta un bucle infinito que escucha la entrada del teclado. Cuando se presiona una tecla (cualquier tecla), el programa oscurece la pantalla, es decir, escribe "negro" en cada píxel; la pantalla debe permanecer completamente negra mientras se presione la tecla.

Cuando no se presiona ninguna tecla, el programa borra la pantalla, es decir, escribe "blanco" en cada píxel; la pantalla debe permanecer completamente despejada mientras no se presione ninguna tecla.

Código:

(START)

@8192 //tamaño de la pantalla (512x256 pixeles, que se llena con 32*256 filas de 16bits)

D=A //se toma la dirección inicio para la pantalla

@PLACE

M=D //Y se pasa a place que es el punto de inicio

(KBDLOOP)

@PLACE //contiene el índice de la pantalla

M=M-1 //lo empieza a recorrer hacia atrás

D=M //se asigna el valor a D

@START //En el caso de que el índice pase a ser negativo,

D;JLT //le decimos que salte a start para reiniciar el índice

@KBD

D=M //Pasamos el valor de KBD a D

@BLACK

D;JGT //con una tecla presionada, salta a negro

@WHITE

D;JEQ //si no hay nada, salta a blanco

(BLACK)

@SCREEN //la dirección de la pantalla

D=A //se pasa a D

@PLACE

A=D+M //se pasa el índice para llenar la pantalla de atrás hacia adelante

M=-1 //se hace set a -1 (1111111111111111) para llenar la fila de 16 bits a 1

@KBDLOOP

0;JMP //y se salta otra vez al loop del teclado

(WHITE)

@SCREEN

D=A

@PLACE

A=D+M

M=0 // Se realiza lo mismo que en BLACK pero ponemos el bit en 0 para "limpiarlo"

@KBDLOOP

0;JMP

Descripción:

La memoria de una máquina de Von Neumann Harvard contiene dos tipos de información: elementos de datos e instrucciones de programación. Los dos tipos de información son generalmente se tratan de manera diferente, y en las computadoras de Harvard Architecture se almacenan en unidades de memoria separadas. Sin embargo, a pesar de sus diferentes funciones, ambos tipos de información se representan como números binarios que se almacenan en el mismo estructura genérica de acceso aleatorio: una matriz continua de celdas de un ancho fijo, también llamados palabras o ubicaciones, cada una con una dirección única. Por tanto, un individuo palabra (que representa un elemento de datos o una instrucción) se especifica proporcionando su dirección.

Código:

// Put your code here:

// primero se selecciona lo que se va a hacer

// a y b hacen referencia a la memoria, c a la pantalla y d al teclado

DMux4Way(in=load, sel=address[13..14], a=rama, b=ramb, c=scr, d=kbd);

// a y b hacen referencia a lo mismo,

// entonces, se usa un OR para unificar la selección

Or(a=rama, b=ramb, out=ram);

// Ram de 16kbits, entrada IN, ram y el resto de la dirección

RAM16K(in=in, load=ram, address=address[0..13], out=rout);

// teclado y su salida

Keyboard(out=kout);

// Pantalla, similar a la RAM

Screen(in=in, load=scr, address=address[0..12], out=sout);

// Ahora para la salida, se pasa todo a un Mux4Way16 para codificar

Mux4Way16(a=rout, b=rout, c=sout, d=kout, sel=address[13..14], out=out);

Descripción:

La CPU, la pieza central de la arquitectura de la computadora, está a cargo de ejecutar las instrucciones del programa cargado actualmente. Estas instrucciones dicen la CPU para realizar varios cálculos, leer y escribir valores desde y hacia memoria, y saltar condicionalmente para ejecutar otras instrucciones en el programa. La CPU ejecuta estas tareas utilizando tres elementos de hardware principales: un Unidad Aritmético-Lógica (ALU), un conjunto de registros y una unidad de control.

Código:

// Put your code here:

// Carga la instrucción si es una instruction A.

// Carga la salida ALU si es una instruction C y la instruction [5] == 1.

Mux16(a=instruction, b=outALU, sel=instruction[15], out=inA);

Not(in=instruction[15], out=not-instruction15);

Or(a=not-instruction15, b=instruction[5], out=loadA);

ARegister(in=inA, load=loadA, out=outA, out[0..14]=addressM);

// el D register:

// carga la salida ALU si es una instruccion C-instruction y instruction[4] == 1.

And(a=instruction[15], b=instruction[4], out=loadD);

DRegister(in=outALU, load=loadD, out=outD);

// el ALU:

// toma D como x-input.

// toma A como y-input, si instruction[12] == 0, de lo contrario M.

Mux16(a=outA, b=inM, sel=instruction[12], out=A-or-M);

ALU(x=outD, y=A-or-M, zx=instruction[11], nx=instruction[10], zy=instruction[9], ny=instruction[8], f=instruction[7], no=instruction[6], out=outALU, out=outM, zr=zrALU, ng=ngALU);

// contador:

// salta a 0 si reset == 1.

// Salta a la salida del registro A si la instrucción es una instrucción C

// salta en bits 0..2, que son respectivamente out > 0, out == 0 and out < 0.

// si no , incrementa en 1.

Or(a=ngALU, b=zrALU, out=ng-or-zrALU);

Not(in=ng-or-zrALU, out=posALU);

And(a=instruction[0], b=posALU, out=jump0);

And(a=instruction[1], b=zrALU, out=jump1);

And(a=instruction[2], b=ngALU, out=jump2);

Or(a=jump0, b=jump1, out=jump01);

Or(a=jump01, b=jump2, out=jump012);

And(a=jump012, b=instruction[15], out=jump);

PC(in=outA, load=jump, inc=true, reset=reset, out[0..14]=pc);

// devuelve M solo si la instruccion es una C-instruction and instruction[3] == 1.

And(a=instruction[15], b=instruction[3], out=writeM);

}

El chip más alto en la jerarquía de hardware de Hack es un sistema informático completo diseñado para ejecutar programas escritos en el lenguaje de la máquina Hack. El chip de computadora contiene todos los dispositivos de hardware necesarios para operar la computadora, incluida una CPU, una memoria, una memoria de instrucciones (ROM), una pantalla y un teclado, todos implementado como partes internas. Para ejecutar un programa, el código del programa debe estar precargado en la ROM. El control de la pantalla y el teclado está logrado a través de sus mapas de memoria, como se describe en el chip de pantalla y teclado especificaciones.

Código:

ROM32K(address=nextInstruction, out=ROMInstruction);

CPU(inM=memoryOut, instruction=ROMInstruction, reset=reset, writeM=writeM, outM=outM, pc=nextInstruction, addressM=addressM);

Memory(in=outM, load=writeM, address=addressM, out=memoryOut);

https://www.nand2tetris.org/project04

https://www.nand2tetris.org/project05

https://github.com/akmcc/nand-2-tetris