El blog de Mega65 de Dan Anderson, y una traducción de algunos de sus artículos

El Mega65 es un ordenador moderno basado en FPGA con la carcasa y teclado del Commodore 65. Mega65 también es un "core" de ordenador de 8 bits que extiende el Commodore 65, que no se comercializó y quizá no terminó su desarrollo como prototipo.

Puede utilizar otros "core" en su ordenador Mega65 (por ejemplo, el de Commodore 64) o puede utilizar el "core" de Mega65 en otra placa FPGA compatible. Pero estos artículos presuponen que usa un ordenador Mega65 con su "core" Mega65.

Después de todo, lo que mueve a los promotores de Mega65 es desarrollar un ordenador nuevo de 8 bits que tome el testigo de los Commodore de 8 bits, lo que quiera que sea que eso significa.

Programar para Mega65

Si alguien ha intentado leer el Manual de Usuario de Mega65 habrá notado que los Capítulos sobre programación están inacabados, y a veces están vacíos directamente. En concreto, el capítulo sobre programación de gráficos empieza explicando el funcionamiento de los bancos de 16kb de VIC-II y se interrumpe con bastante brusquedad. Además llama la atención que es una información irrelevante para programar Mega65, porque VIC-IV no usa bancos de 16kB, aunque puede gestionarlos como lo hace VIC-II por retrocompatibilidad.

En los Apéndices sí hay información, pero es críptica, y los ejemplos de aplicación son breves y sin contexto.

En cambio existe un blog orientado a la programación de Mega65 con periodicidad mensual, Dan’s MEGA65 Digest, que lleva años activo, y donde se van tocando todos los temas, cuyo autor es Dan Sanderson, entiendo que la misma persona encargada de la redacción del manual de usuario.

El blog de Dan

Mi interés por el blog se acrecienta mucho cuando en 2025 empieza una serie sobre gráficos de caracteres. Tanto como el 6502, este tipo de gráficos es el hilo de unión de los diferentes modelos de Commodore de 8 bits: el PET (con el juego de caracteres PETSCII), el VIC20 (que introduce los caracteres redefinibles por el usuario y el modo alfanumérico multicolor) y el C64 (que hereda el modo multicolor del VIC20 e incluye 4 modos gráficos más). El C16 (o Plus/4) es bastante parecido al C64 en este tema.

Las publicaciones del blog son bastante largas, como artículos de revista. No siempre se puede seguir el hilo leyendo simplemente, sin detenerse a teclear algún trozo de código o hacer lo necesario para entender partes. En un momento dado me pareció interesante traducirlos. Ahora quiero compartir la traducción por si alguien encuentra más fácil leer los artículos traducidos, especialmente si, al menos de momento, sólo quiere un conocimiento superficial de programación Mega65.

La traducción

Los artículos traducidos los voy a compartir agrupados en tres documentos PDF: uno que contiene los artículos de la mencionada serie sobre gráficos de caracteres. Otro PDF contiene artículos anteriores sobre gráficos y sobre BASIC, algunos de los cuales podría ser interesante leer incluso antes de empezar a leer la serie. Un tercer PDF contiene artículos sobre programación de Mega65: desarrollo cruzado, ensambladores, compiladores, etc., materia sobre la que el autor parece tener bastante experiencia o interés.

A continuación pongo la lista de los artículos traducidos. Los enlaces a PDF con los artículos agrupados y traducidos están bajo el título Enlaces.

Artículos de la serie sobre gráficos de caracteres de VIC-4

• Character Study. Mayo 30, 2025. Caracteres gráficos
• Taste the Rainbow. Junio de 2025. Atrapa el arcoíris
• Super Extended Attribute Mode. Septiembre de 2025. Modo de atributos super extendidos
• Every Pixel a Color. Noviembre de 2025. Cada Pixel con su color
• Roguecraft DX; Introducing the Raster Rewrite Buffer. Marzo de 2026. Roguecraft DX; Introducción a Raster Rewrite Buffer
• Pixie Power. Dan’s MEGA65 Digest de April de 2026. “Pixies”, los sprites de Mega65

Otros artículos sobre gráficos y BASIC

• Sprite Attack!. Febrero de 2024. Caña a los sprites!
• Bitmap Bonanza! Mayo de 2023. Dibujar en bitmap con BASIC
• Let’s paint! Julio de 2024. A pintar!
• Fun with PETSCII! Abril de 2023. Disfrute con PETSCII!
• Back to BASICs. Diciembre de 2022. Vuelta a lo BASICo
• Big Screens for Fun And Profit – configuración para pantallas de texto altas en BASIC65 (del mismo autor pweo wsta en Filehost no es un Digets)
• Screenful of BASIC 2025 compo. Febrero de 2025. Modo de caracteres altos

