Après avoir eu l'idée d'ajouter un deuxième écran au Commodore 64, j'ai rapidement mis en œuvre ce projet. Tout le matériel s'insère dans une cartouche de taille standard (y compris le connecteur DE-15). Sortie vidéo compatible VGA (31 kHz).
A l'intérieur de la cartouche se trouve 128 Ko de SRAM pour le framebuffer et un simple DAC 1 bit.
TL ; DR
Voici à quoi ressemble la carte à l'intérieur de la cartouche. Vous pouvez télécharger la source ici .
Interface de programmation
La cartouche peut être placée n'importe où dans l'espace d'adressage de 64 Ko, y compris I/O1 ou I/O2. Il y a du code Verilog à présenter soit dans une fenêtre dans le framebuffer @EXPROM, qui occupera 8 Ko de mémoire de base, soit une approche basée sur les registres qui économise de la RAM.
Dans les exemples illustrés, I/O1 à $DE00 est utilisé pour les registres de contrôle. Vous voudrez peut-être modifier l'exemple donné s'il y a un conflit avec un autre module complémentaire (deuxième puce SID, etc.). En général, il existe un support pour un jeton spécial qui vous permet d'éviter les conflits, mais je n'ai pas de logiciel supplémentaire qui provoque ces conflits.
Registres
IOBASE = jeton
IOBASE + 1 = adresse lsb
IOBASE + 2 = adresse msb
IOBASE + 3 = données Le framebuffer
est linéaire et simple d'utilisation, comme les modes bitmap natifs du C64. Chez SRAM, cela commence à 00 000 $.
Sortie vidéo
Quel que soit le mode sélectionné, la vidéo est émise avec un taux de pixels de 25 MHz grâce au générateur 100 MHz intégré. Ce paramètre est proche de la norme 25,175 MHz pour un écran 640x480 à 60 Hz FPS. En conséquence, tout écran que j'ai connecté a montré l'image correctement et sans problème. Les zones de synchronisation et de suppression verticales et horizontales sont réglées sur la polarité et la longueur correctes pour déclencher ce mode. Il existe deux interprétations possibles des données du framebuffer : mode haute résolution 640x480 1 bit par pixel et mode multicolore basse résolution 320x480. Les deux modes sont directement palette.
Le fer
Le hardware est assez basique : régulateur 3.3V, CPLD, oscillateur et SRAM. La SRAM passe la moitié de son temps à répondre à l'hôte et la moitié de son temps à charger les données de pixels. Le CPLD utilisé ici, le Xilinx 95144XL, est stable à 5 V, il se trouve donc sur le bus d'extension C64, bien qu'il soit alimenté par un régulateur de 3,3 V avec le reste du matériel.
Presque toutes les ressources CPLD sont utilisées. J'espérais installer un sprite matériel pour le pointeur, mais il n'y avait tout simplement pas de place pour cela.
Pour ceux qui imprimeront des glacières, le modèle STL a tout ce dont vous avez besoin, et dans le style C64.
Le point important est que vous avez besoin d'un programmeur JTAG pour charger le flux binaire dans le CPLD.
Et encore une chose - la cartouche ne fonctionne pas avec la carte Ultimate 64. De plus, l'installation d'une cartouche sur cette carte peut endommager la cartouche. Mais tout fonctionne avec toutes les versions des cartes C64, C128 et C64 Reloaded. Je ne sais pas avec certitude si la cartouche est compatible avec toutes les versions de C64 ou C128 publiées par Commodore, mais je ne vois aucun problème.
Caractéristiques
- 4- . Gerber. , ( , female-).
- . STL.
- , 22 , 6,6
- , pn 430156043726, reset .
- .1"
- 0603: 2 499R, 3 300R, 2 30R
- 0603: 10 0,1 , 7 0,01
- 2 3,2x1,6 ( , )
- XC95144XL-5TQ100C CPLD ( )
- JEDEC 128kx8 SO Async SRAM a la AS6C1008-55PCN ( )
- VGA , DE15
Verilog
J'ai utilisé Xilinx ISE 14.5 car je ne pouvais pas trouver de boîte à outils open source pour ces CPLD. Si quelqu'un a de telles informations, merci de les partager.
Emballage de pixels
En mode haute définition, chaque bit correspond à un pixel. 1 = blanc, 0 = noir. Les adresses se déplacent de (0,0) à la position la plus visible en haut à gauche vers le bas à droite (639 479), colonne par colonne, puis ligne par ligne. Le bit 7 de chaque octet est le premier pixel.
En mode multicolore, les pixels sont émis à la même vitesse qu'en mode monochrome, mais chaque canal de couleur a une résolution différente. Le vert correspond à un taux de 1/2 pixel et le rouge et le bleu à un taux de 1/4 de pixel. Le mappage du modèle binaire sur le canal de couleur est octet par octet (fragmentaire) et est :
G0 G1 G2 G3 R0 R1 B0 B1
Alors que la représentation à l'écran de chaque octet du tampon de trame ressemble à ceci :
R0 R0 R0 R0 R1 R1 R1 R1
G0 G0 G1 G1 G2 G2 G3 G3
B0 B0 B0 B0 B1 B1 B1 B1
Convertir des images pour l'affichage avec ImageMagick, mode monochrome :
convertir input.tiff -resize 640x480 -colors 2 -depth 1 output.mono
Mode couleur :
convertir input.tiff + dither -posterize 2 -resize 640x480 output.tiff
convert output.tiff -separate channel% d.png
Le code est écrit en Python - cette option m'a semblé la plus simple :
from PIL import Image
from array import *
import numpy as np
ir = Image.open("channel0.png")
ig = Image.open("channel1.png")
ib = Image.open("channel2.png")
ir = ir.resize((640,480))
ig = ig.resize((640,480))
ib = ib.resize((640,480))
r = ir.load()
g = ig.load()
b = ib.load()
arr=np.zeros((480,80,8))
out=np.zeros((480,640))
for y in range(0,480):
for x in range(0,80):
# 0 1 2 3 is green level
# 4 5 is red level
# 6 7 is blue level
# GREEN
arr[y][x][0]=(g[x*8+0,y]+g[x*8+1,y])/2
arr[y][x][1]=(g[x*8+2,y]+g[x*8+3,y])/2
arr[y][x][2]=(g[x*8+4,y]+g[x*8+5,y])/2
arr[y][x][3]=(g[x*8+6,y]+g[x*8+7,y])/2
# RED
arr[y][x][4]=(r[x*8+0,y]+r[x*8+1,y]+r[x*8+2,y]+r[x*8+3,y])/4
arr[y][x][5]=(r[x*8+4,y]+r[x*8+5,y]+r[x*8+6,y]+r[x*8+7,y])/4
#BLUE
arr[y][x][6]=(b[x*8+0,y]+b[x*8+1,y]+b[x*8+2,y]+b[x*8+3,y])/4
arr[y][x][7]=(b[x*8+4,y]+b[x*8+5,y]+b[x*8+6,y]+b[x*8+7,y])/4
for y in range(0,480):
for x in range(0,80):
for bit in range(0,8):
arr[y][x][bit] = int(round(round(arr[y][x][bit])/255))
newfile=open("output.bin","wb")
for y in range(0,480):
for x in range(0,80):
out[y][x] = int(arr[y][x][0] + arr[y][x][1]*2 + arr[y][x][2]*4 + arr[y][x][3]*8
+ arr[y][x][4]*16 + arr[y][x][5]*32 + arr[y][x][6]*64 + arr[y][x][7]*128)
newfile.write(out[y][x].astype(np.ubyte))
newfile.close()
Vidéo de démonstration :
Nous collectons et soudons :
A partir de ce lien, vous pouvez télécharger tous les fichiers nécessaires au travail.
