Following question generally relates to 6502 based projects, but I am also interested in other retro platforms so I will be also grateful for answers regarding for example 68k.
I am curious if it is possible to use some retro PC parts in homemade computers based on retro CPUs. For example:
1) Is it possible to use 30 pin SIMM RAM modules?
2) Is it possible to use ISA sound and graphic cards?
3) Is it possible to access IDE CD-ROM?

Possible, yes. Not always the best way to achieve a result, but certainly possible.

An 30-pin SIMM contains an 8-bit-wide FPM DRAM array. Your biggest challenges will be sourcing a 30-pin SIMM socket, and interfacing the 65xx bus correctly to DRAM, including generating adequate refresh sequences. The latter was common practice in days of yore, so examine circuit diagrams of the BBC Micro et al for inspiration. However, modern hobbyist projects tend to use SRAM, as it's much cheaper than it used to be, and far easier to interface to than DRAM.

The ISA bus should not be terribly difficult to build. Then, just plug in your soundcard and dig out documentation on how to drive it. Driving sound hardware directly was normal for DOS games, so finding documentation for that purpose should be possible. Expect PC-type video hardware to be awkward to drive, however.

The IDE bus was originally just a buffered extension to the ISA bus. Again, you should be able to find documentation on what to do here.

Yes, it's possible.

However the real answer is something only you (or the retro builder) can answer.

So, for-example, I use an ATmega1284p in my retro 65C02 and 65C816 boards. Does that make them any less retro? Not from my point of view as I'm considering it almost a "big blob" of logic and code that supports the real CPU in the system. I'm also using an SD card rather than a floppy drive and media. I also use GALs, but programmable logic ICs were about in the late 70's/early 80's so I don't have any real feelings for/against there.

So for me, this is an acceptable level of retro - at the end of the day stuff I type goes into a real retro CPU and the rest is just glue. Yo may feel differently though!

Cheers,

-Gordon

_________________
--
Gordon Henderson.
See my Ruby 6502 and 65816 SBC projects here: https://projects.drogon.net/ruby/

I already have four such sockets.



This is what I expected, but 6502 rather do not require large amounts of RAM.
What about other CPU families? For example 68k? Does some of them have required circuitry already present inside silicon?




I already thought about it and established my own set of rules.
1) For me it doesn't feel right to use modern microcontroller in retro design. I did it once, while building devive designed by someone else - modern recreation of Polish DIY computer from the eighties. It uses ATmega as a PS/2 keyboard interface. Original project utilized expensive matrix keyboard with reed switches, which would not be practical but using AVR feels weird.
2) I'd rather use CF card instead SD in my designs. Yes, it is not strictly "retro" (I mean it was not available while 6502/Z80/8080 systems were in common use) but it is compatible witch technology of that era. You can connect it directly to the system bus.
3) I am fine with using 74HCT chips. This technology was novelty in the eighties, but theoretically could heave been used in 8 bit systems.
4) The same with PAL/GAL chips. Yes, out of reach of electronic enthusiasts in 80s/90s, but existed back then...
5) In some cases I am ok with recreating some inaccessible parts (like ZX Spectrum ULA) with CPLD/FPGA. But recreating entire systems inside one programmable chip is definitely not my thing.

So I have no problem with using retro PC parts like SIMM modules or ISA/PCMCIA devices. It is just like mentioned CF card.
Amiga users are merging much more distant technologies. There are PCI bridges for the Amiga computers.

The size of RAM makes no difference to the interface (unless scaled dramatically); refreshing one byte of RAM is more or less the same as refreshing a megabyte. Compared to SIMMs, using modern static RAM is probably going to be more retro (as in, using hardware more similar to that available to contemporary designers) than using SIMMs since the interface is the same as old static RAM, the only difference is in the size and cost. (The earliest microcomputers often used static instead of dynamic RAM, anyway; dynamic RAM was used only for cost reasons back in the day and that is no longer an issue for hobbyists even with enormous RAM sizes such as 256 KB.)

