I’ve got two friends who make old retro computers.
They like to use old chips and use only THT.
What is my take on this?
I like to use THT when possible. Exceptions are:
Size constrains
No THT parts available
New gadgets
Old versus new chip solutions
CPU : never a new alternative (I’m not going to replace a 6502 using Arduino emulation, for example)
Yes, I’m using static ram instead of dynamic
Address decoder using 74xx ? Yes, I want to test at least once. But using a ATF22v10 has my preference. (Not using GALs anymore)
I only replace with newer alternatives when it does NOT interfere with how a system is performing. CPU has its own quirks, also chips like the SID. I never emulate when it can be avoided. Address decoding, RAM or ROM yes please 🙂 Old untrusted UV Eproms are sh*t. Give me the new flash-able alternatives any time
I can emulate everything, but I need real hardware.
Real 6502
Real 68000
Real 8088
Real 8086
Real 80386
I still want a real VGA monitor because I used to write VGA manipulation programs which only work on CRTs.
While testing on a breadboard is fast, I still want my 68000 on PCBs.
Breadboards are nice for testing, and I use them in the design stage. But they will fail in the end. Loose wires, oxidated contacts and alike.
So when I was testing using breadboard, I drew the schematics in KiCad.
I wanted to use Eurocards for this one. If I divide the whole system in system blocks, I can exchange and experiment parts. (My 6502 uses another method to connect different cards)
Emulates a floppy drive:Â Meatloaf plugs into the Commodore 64’s IEC serial port and acts like a virtual floppy drive. This allows you to load software and data stored on its internal flash memory, sd card, or stream it via WiFi using various protocols from servers all over the world.
Supports multiple virtual drives:Â Unlike a single floppy drive, Meatloaf can be configured to emulate up to 26 virtual drives (IDs 4-30). Each virtual drive can have a different disk image loaded, essentially offering the equivalent of having thousands of floppies connected to your C64.
Supports additional virtual device types:Â Printers, a network interface, and more.
Connects to the internet:Â Meatloaf also functions as a WiFi modem, enabling your Commodore 64 to connect to Telnet BBS (bulletin board systems) for communication and sharing information.
load from urldebug outputmy own repo testOnly a Lolin D32 and a cable with din connector.
Saw a cool game a while ago, and found some old code. There was no schematic, so I had to reverse engineer it using the Arduino code. This one uses a Micro Pro.
Build a working version, now I can use this as base to create other games. But first i’m going to rebuild it so it can use Wifi and uses a Lipo Battery. Making it usable without wires.
Rotary – set angle/speed (Press resets)
Blue – toggle angle or speed ( was rotary press )
Green – select digit to change
Red – Fire
Led – not completely working yet, shows color of player Wil be changed to addressable leds with more functions (Player color, energy warning and more)
Last week I bought an old Bornhack Badge. I thought it needed a display.
Using a SSD1306 display, and Circuitpython I made this.
( Wooded thingy contains an RFID chip ( Part of my player ))
Library and files needed:
font5x8.bin in root of filesystem ( just google for this file )
copy of adafruit_framebuf.mpy in /lib
copy of adafruit_ssd1306.mpy in /lib
Code: (midway some pixel examples, just uncomment)
import board
from time import sleep
import busio
from PN7150 import PN7150
import adafruit_ssd1306
import math
import adafruit_framebuf
if True:
# Fast 400KHz I2C
i2c = busio.I2C(board.SCL, board.SDA, frequency = 400000)
else:
# Regular 100kHz I2C
i2c = board.I2C()
WIDTH = 32
HEIGHT = 8
buffer = bytearray(round(WIDTH * math.ceil(HEIGHT / 8)))
fb = adafruit_framebuf.FrameBuffer(
buffer, WIDTH, HEIGHT, buf_format=adafruit_framebuf.MVLSB
)
nfc = PN7150(i2c, board.IRQ, board.VEN)
display = adafruit_ssd1306.SSD1306_I2C(128, 32, i2c,addr=0x3c)
assert nfc.connect()
print("Connected.")
assert nfc.modeRW()
print("Switched to read/write mode.")
display.fill(0)
display.show()
#display.fill(0)
#display.text('Hello', 0, 0, 1 )
#display.text('World', 0, 10, 1)
#display.show()
# Set a pixel in the origin 0,0 position.
#display.pixel(0, 0, 1)
# Set a pixel in the middle 64, 16 position.
#display.pixel(64, 16, 1)
# Set a pixel in the opposite 127, 31 position.
#display.pixel(127, 31, 1)
#display.show()
while True:
display.fill(0)
display.text('Waiting for card', 0, 0, 1 )
display.show()
assert nfc.startDiscoveryRW()
print("Waiting for card..")
card = nfc.waitForCard()
assert nfc.stopDiscovery()
print("ID: {}".format(card.nfcid1()))
id = card.nfcid1()
display.text(id, 0, 10, 1 )
display.show()
sleep(0.5)
Not sure about display i2c address? Use below code
import time
import board
import busio
# List of potential I2C busses
ALL_I2C = ("board.I2C()",)
# Determine which busses are valid
found_i2c = []
for name in ALL_I2C:
try:
print("Checking {}...".format(name), end="")
bus = eval(name)
bus.unlock()
found_i2c.append((name, bus))
print("ADDED.")
except Exception as e:
print("SKIPPED:", e)
# Scan valid busses
if len(found_i2c):
print("-" * 40)
print("I2C SCAN")
print("-" * 40)
while True:
for bus_info in found_i2c:
name = bus_info[0]
bus = bus_info[1]
while not bus.try_lock():
pass
print(
name,
"addresses found:",
[hex(device_address) for device_address in bus.scan()],
)
bus.unlock()
time.sleep(2)
else:
print("No valid I2C bus found.")
I’ve connected the rotary encoder directly to the zero. Although many websites state that you need pull-up resistors, there is no need. Just use the internal pull-up resistors in the Pi.
Example code
GPIO.setmode(GPIO.BCM) # Use BCM mode
GPIO.setup(self.24, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(self.25, GPIO.IN, pull_up_down=GPIO.PUD_UP)
NOTE: Between 24 and 25 is a GND connection
Besides USB HID below XT, C64 and Amiga connectors will be emulated
Testing the first keyboard. It is the 8085-SDK hex matrix keyboard.
It is running on a Raspberry Pi Zero 2, without X server. So the images are displayed using the framebuffer. Also the touch data is read using evdev and the raw devices.
Todo:
HID part
Add a rotary button for the selection of the different Keyboard Layouts
Improvement keyboard matrix calculation to find out which key is being pressed.
Code to control AT/PS2 computers directly using GPIO pins
Add a controller to use Raw controlling of matrix pins ( 6502 C64 hardware for example )
import select
from math import floor
import sys
slot = 0
keysname=[["F","E","D","C","vect-int","reset"],
["B","A","9","8","GO","Single-Step"],
["7","6","5","4","Exam-reg","Subst-mem"],
["3","2","1","0","Exec","Next"],
]
keysnames=[["F","E","D","C","vect-int","reset"],
["B","A","L","H","GO","Single-Step"],
["PCL","PCH","SPL","SPH","Exam-reg","Subst-mem"],
["3","2","1","0",".",","],
]
for path in evdev.list_devices():
device = evdev.InputDevice(path)
if evdev.ecodes.EV_ABS in device.capabilities():
break
else:
sys.stderr.write('Failed to find the touchscreen.\n')
sys.exit(1)
while True:
r, w, x = select.select([device.fd], [], [])
id_ = -1
x = y = 0
for event in device.read():
if event.code == event.value == 0:
if id_ != -1:
yy = floor(( x - 600 ) / 700)
xx = floor(( y - 1377 ) / 226)
if yy < 4 and yy >=0 and xx < 6 and xx >= 00:
if slot == 1:
print(keysnames[yy][xx])
else:
print(keysname[yy][xx])
elif event.code == ABS_MT_TRACKING_ID:
id_ = event.value
elif event.code == ABS_MT_SLOT:
slot = event.value
elif event.code == ABS_MT_POSITION_X:
x = event.value
elif event.code == ABS_MT_POSITION_Y:
y = event.value
I came up with a simple matrix calculation
Pressing the 4 corner keys gave me x and y. I took averages for min and max reading. I don’t need pixel-perfect reading, and I noticed values between 960 and 3080 vertically. We want 960 – 3080 into 4 blocks, but the middle should start @ 960.
So 3080/3 = about 700 700 / 2 = 350 block 1 starts 350 sooner than 960 is ~ 600 Upper key y coords = 600-> + 700 Next is 1300 -> + 700 converting to whole numbers using floor gives me: floor(( y – 600 ) / 700) NOTE: My x and y are rotated
Example using coordinates 1600, 1600 floor(( 1600 – 600 ) / 700) = floor(1,4…) = 1st row (from row 0,1,2,3)
"If something is worth doing, it's worth overdoing."