Setelah mendapatkan ide untuk menambahkan tampilan kedua ke Commodore 64, saya segera mengimplementasikan proyek ini. Semua perangkat keras cocok dengan kartrid ukuran standar (termasuk konektor DE-15). Output video kompatibel dengan VGA (31 kHz).
Di dalam kartrid terdapat 128KB SRAM untuk framebuffer dan DAC 1-bit sederhana.
TL; DR
Beginilah tampilan papan di dalam kartrid. Anda dapat mengunduh sumbernya di sini .
Antarmuka pemrograman
Kartrid dapat ditempatkan di mana saja dalam ruang alamat 64KB, termasuk I/O1 atau I/O2. Ada kode Verilog untuk ditampilkan baik di jendela di framebuffer @EXPROM, yang akan memakan 8KB memori Basic, atau pendekatan berbasis register yang menghemat RAM.
Pada contoh yang ditunjukkan, I/O1 pada $DE00 digunakan untuk register kontrol. Anda mungkin ingin mengubah contoh yang diberikan jika ada konflik dengan beberapa addon lain (chip SID kedua, dll.). Secara umum, ada dukungan untuk token khusus yang memungkinkan Anda menghindari konflik, tetapi saya tidak memiliki perangkat lunak tambahan yang menyebabkan konflik ini.
Register
IOBASE = token
IOBASE + 1 = alamat lsb
IOBASE + 2 = alamat msb
IOBASE + 3 = data Framebuffer
linier dan mudah digunakan, seperti mode bitmap C64 asli. Di SRAM, mulai dari $ 00.000.
Keluaran video
Terlepas dari mode yang dipilih, video dihasilkan dengan kecepatan piksel 25 MHz berkat generator 100 MHz bawaan. Parameter ini mendekati standar 25,175 MHz untuk layar 640x480 pada FPS 60 Hz. Dengan demikian, setiap tampilan yang saya sambungkan menunjukkan gambar dengan benar dan tanpa masalah. Sinkronisasi vertikal dan horizontal dan area blanking diatur ke polaritas dan panjang yang benar untuk memicu mode ini. Ada dua kemungkinan interpretasi data framebuffer: resolusi tinggi 640x480 1 bit per mode piksel dan mode multiwarna resolusi rendah 320x480. Kedua mode adalah palet langsung.
Besi
Perangkat kerasnya cukup mendasar: regulator 3.3V, CPLD, osilator, dan SRAM. SRAM menghabiskan separuh waktunya untuk merespons host dan separuh waktunya memuat data piksel. CPLD yang digunakan di sini, Xilinx 95144XL, stabil 5V, sehingga duduk di bus ekspansi C64, meskipun didukung oleh regulator 3.3V bersama dengan perangkat keras lainnya.
Hampir semua sumber daya CPLD digunakan. Saya berharap untuk memasukkan satu sprite perangkat keras untuk pointer, tetapi tidak ada ruang untuk itu.
Bagi mereka yang akan mencetak pendingin, model STL memiliki semua yang Anda butuhkan, dan dalam gaya C64.
Poin penting adalah bahwa Anda memerlukan programmer JTAG untuk memuat bitstream ke dalam CPLD.
Dan satu hal lagi - kartrid tidak berfungsi dengan papan Ultimate 64. Selain itu, memasang kartrid di papan ini dapat merusak kartrid. Tapi semuanya bekerja dengan semua versi papan C64, C128 dan C64 Reloaded. Saya tidak tahu pasti apakah kartrid kompatibel dengan semua versi C64 atau C128 yang dirilis oleh Commodore, tetapi saya tidak melihat ada masalah.
spesifikasi
- 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
Saya menggunakan Xilinx ISE 14.5 karena saya tidak dapat menemukan toolkit open source untuk CPLD ini. Jika ada yang memiliki informasi seperti itu, tolong bagikan.
Pengepakan piksel
Dalam mode definisi tinggi, setiap bit sesuai dengan satu piksel. 1 = putih, 0 = hitam. Alamat berpindah dari (0,0) di posisi paling kiri atas ke kanan bawah (639 479), kolom demi kolom, lalu baris demi baris. Bit 7 di setiap byte adalah piksel pertama.
Dalam mode multiwarna, piksel dikeluarkan dengan kecepatan yang sama seperti dalam mode monokrom, tetapi setiap saluran warna memiliki resolusi yang berbeda. Hijau adalah tingkat 1/2 piksel dan merah dan biru adalah tingkat 1/4 piksel. Pemetaan pola bit ke saluran warna adalah byte-by-byte (fragmentary) dan adalah:
G0 G1 G2 G3 R0 R1 B0 B1
Sedangkan representasi layar dari setiap byte frame buffer terlihat seperti ini:
R0 R0 R0 R0 R1 R1 R1 R1
G0 G0 G1 G1 G2 G2 G3 G3
B0 B0 B0 B0 B1 B1 B1 B1
Mengonversi gambar untuk ditampilkan dengan ImageMagick, mode monokrom:
mengonversi input.tiff -mengubah ukuran 640x480 -warna 2 -kedalaman 1 output.mono
Mode warna:
mengonversi input.tiff + gentar -posterize 2 -resize 640x480 output.tiff
convert output.tiff -separate channel% d.png
Kode ini ditulis dengan Python - opsi ini menurut saya paling sederhana:
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()
Video demo:
Kami mengumpulkan dan menyolder:
Dari tautan ini Anda dapat mengunduh semua file yang diperlukan untuk bekerja.