Articulos sobre desarrollo cruzado para MEGA65

• Cross Development for Fun and Profit, part 1. Junio de 2023. Desarrollo cruzado for Fun and Profit, parte 1
• Cross Development for Fun and Profit, part 2. Julio de 2023. Desarrollo cruzado for Fun and Profit, parte 2
• Disassembling Crossroads, part 1. Noviembre 2024. Desensamblando Crossroads, parte 1
• Disassembling Crossroads, part 2. Enero de 2025. Desensamblando Crossroads, parte 2
• robotfindskitten, part 1. Octubre de 2023. robotfindskitten, parte 1
• robotfindskitten, part 2. Noviembre de 2023. robotfindskitten, parte 2
• robotfindskitten, part 3. Diciembre de 2023. robotfindskitten, parte 3
• Calypsi C, part 1. Mayo de 2026. Calypsi C, parte 1
• Classic Rogue. Junio de 2026. Rogue clásico
• Calypsi C, part 2: Using memory. Julio de 2026. Calypsi C, parte 2: acceder a memoria
• Calypsi C, part 3: Making large programs. Agosto de 2026. Calypsi C, parte 3: código fuente en programas grandes

También incluyo una lista de artículos que no he traducido de momento o no me han parecido de interés

• Racing the Beam. Mayo 2024. (sobre interrupciones raster)
• Up Up Down Down Left Right Left Right B A Start. Octubre 2024. (sobre el Joystick)
• EasyAsm. Agosto 2024. (un ensamblador para Mega 65)
• Kernal of Truth. Junio 2024. (sobre usar el Kernal en los programas)
• The Justified Ancients of Mu Mu. Marzo 2024. (sobre sonido)
• Sounds of the SID. Noviembre 2022. (sobre sonido también)
• A Rorschach Test on Fire. Marzo de 2023. (algunos trucos y cosas de BASIC)
• What I Wish I Knew About Machine Language. Febrero 2023. (cosas de BASIC y del uso del monitor de ensamblador)
• MEGA65 Adventures. Octubre 2022. (cosas sobre aventuras de texto y su programación)
• MEGA65: The Next Batch!. Septiembre de 2022. (es el primer Digest en el que incluye cosas sobre programación en BASIC)

Gráficos de caracteres

Los primeros artículos de la serie sobre gráficos de caracteres son los que tocan los aspectos de Mega65 donde hay más continuidad con C64, donde las diferencias entre ambos ordenadores se difumina. Se mantienen conceptos y organización de la memoria gráfica en las memorias de pantalla, color y juego de caracteres (charset), y a la vez se flexibiliza (facilita) su acceso.

La continuidad permite utilizar los modos alfanuméricos de C64 con mejoras importantes:

• Doblar las columnas y/o las filas: de 40 a 80, de 25 a 50 respectivamente (usar 80 columnas permite, por ejemplo, usar el modo multicolor con pixeles cuadrados en lugar de ladrillo, y resolución de 320x200)
• Cambiar los colores de la paleta (quizá en modo GO64 también? podría apañar algunos juegos de C64)
• Utilizar más bits de atributos: texto en 32 colores, atributos de subrayado y parpadeo
• Más memoria gráfica y más granularidad (la ubicación no queda restringida a un número limitado de bloques de 1kB/2kB/8kB): mejoras para doble/triple buffer, para scroll de caracteres.
• Redefinir el juego de caracteres sin tener que reconfigurar bancos de memoria
• Atributos superextendidos: 2 bytes por cada celda de memoria de pantalla y 2 por cada celda de color expande los charsets hasta 8192 caracteres y abre la puerta a los modos nuevos, exclusivos de Mega65

Los últimos artículos de la serie sobre gráficos de caracteres hablan de los modos nuevos. Son los modos que se espera que utilicen los juegos y demos nuevos para Mega65: el Full Color Mode (FCM) y el Nibble Color Mode (NCM). En estos modos hay más colores disponibles por celda y la memoria de color pierde relevancia.

Tres ejemplos

Aquí pongo tres ejemplos de programas en BASIC que me ha interesado probar a modo de ejercicio. No están extraídos del Digest original y tampoco están añadidos a la traducción. Puede husmear los listados al final de esta publicación.

