title: CHIP-8
text: # CHIP-8
  
  CHIP-8 es un lenguaje de programación interpretado, desarrollado por Joseph Weisbecker. Fue inicialmente usado en los microcomputadores de 8 bits COSMAC VIP y Telmac 1800 a mediados de 1970. Los programas de CHIP-8 corren sobre una máquina virtual de CHIP-8. Esto se hizo así para que los video juegos fueran más fáciles de programar en otros computadores.
  Aproximadamente 20 años después el CHIP-8 reapareció, pero esta vez, aparecieron diversos intérpretes para algunos modelos de calculadoras gráficas. Como era de esperar, desde finales de 1980 en adelante, esos dispositivos de mano tienen mucho más poder de cálculo que los microcomputadores de mediados de 1970.
  
  # CHIP-8
  ## Aplicaciones en CHIP-8
  
  Hay un número no pequeño de videojuegos clásicos portados a CHIP-8, como Pong, Space Invaders, Tetris y Pac-Man. También hay disponible un generador aleatorio de laberintos. Esos programas están en dominio público y se pueden encontrar fácilmente en Internet.
  
  # CHIP-8
  ## El CHIP-8 hoy en día
  
  Hay una implementación de CHIP-8 para casi todas las plataformas imaginables, así como algunas herramientas de desarrollo. A pesar de eso, solo hay un pequeño número de juegos para CHIP-8.
  CHIP-8 tiene un descendiente llamado SCHIP (Super Chip), presentado por Erik Bryntse. En 1990, un intérprete de CHIP-8 llamado CHIP-48 fue hecho para la calculadora gráfica HP-48 de esta forma los juegos podían ser programados más fácilmente. Estas extensiones para CHIP-8 fueron conocidas como SCHIP. Este nuevo intérprete cuenta con una mayor resolución y varios opcodes adicionales que permiten programarlo más fácilmente. Si no fuera por el desarrollo del intérprete de CHIP-48, el CHIP-8 no sería conocido en nuestros días.
  El desarrollo que más influyó (el cual popularizó el S/CHIP-8 en otras plataformas) fue el emulador de David Winter, que era un desensamblador y además, elaboró una documentación técnica. Estableció una completa lista de opcodes y otras características que hasta esa fecha estaban sin documentar, y fue distribuida a través de varios foros de aficionados a los emuladores. Muchos de los emuladores listados abajo, tuvieron su punto de inicio en dicha documentación.
  
  # CHIP-8
  ## Descripción de la Máquina Virtual
  ### Memoria
  
  Las direcciones de memoria del CHIP-8 tienen un rango 200h a FFFh, lo que hacen 3.584 bytes. La razón del porqué la memoria comienza en 200h varía de acuerdo a la máquina. Para el Cosmac VIP y el Telmac 1800, los primeros 512 bytes son reservados para el intérprete. En esa máquinas, los 256 bytes más altos (F00h-FFFh en máquinas de 4K) fueron reservados para el refresco de pantalla, y los 96 bytes anteriores (EA0h-EFFh) fueron reservados para los llamados de la pila, uso interno y otras variables.
  
  # CHIP-8
  ## Descripción de la Máquina Virtual
  ### Registros
  
  El CHIP-8 tiene 16 registros de 8-bit para datos llamados V0, V1, V2, hasta el VF. El registro VF funciona como un flag o Registro de Estado (Status Register). Se usa como carry flag (cuando se usan instrucciones aritméticas) o como detector de colisiones (cuando se dibujan Sprites).
  Existe el registro de direcciones llamado I, tiene 16 bits de ancho y es usado con varios opcodes que involucran operaciones con la memoria. De estos 16 bits, el intérprete solo usa los 12 bits menores ya que los 4 bits mayores se usan para la carga de Fuentes.
  
  # CHIP-8
  ## Descripción de la Máquina Virtual
  ### La pila o stack
  
  La pila solo se usa para almacenar direcciones que serán usadas luego, al regresar de una subrutina. La versión original 1802 permitía almacenar 48 bytes hacia arriba en 12 niveles de profundidad. Las implementaciones modernas en general tienen al menos 16 niveles.
  
  # CHIP-8
  ## Descripción de la Máquina Virtual
  ### Timers
  
  El CHIP-8 tiene 2 timers o temporizadores. Ambos corren hacia atrás hasta llegar a 0 y lo hacen a 60 hertz.
  * Timer para Delay: este timer se usado para sincronizar los eventos de los juegos. Este valor puede ser escrito y leído.
  * Timer para Sonido: Este timer es usado para efectos de sonidos. Cuando el valor no es 0, se escucha un beep.
  
  # CHIP-8
  ## Descripción de la Máquina Virtual
  ### Entrada
  
  La entrada está hecha con un teclado de tipo hexadecimal que tiene 16 teclas en un rango de 0 a F. Las teclas '8', '4', '6' y '2' son las típicas usadas para las direcciones. Se usan 3 opcodes para detectar la entrada. Una se activa si la tecla es presionada, el segundo hace lo mismo cuando la no ha sido presionada y el tercero espera que se presione una tecla. Estos 3 opcodes se almacenan en uno de los registros de datos.
  
  # CHIP-8
  ## Descripción de la Máquina Virtual
  ### Gráficos y Sonido
  
  La Resolución de Pantalla estándar es de 64×32 píxels, y la profundidad del color es Monocromo (solo 2 colores, en general representado por los colores blanco y negro). Los gráficos se dibujan en pantalla solo mediante Sprites los cuales son de 8 pixels de ancho por 1 a 15 pixels de alto. Si un pixel del Sprite está activo, entonces se pinta el color del respectivo pixel en la pantalla; en cambio, si no lo está, no se hace nada. El indicador de acarreo o carry flag (VF) se pone a 1 si cualquier pixel de la pantalla se borra (se pasa de 1 a 0) mientras un pixel se está pintando.
  Como se explicó antes, suena un beep cuando el temporizador de sonido no es 0. Para quien esté desarrollando un emulador o intérprete de Chip-8, debe recordar que el sonido debe ser de un solo tono, quedando la frecuencia de dicho tono a decisión del autor del intérprete.
  
  # CHIP-8
  ## Descripción de la Máquina Virtual
  ### Tabla de instrucciones
  
  CHIP-8 tiene 35 instrucciones, las cuales tienen un tamaño de 2 bytes. Estos opcodes se listan a continuación, en hexadecimal y con los siguientes símbolos:
  * NNN: Dirección
  * KK: constante de 8-bit
  * N: constante de 4-bit
  * X e Y: registro de 4-bit
  * PC: Contador de programa (del inglés Program Counter)
  * SP: Puntero de pila (del inglés Stack Pointer)
  | Opcode | Explicación |
  | 0NNN | Salta a un código de rutina en NNN. Se usaba en los viejos computadores que implementaban Chip-8. Los intérpretes actuales lo ignoran. |
  | 00E0 | Limpia la pantalla. |
  | 00EE | Retorna de una subrutina. Se decrementa en 1 el Stack Pointer (SP). El intérprete establece el Program Counter como la dirección donde apunta el SP en la Pila. |
  | 1NNN | Salta a la dirección NNN. El intérprete establece el Program Counter a NNN. |
  | 2NNN | Llama a la subrutina NNN. El intérprete incrementa el Stack Pointer, luego pone el actual PC en el tope de la Pila. El PC se establece a NNN. |
  | 3XNN | Salta a la siguiente instrucción si VX = NN. El intérprete compara el registro VX con el NN, y si son iguales, incrementa el PC en 2. |
  | 4XKK | Salta a la siguiente instrucción si VX != KK. El intérprete compara el registro VX con el KK, y si no son iguales, incrementa el PC en 2. |
  | 5XY0 | Salta a la siguiente instrucción si VX = VY. El intérprete compara el registro VX con el VY, y si no son iguales, incrementa el PC en 2. |
  | 6XKK | Hace VX = KK. El intérprete coloca el valor KK dentro del registro VX. |
  | 7XKK | Hace VX = VX + KK. Suma el valor de KK al valor de VX y el resultado lo deja en VX. |
  | 8XY0 | Hace VX = VY. Almacena el valor del registro VY en el registro VX. |
  | 8XY1 | Hace VX = VX OR VY. Realiza un bitwise OR (OR Binario) sobre los valores de VX y VY, entonces almacena el resultado en VX. Un OR binario compara cada uno de los bit respectivos desde 2 valores, y si al menos uno es verdadero (1), entonces el mismo bit en el resultado es 1. De otra forma es 0. |
  | 8XY2 | Hace VX = VX AND VY. |
  | 8XY3 | Hace VX = VX XOR VY. |
  | 8XY4 | Suma VY a VX. VF se pone a 1 cuando hay un acarreo (carry), y a 0 cuando no. |
  | 8XY5 | VY se resta de VX. VF se pone a 0 cuando hay que restarle un dígito al número de la izquierda, más conocido como "pedir prestado" o borrow, y se pone a 1 cuando no es necesario. |
  | 8XY6 | Establece VF = 1 o 0 según bit menos significativo de VX. Divide VX por 2. |
  | 8XY7 | Si VY > VX => VF = 1, sino 0. VX = VY - VX. |
  | 8XYE | Establece VF = 1 o 0 según bit más significativo de VX. Multiplica VX por 2. |
  | 9XY0 | Salta a la siguiente instrucción si VX != VY. |
  | ANNN | Establece I = NNN. |
  | BNNN | Salta a la ubicación V[0]+ NNN. |
  | CXKK | Establece VX = un Byte Aleatorio AND KK. |
  | DXYN | Pinta un sprite en la pantalla. El intérprete lee N bytes desde la memoria, comenzando desde el contenido del registro I. Y se muestra dicho byte en las posiciones VX, VY de la pantalla. A los sprites que se pintan se le aplica XOR con lo que está en pantalla. Si esto causa que algún pixel se borre, el registro VF se setea a 1, de otra forma se setea a 0. Si el sprite se posiciona afuera de las coordenadas de la pantalla, dicho sprite se le hace aparecer en el lado opuesto de la pantalla. |
  | EX9E | Salta a la siguiente instrucción si valor de VX coincide con tecla presionada. |
  | EXA1 | Salta a la siguiente instrucción si valor de VX no coincide con tecla presionada (soltar tecla). |
  | FX07 | Establece Vx = valor del delay timer. |
  | FX0A | Espera por una tecla presionada y la almacena en el registro. |
  | FX15 | Establece Delay Timer = VX. |
  | FX18 | Establece Sound Timer = VX. |
  | FX1E | Índice = Índice + VX. |
  | FX29 | Establece I = VX * largo Sprite Chip-8. |
  | FX33 | Guarda la representación de VX en formato humano. Poniendo las centenas en la posición de memoria I, las decenas en I + 1 y las unidades en I + 2 |
  | FX55 | Almacena el contenido de V0 a VX en la memoria empezando por la dirección I |
  | FX65 | Almacena el contenido de la dirección de memoria I en los registros del V0 al VX |
  * Datos: Q1023623