(In case it's not clear, throughout this post I use "contemporary" to mean, "contemporary to the retro period in question," i.e., the late 1970s or early 1980s or whenever the original system you're cloning was built.)


Generally not. Note, however, that there's no need to use hardware to refresh RAM; you just need to ensure every row is accessed regularly, and this can be done by the CPU itself. The 68000-based Sun 1 workstation released in 1982 worked this way. The designer did admit that it was a bit tricky, not just making sure that the RAM refresh interrupt was set up and operating early enough in the boot process that the RAM it was using to boot didn't fade away as it was preparing to load and loading the OS, but also in that it made setting breakpoints when debugging more interesting. :-)


Well, pretty much every keyboard uses a scanned matrix, then and now, and whether you use "reed switches" (by which I think you mean something different than the standard definition of the term) or not makes no difference since you scan any kind of switch in a matrix in the same way.

If the system could use an ATmega for the keyboard interface without significant changes to the system's design and ROM code, the original system was already using a microcontroller or a custom keyboard scanning chip in the keyboard anyway, making the ATmega and PS/2 keyboard together a single system replacing just the keyboard assembly in the original system, with the ATmega being just a protocol converter. Unless you feel that the PS/2 keyboard itself is somehow closer to period-correct than an ATmega, you probably went just as "non-retro" with that. However, you could always replace the ATmega with a more period-correct microcontroller such as an 8042, which was used in computer keyboards as early as 1979, if that makes you feel better. But you'd definitely be more period correct and avoiding modern microcontrollers if you took the controller off the keyboard PCB as well and built your own system for scanning the matrix on that PS/2 keyboard.

To gain a better understanding of this topic, I suggest you study carefully until you reach full understanding the schematics and theory of operation for both a CPU-scanned keyboard, such as the TRS-80 model I, Commodore PET or Commodore 64, and an externally scanned keyboard, such as the Apple II. Once you understand these well, you will probably revise your rule to be better align with the design principles in use here.


I see the SD card approach as being a little more retro. In both cases you have what is from a contemporary point of view a "magic memory device" attached to the system, but in the SD card case you can talk its serial protocol through a standard contemporary interface such as a 6821 PIA, so the magic hardware starts on the other side of that protocol. Similar systems were used in contemporary consumer microcomputers: both the 1977 PET and the 1979 NEC PC-8001 did pretty much exactly this for their external drives, right down to using a PIA as the computer end of the interface between computer and storage device.

With the CF card, though, you've now got the magic device directly on your bus, emulating a peripheral chip with a kilobyte of independently updated address space, something that never existed back in the day as far as I'm aware, though I suppose someone could have built such a system with dual-ported RAM. At any rate, that interface was not nearly as widely used as the "smart device on the other side of a PIA" interface.

_________________
Curt J. Sampson - github.com/0cjs

Good! One the one hand it's worth recognising that everyone might make different tradeoffs and compromises depending on how they feel, but on the other hand it's worth keeping some flexibility. When you make your own rules, you can also change them, as new information comes to light.

It's also worth thinking about a build as not being the last build you'll ever do, or not being in its final form when it works. In other words, you might wish to make compromises as you build, to get the thing working and to feel a sense of success, and revisit those compromises later, either by modifying (upgrading) the machine or in your next project.

Coldfire (a "re-imagined" 68K still in production) has on-board DRAM refresh but the only older CPU I know of that does it is the Z80. SRAM is very cheap and easy now. I used 2 x 32KB SRAMs in my 6502 project and a single 512KB chip in the 816 project.



The Apple II had an off-the-shelf keyboard scanner IC that presented a 7-bit interface + strobe & reset to the computer... AVR as a "black box" vs. dedicated keyboard scan IC vs. some IO ports and software ... ??? Do what makes sense to you.



Video was my original use of the ATmega.. I was using the 1284p to produce a 320x240 pixel video display. It worked great, but was really too slow as generating the video was taking up some 70% of the cpu cycles in the ATmega - the other uses; serial port, boot ROM emulator, SD card interface were somewhat after-thoughts..