El primer ejemplo está tomado de una idea de idreamtin8bits, es cargar 4 pantallas PETSCII de C64 en una única pantalla PETSCII en Mega65, de doble anchura y altura (80 columnas x 50 filas). A diferencia del gráfico original, que tiene que utilizar la paleta del VDC del C128, aquí podemos utilizar directamente la paleta del VIC-II. Nosotros cargamos las imágenes originales de C64, ellos tuvieron que hacer un trabajo de recolorear.

El segundo ejemplo es una idea mía, cargar imágenes estándar de Sinclair Spectrum, de 6.912 bytes, en el modo bitmap del C64 (a veces llamado "modo Spectrum"), utilizando la paleta de Spectrum y no la paleta de VIC-II (de C64). Al margen de la paleta son modos muy parecidos en Spectrum y en C64, pero la memoria se ordena de diferente manera. La reordenación de los bytes se hace en el mismo programa BASIC.

El tercer ejemplo trata de convertir una imagen en un formato moderno como JPG a FCM. Es un ejercicio que está incluido en el Digest de Noviembre de 2025, Every Pixel a Color (cada Pixel con su color). Pero en el artículo original se realiza la conversión con un programa de dibujo llamado Aseprite. En mi caso para la conversión utilizo GIMP. Además de recortar, reescalar, etc., GIMP permite extraer una paleta de una imagen y convertirla en color indexado.

Un ejemplo parecido para el modo de bitplanos había aparecido en el Digest de Mayo de 2023, Bitmap Bonanza! (Dibujar en bitmap con BASIC). El Mega65 permite cargar imágenes IFF de Amiga desde BASIC. En ese artículo el autor se explaya con este modo de bitplanos que el Commodore 65 adoptó del Amiga, pero sin Blitter ni Copper.

Recapitulación

Las series de artículos de gráficos y de programación cruzada seguramente no han acabado y en todo caso aparecerán más artículos o series relacionadas y si puedo los seguiré traduciendo.

Los artículos traducidos abarcan más de 400 páginas e incluso así deja muchos vacíos, por ejemplo, aún no tocó artículos sobre scroll. Es una recopilación de artículos que abre muchos interrogantes. La complejidad de Mega65 respecto de los 8 bit que conocemos se manifiesta con los gráficos más detallados o la mayor variedad de lenguajes de programación que en la práctica permite la mayor potencia.

Como programador en ensamblador me llama mucho la atención que el 65CE02 de MOS incluyese un cuarto registro Z, de funcionalidad parecida a Y, porque 6502 va muy corto de registros y uno más se agradece. Pero ningún compilador utiliza todavía las instrucciones nuevas del procesador.

Al conocer Mega65 despierta deseo empezar a programar para Commodore 65 y no para Mega65. Cuesta un poco entender que ambos son un poco lo mismo. Como el Commodore 65, el Mega65 tampoco se considera un diseño acabado. El autor de Digest a veces comenta si una característica viene de Commodore 65 y no es nueva de Mega65, pero tampoco lo hace sistemáticamente.

Enlaces