For me, now, it's the CPU and the code that I consider the retro part. I'm happy that I can use an authentic CPU and authentically old software (assembler, BASIC and BCPL) The "glue" is almost incidental now (maybe my rules changed to suite though

Cheers,

-Gordon

_________________
--
Gordon Henderson.
See my Ruby 6502 and 65816 SBC projects here: https://projects.drogon.net/ruby/

In most 6502-based micros that used DRAM, the interleaved DMA accesses required for video scanout were used as a way to reliably perform DRAM refresh. The address sequence was often generated by a 6845 CRTC or similar. The trick is that you have to multiplex two address sources (CPU and CRTC) in two halves (row and column) for the DRAM's benefit; this results in 8MHz signalling on the DRAM address bus when running a 2MHz CPU. That's why I suggested looking at such a machine for ideas on how to handle that in a way that is known to work; there are a lot of non-obvious details to take care of.

SRAM really is easier.

I think people struggle too much with defining "retro". Some people won't consider it "retro" unless it has actual vintage parts with old date codes.

I think it's silly to worry about it too much. I mean, if you build a 65C02 computer using a CPU that was manufactured in 2018, how is that retro? Even if it is a 65C02. It's still a NEW CPU.

I think retro is more about the spirit of the computer with a loose requirement that it should contain at least a few vintage parts or parts that existed back in the day. In other words, an emulator running on a modern computer isn't a retro computer.

At the end of the day, it's about having fun and learning.

_________________
Cat; the other white meat.

I consider it retro if it has the feel of vintage hardware.

For example, I have one of these: http://www.brielcomputers.com/wordpress/?cat=18

I bought it used. Unfortunately, it does not have the additional card to run CP/M.

Did you hang around on the XGameStation forum? The name is familiar.

Yep! I sure did. My first introduction to electronics (building them vs. just using them) was with a PIC that lead to the SX52.

I still own my XGameStation computer. The SX52 was a very interesting mcu.

I've been a big fan of Andre' for decades...he even called me once to talk about one of his books.

Good times!

_________________
Cat; the other white meat.

I started with the Micro Edition, but was not enamored with the SX52 - it was just a much faster PIC. Those register and memory banks were a pain.

Bought and built the Pico at a Vintage Computer Festival.

Then got the AVR and PIC24 boards. Now we're cooking. Seeing there was no way to actually program on the device yet, I started on a BASIC interpreter in C for both and a FORTH in AVR assembly language.

I never got into the Propeller even though I bought the Chameleon boards too.

He kept talking about something bigger and better in the works, but it was never released.

SIMMs were used in the late 1980s (in Atari STFM/STe which use the 68000). I have not checked any of the DRAM chips used on any SIMMs, but before then, some DRAM chips were available with their own built-in refresh counters. You no longer had to supply the row address, instead all you had to do was to signal for the DRAM to carry out it’s own refresh. Of course this had to be done at a time when the rest of the system did not need to access the DRAM for a short time. So check the type of chips used on your SIMMs and read their datasheets.

There was a site showing a ZX Spectrum (uses a Z80A) with a SIMM wired in. But I could not find this when I last went looking.

The ISA is just an extension of the 8086 / 8088 bus. So it should not be a problem to hook up say, a Z80 to it. Some suitable glue logic will be needed to get a 6502 to use it. As said above, driving graphic cards will be challenging, primarily due to difficulties in working out the software side.

IDE CD-ROMs use a subset of the IDE hard drive protocol. The divIDE expansion (1990s technology) for the ZX Spectrum could access CF cards, HDD and CD-ROMs. The hardware is not too hard, but you will have to write suitable drivers, and I’m told that’s not much fun.

PAL chips were used in commercial home eight bit computers in the mid 1980s (1984). And 74HCxxx and 74HCTxxx were available in the mid 1980s onwards, even appearing in limited numbers in commercial home eight bit computers in the mid to late 1980s. They were also available to hobbyists via mail order (in the U.K. from Maplin for example).

Retro is a very vague term. Outside computing it often means the 1960s!

Mark