En este enlace a Archive [https://archive.org/details/dan-sanderson-mega-65] podréis encontrar los siguientes contenidos:

• PDF de artículos de gráficos de caracteres traducidos al español
• PDF de otros artículos sobre gráficos y BASIC traducidos al español
• PDF de artículos de programación cruzada traducidos al español
• Archivos .D81 con los ejercicios de este artículo

Código de los ejercicios

Para los que les guste husmear código, incluyo los listados de los ejemplos comentados anteriormente.

En primer lugar el código BASIC para cargar 4 pantallas PETSCII de C64 en una única pantalla PETSCII en Mega65.

10 REM
20 BACKGROUND 0
30 BORDER 2
40 PRINT CHR$(27)+"5"+CHR$(147) : REM80X50
50 BLOAD "fullack_myd",P($8000000) :REM LOAD TO ATTIC RAM, 2096 BYTES, SKIP96
60 BLOAD "morbosez_myd",P($8000830) :REM 2096 BYTES, SKIP96
70 BLOAD "monkey_island_lo",P($8001060) :REM 3919 BYTES, SKIP$714
80 BLOAD "arcadevenus_skle",P($8001FAF) :REM 10191 BYTES, SKIP$1FFF
90 SC=WPEEK($D060) + WPEEK($D062)*65536
100 BS=$8000060:OD=0:GOSUB200 : REM COPIAR IMAGEN 50 EN CUADRANTE SUPERIOR IZQUIERDA
110 BS=$8000890:OD=40:GOSUB200 : REM COPIAR IMAGEN 60 EN CUADRANTE SUPERIOR DERECHA
120 BS=$8001774:OD=2000:GOSUB200 : REM COPIAR IMAGEN 70 EN CUADRANTE INFERIOR IZQUIERDA 
130 BS=$8003FAE:OD=2040:GOSUB200 : REM COPIAR IMAGEN 80 EN CUADRANTE INFERIOR DERECHA 
140 GETKEY A$
150 PRINT CHR$(27)+"8"+CHR$(147) : REM80X25
160 END
200 FORI=0TO24:EDMA0,40,BS+I*40,SC+OD+I*80:EDMA0,40,BS+1000+I*40,$FF80000+OD+I*80: NEXTI
210 REM QUIZA ESTA OPERACION DEBERIA PODER HACERSE SIN EL BUCLE, CON DOS INSTRUCCIONES EDMA
220 RETURN

Breve explicación: Las líneas 20 a 40 configuran las dimensiones y colores de la pantalla. Las líneas 50 a 80 cargan las imágenes en la memoria de ático. La memoria de ático son 8 megabytes de RAM que no son accesibles por VIC-IV. Cada imagen tiene su formato, así que las direcciones están calculadas de manera individual. Las líneas 100 a 130 copian a la memoria de pantalla desde la memoria de ático, pasando los offsets BS y OD. La subrutina en las líneas 200-220 hace la copia efectiva utilizando el comando EDMA que copia usando el chip DMA.

En segundo lugar el ejemplo de importar una imagen estándar de Spectrum, de 6.912 bytes, en el modo bitmap del VIC-II, pero utilizando la paleta de Spectrum, no la de VIC-II.

10 REM cargar imagen spectrum
20 BACKGROUND 0
30 BORDER 2
35 C1=WPEEK($D068):C2=PEEK($D06A)
40 PRINT CHR$(27)+"4"+CHR$(147) : REM40X25
50 BLOAD "prof4d-aloha.scr",P($8000002) :REM LOAD TO ATTIC RAM
55 BORDER3
60 MEM1,0 : REM son dos mascaras binaria, 1 reserva los primeros 8k del banco 4, 0 no reserva nada en el banco 5
70 WPOKE$D068,0:POKE$D06A,4 : REM CHARSET en el banco 4, no se puede utilizar la ubicacion por defecto pq solo tiene 4k
75 BORDER4
80 SETBIT$D011,5 : rem bitmap
85 BORDER5
90 BANK4 : rem para pokear
95 GOSUB 600
100 CM=32:BS=$8000000:GOSUB300 : REM tercio superior pantalla spectrum
105 BORDER7
110 CM=2592:BS=$8000800:GOSUB300 : REM tercio medio pantalla spectrum
120 CM=5152:BS=$8001000:GOSUB300 : REM tercio inferior pantalla spectrum
130 BANK128
135 BORDER8
140 SC=WPEEK($D060)+65536*WPEEK($D062) : REM en modo bitmap la memoria de pantalla alfanumerica hace de memoria de color
150 FORA=0TO23:FORB=0TO31:ZX=PEEK($8001800+A*32+B) : REM atributo spectrum
160 CB=((ZX/8)AND$0F)OR((ZX*2)AND128)OR((ZXAND7)*16) : REM colores fondo y primer plano c64
170 POKESC+4+a*40+b,CB:NEXTB:NEXTA
180 GOSUB 400 : REM cambio de paleta
190 GETKEYA$ : REM salir
200 CLRBIT$D011,5 : REM bitmap
210 WPOKE$D068,4096:POKE$D06A,0 : REM charset
220 END
300 FORA=0TO7:FORB=0TO7:FORC=0TO31:POKECM+A+C*8+B*320,PEEK(BS+C+B*32+A*256):NEXTC,B,A
310 REM este bucle deberia poder hacerse al menos con un bucle menos uilizando EDMA
320 RETURN
400 PALETTE COLOR 0, 0, 0, 0
410 PALETTE COLOR 1, 0, 0, 15
420 PALETTE COLOR 2, 15, 0, 0
430 PALETTE COLOR 3, 15, 0, 15
440 PALETTE COLOR 4, 0, 15, 0
450 PALETTE COLOR 5, 0, 15, 15
460 PALETTE COLOR 6, 15, 15, 0
470 PALETTE COLOR 7, 15, 15, 15
480 PALETTE COLOR 8, 0, 0, 0
490 PALETTE COLOR 9, 0, 0, 13
500 PALETTE COLOR 10, 13, 0, 0
510 PALETTE COLOR 11, 13, 0, 13
520 PALETTE COLOR 12, 0, 13, 0
530 PALETTE COLOR 13, 0, 13, 13
540 PALETTE COLOR 14, 13, 13, 0
550 PALETTE COLOR 15, 13, 13, 13
560 RETURN 
600 FORA=0TO7999:POKEA,0:NEXT:RETURN

Breve explicación: Las líneas 20 a 40 configuran las dimensiones y colores de la pantalla. La línea 50 carga la imagen en la memoria de ático. Las líneas 60 a 80 activan el modo gráfico y reservan memoria que si no BASIC podría utilizar para guardar variables. Las líneas 90 a 120 copian la memoria de pantalla desde la memoria de ático, pasando los ófsets BS y OD. La subrutina en las líneas 300-320 hace la copia efectiva reordenando los datos. Las líneas 130 a 170 se encargar de copiar y procesar la memoria de color. Las líneas entre 400 y 560 redefinen los 16 primeros colores de la paleta a los colores de Spectrum.

En tercer y último lugar vienen los listados correspondientes al ejemplo de cargar una imagen en FCM. El primer listado en BASIC toma el archivo de exportación que hemos generado en GIMP, y reordena y mete los datos en memoria para visualizar la imagen. Como en los ejemplos anteriores utiliza la memoria de ático como paso intermedio entre la memoria gráfica y el archivo en disco.

100 REM === Enable CHR16. Set LINESTEP to 80 x 2 = 160.
110 SETBIT $D054,0: CLRBIT $D031,5
120 WPOKE $D058,160
130 REM === Set SCRNPTR to $5.F060. Remember previous setting.
140 S1 = WPEEK($D060) : S2 = WPEEK($D062)
150 WPOKE $D060,$F060 : WPOKE $D062,$05
160 REM === Set FCLRHI.
170 SETBIT $D054,2
180 REM === Load image chars to $4.0000.
190 BLOAD "dc3_640.bin",R,P($8000000)
200 REM === Load palette to temp location, then copy.
210 BLOAD "dc3_640.pale.bin",R,P($8040000)
220 FOR I=0 TO 767:POKE $D100+I,PEEK($8040000+I):NEXT I
230 REM === Fill screen.
240 FOR I=0 TO 1759 : REM Stop at 22 rows.
250 WPOKE $5F060+I*2,$1000+I
260 WPOKE $FF80000+I*2,$FF00
270 NEXT I
280 FOR I=1760 TO 1999 : REM Fill row 23,24,25 as empty.
290 WPOKE $5F060+I*2,32
300 WPOKE $FF80000+I*2,0
310 NEXT I
320 GOSUB500
330 REM === Set background and border to color 0.
340 BACKGROUND 0:BORDER 0
350 REM === Wait for keypress, then reset.
360 GETKEY A$
370 PALETTE RESTORE
380 CLRBIT $D054,2:CLRBIT $D054,0:WPOKE $D058,80
390 WPOKE $D060,S1:WPOKE $D062,S2
400 END
500 FORI=0TO79:FORJ=0TO21:FORA=0to7:FORB=0TO7
510 POKE$40000+I*64+J*5120+A+B*8,PEEK($8000000+I*8+J*5120+A+B*640)
520 NEXTB:NEXTA:NEXTJ:NEXTI
530 RETURN

El script anterior se invoca desde la misma consola Python incluyendo la ruta de nuestro PC donde queremos que guarde la exportación:

m65("C:\\Users\\javiergonzalez\\OneDrive\\Retro\\Articulo\\MEGA65\\")

Para extraer la paleta se usa un script parecido:

def nibble_swap(v):
  return ((v & 0x0f) << 4) | ((v & 0xf0) >> 4)

def paleta(carpeta) :
	imagen=gimp.image_list()[0]
	drawable=imagen.active_layer
	nombre = os.path.splitext(drawable.name)[0]
	ruta = os.path.join( carpeta, nombre + ".paleta.bin" )
	f = open(ruta, "wb")
	newFileBytes = [0, 160]
	num, mapacolor = pdb.gimp_image_get_colormap(imagen)
	for j in range(0, 3):
		for  i in range(0, 256):
			color=mapacolor[j+i*3]
			byte = nibble_swap(color)
			newFileBytes.append(byte)
	newFileByteArray = bytearray(newFileBytes)
	f.write(newFileByteArray)
	f.close()

El script para la paleta también se invoca desde la misma consola Python incluyendo la ruta de nuestro PC donde queremos que guarde la exportación:

paleta("C:\\Users\\javiergonzalez\\OneDrive\\Retro\\Articulo\\MEGA65\\")

Esperamos que os haya resultado de interés y sea de utilidad para entender y usar el Mega65.