Tag Archives: Atari

68000, Atari

ATW800/2

12 Comments
Current Mega-ST version

Welcome to the ATW800/2 page – read that as you like:  “ATW800 two” or “ATW800 half”, depending on your expectation.😉
Whatever way, it’s the Atari Transputer Card as it was meant to be.

This is a pre-announcement – July/August 2024

Normally I do not talk about things which are still in the works.
This is an exception to the rule to inform “the scene” and especially other creators of hardware to prevent unnecessary diversification and fragmentation of an already small market.

I personally hate to buy a piece of hardware just to learn some time later, there’s another one available I wasn’t able to compare to the one I just bought.
So this is a ‘shoulder look’ for you to get an idea what’s coming.

To be dead sure: It already works. It will be released. It’s just not 100% done yet.

And for those, who haven’t watched it… here’s the hastly made YT video 😅

…and another one showing the card running on the VME bus of an ATARI TT

Background

Before we go into features & technical details (skip to those if you’re impatient) I’d like to talk a bit about motivation and goals of this project.

You might have read about my STG[A]TW card for the ATARI Mega-ST expansion bus. That contained an ET4000 graphics card borrowed from IBM PC ISA-land and an Inmos C011 Link-Adapter to connect to a Transputer CPU.
This showed the direction but was a bit cumbersome. Also, ET4000 cards are getting hard to find, expensive (>100€) and not all of them actually do work in your ATARI – and most important, my intention was to create something affordable – remember: Power without the price ✊

The idea is/was to provide a plug-and-play version of a expansion which brings your ATARI as close as possible to what the ATARI Transputer Workstation (ATW800) provided.
That is: Transputers of course as well as expanded graphics capabilities.

Here are my 6 goals I want(ed) to achieve:

  1. Be reasonably ‘historically correct’
  2. Create a design avoiding obsolete parts where possible
  3. Stay in a affordable price range
  4. Simple installation
  5. Integrate/play nice with other peripherals
  6. Offer flexibility

Goal #1 is a philosophical topic one can discuss for his/her whole retro-nerd life. It’s the same as with e.g. cars. Is it OK to put an US V8 into a Ferrari? Electrifying a 1970 Porsche 911? LED headlights in a vintage car? Trailer Queen or patina? The list and discussion will go to the end of humankind.
The very same goes for vintage computer systems. There’s nearly none left which hasn’t had a Raspberry Pi of some sort slapped into it. Starting with a Pi Nano as WiFi-module and ending with a full blown 1.5GHz Pi 4 in an 8bit machine… for my taste, this is not the way.
So with this project we stay with what would have been possible in the let’s say 90s. It might be reached by using more integrated parts, but no recent high-tech here. Sorry. Which brings us to the next point…

Goal #2 is more or less a financial decision. If you use parts which are long time out of production, you depend on a grey market which is limited and can quickly drain, might be full of fakes and prices explode due to greediness.
So instead of buying the last stock of e.g. ET4000W32 chips and create a redesign of an x86 ISA card kludged onto a 68k bus, it’s wiser to go for a ‘virtual design’ which won’t go EOL and can grow as we go… in this case: FPGA is the way. But following goal #1, don’t overdo.
If there’s (currently) no other option, we obviously have to go with the old parts. The Inmos C011 link-adapter is an example here.

Goal #3 limits #2 in some aspects. It’s relatively simple to pick a recent FPGA which actually would be capable to easily simulate your whole ATARI ST (or two)… but that would be quite expensive – not just the chip but also the design, which requires external RAM, 3-4 voltages and multi-layer PCBs to cope with 200+ BGA connects.
The compromise here is an FPGA board which offers all that already mounted onto it and will be piggy-backed onto our card.
And because cheap is always a challenge, we went for the Chinese Nano FPGA family which has an unreached price/feature ratio and fits the “Power without the price” mantra.

Goal #4 is quite simple: Not everybody is a virtuoso with his/her solder iron. So I tried to avoid as much additional soldering/cabling as possible.
Basically you plug the card into the Mega-ST or VME slot and you’re good to go.
In fact, as of today, there’s just one cable to plug(!) if you want to use one optional feature of the ATW800/2 (ACSI INT). No soldering whatsoever.
Also, you should be able to plug the card in and use it without additional needs. That’s why it offers (optional) TOS ROMs.
This is the way 😉

Goal #5 reflects the awareness that there are mostly souped-up machines out there. I daresay no one who plays with uses his Atari unenhanced in one or the other way.
The ATW800/2 tries to play nice with other common expansions by precisely decoding (previously unused) addresses and even integrate their features like the looped-through USB port of the Lightning-ST.
That said, there are so many old and new peripherals that nobody can guarantee that everything works nicely together with an ATW800/2 – especially on an overloaded bus.

And because of this Goal #6 will be covered by “bespoke ordering“.
Not everybody will be interested in having 2 TRAM slots for hosting real Transputers – so you can leave them out and save some €€.
The same goes for the TOS ROMs. If you already have another ROM switcher, just leave it unpopulated.

Reality kicked in

Having all that planned out, back to the drawing board I went… just to realize that I cannot handle that all by my self.
So it became clear that I have to ask specialists if they like to join the effort.
Let me introduce you to the team aka “The league of extraordinary Transputer gentlemen“:

  • Wolfgang ‘Idek’ Hiestand of the Nova drivers fame.
    Back around the start of the 2000s, Wolfgang looked into getting his hands on the Nova source code with the intention of preserving knowledge about Nova cards. It took some time, but in the end he succeeded in recreating the original drivers. Since then, he has maintained and extended Nova drivers to support additional VGA cards and ATARI computers. For this project, Wolfgang has created a branch of the Nova drivers to support the FPGA-based card.
  • Claus Meder. God of all things FPGA and fellow Transputer maniac. So much actually that he wrote a Transputer core in VHDL.
    Claus designed and wrote the impressive graphics-core for an FPGA from hell.
  • André Saischowa. Atari and Transputer fiddler of the earliest hours. He wrote Transputer and Atari ST programs back then and just got into the matters again when we met. Perfect timing!
    André ported all INMOS tools as well as the Helios server… plus developing  driver .sys files for NVDI.
  • Honorable mention: Mike Brüstle of transputer.net. The man whose brain natively runs Transputer assembly code.
    When you have a question regarding Transputers and he doesn’t know the answer, nobody does.

All four of them have many, many more talents and without them this project would still be just another dream of mine. ❤

Features

Ah, finally… features.
I assume you’re roughly in the picture, what the ATARI Transputer Workstation was all about. Basically, it was a Transputer system running Helios  which used an Mega-ST1 as host. The powerful graphics chip (“Blossom“) was connected to the Transputer which ran X11 on it to display graphics in 1280 by 960 pixels (16 colors) or 1024 by 786 pixels in 256 colors, making the most out of its 1MB VRAM.
As said the Atari part was mainly just I/O: Harddisk, keyboard, mouse, serial and parallel interface. No access to Blossom and after booting, there was no way to run Atari software from/in Helios.

Today that’s bugging me, and like said before, I think Atari or Perihelion, the company behind Helios as well as the ATW, took the wrong approach.
The Transputer system should not sit on top of the Atari system but next to it. Both, TOS/GEM as well as the Transputer(s) should have access to all that pixel beauty.

So there you have it, the two main features and ‘raison d’Être’:

High-Res color graphics 👾

The ATW800/2 graphics controller is actually a tiny and cheap FPGA board piggybacked onto the card. While we started out with the Tang Nano9k it soon proved to be unstable as soon you stretched it to the max… as for now, we changed to the slightly more expensive Nano20k which therefore offers more room and faster/bigger RAM.
[NB: This is the prefect proof that it does make sense to keep this part “virtual” – no shortcoming or chip EOL’ing can stop the product itself. All it needs is an adaptor.]

Displays will be directly connected to its HDMI port.

The running core, called “Seurat” (named after the inventor of Pointillism), has access to 2MB of VRAM, which is twice what Blossom had. Thus there are quite some resolutions possible (in 2,  8 and 16 bit colors):

Woo-hoo… holy Bat-Resolution! 🤯 (1600×1200@256)

To cope with such an amount of pixels Seurat features a blitter with is able to push roughly 130MB/s for fast redraws and smooth scrolling.

As of today (July 2024) the current Gembench 6 numbers vs. 640×200 ST-Med (no NVDI!):

Transputer(s)

Yes, they might not be of everybody’s interest, but they were the main actor in the ATW800 and are fascinating beasts when you take a closer look at them.
32bit RISC’ish CPUs, running at 20-30MHz, each having 4 links to directly connect to other Transputers. That way one can create a massive, unlimited parallel system that blew away anything you could run at home back in 1990.
This strictly follows my goal #1: Historically correct. Run things on the real stuff and feel how an ATW800 felt back then.

The ATW800/2 features 2 slots for classic size-1 TRAM modules next to the Nano20k. Here’s one size-2 TRAM installed:

TRAMs were/are available in many configurations, for those who want to know more, I made a dedicated page about TRAMs.

But that’s not all. Because Claus isn’t Claus without some sort of magic, he also added a synthetic Transputer core into Seurat.
That core is 100% T425 compatible and can not only access his own RAM (6MB, can be partitioned by the user) but also the Video-RAM… like Blossom did.
To make everything perfect, this synthetic Transputer has a link to the physical Transputers on the ATW800/2 which are also linked and themselves have a link at the edge of the card to connect to the outside world.

To round this up:
Everything is shared with the Atari host. You have access to the physical Transputer(s) and the synthetic ones over the 68k bus.
GEM has access to the VRAM as do the synthetic Transputers… and indirectly over their links, the physical Transputers, too.
Given proper programming, the possibilities are endless. Here are some ideas:

  • Accelerate Atari programs using Transputers (send data, let them do the math, collect results)
  • Run X windows on Helios (running the X client on a synthetic Transputer).
  • Use the synthetic Transputers as GPU. Let them do the VRAM manipulation. Lines, vertices, transformation… you name it.
Optional features

But wait, there’s more 🤓… at least for the Mega-ST:

Like I told you in the beginning, I’d like to be this as much plug-and-play as possible. So the ATW800/2 optionally features 1MB in-system programmable Flash ROM. That ROM can host 4 different versions of TOS selectable by two DIP-switches at the back-edge of the card.

Next to that DIP-switch you’ll find a dual USB port. That is a dumb loop-through to the front left edge of the ATW800/2. It is meant to connect an optional Lightning-ST so you have a nice & clean way to lead those connectors to the outside without cutting holes into your Mega-ST case.
Alternatively you can use these port to power external ACSI drives like the ACSI2SD or ACSI2STM etc.

Besides the 3 external Transputer-Links there’s also an internal one at the cards front. Just in case you have my relocator installed…

The ATW800/2 features a battery-holder for a coin battery. Because the original AA battery compartment of the Mega-ST can get in the way with the ATW800/2, this might have to be cut out 😥.
That holder can then replace the original one.

And finally, because the Nano20k has it already on-board, we’re planning to provide a harddisk interface using the Nano’s Micro-SD feature. For easy access, this is also routed to the back edge of the card providing another Mirco-SD socket. An alternative internal pin-connector is provided if you like to place the SD-card slot elsewhere.
This feature is not yet implemented but is the next on the list after VME ist running…

Why “Mega-ST” only?
Well the ATW800/2 will also be available for the VME bus, i.e. Mega-STe and Atari TT.
Most of those optional features aren’t needed in those systems. Also VME cards require a 0.5mm unpopulated edge on both sides to slide into its cage.

  • ROMs cannot fully served through the VME bus.
  • When installed in the VME cage, there’s nearly no way to feed in the USB connector of a Lightning-TT.
  • Same goes for internal TRAMs and a battery cable.
Look Ma’! VME connector fitted! (yes, its an older board revision but you get the idea)

There you have it. This is all we’re able to talk about right now. Some smaller details might change until the release – that’s called ‘agile’ 😏
Let’s sum it up again:

The ATW800/2 will be available for the Mega-ST bus as well as VME bus. This is our progress so far. It will be updated every time we think it’s worth doing so.

Mega-ST bus support
100%
VME bus support
90%
Graphics
99%
Real Transputers
100%
Synthetic Transputers
80%
4 TOS ROMs selectable and programmable
100%
Using MicroSD as harddrive
50%

Technical details

The ATW800/2 basically consists of 3 main devices:

  • The FPGA (“Seurat”)
  • The CPLD (“Absinth”)
  • The Inmos C011 link-adapter

Absinth is the glue to the system-bus. He decodes addresses, manages the different functions on the card and controls the C011. He’s also the gateway between the 5V and 3.3V worlds.

Seurat itself, the core within the FPGA, consist of the Framebuffer controller, a blitter and (currently) two synthetic T425 Transputer cores.

This is a schematic representation:

FAQ

Q: When will you release?
A: When we think it’s usable. That is at least Graphics and Transputers are at 100%.
Some minor features might be added by firmware updates later on. E.g. we consider the harddisc interface as “nice to have” but not essential as most users have at lease one HD replacement already. So that might be added later.

Q: Ok, I’m confused. How many versions will be available then?
A: As of today, we plan various levels of populating the PCB, depending on what makes sense on the specific platform – all versions have the graphics part, i.e. Seurat and Absinth and the USB loop-through connector.

The ATW800/2-VME card will be basically it. Most additional features are useless or redundant in an Atari Mega-STe or TT.

On the other hand the vanilla ATW800/2 for the Mega-ST comes with the clock-battery holder, an auxiliary power cable and will give you some options to choose from:

ATW800/2-R – added TOS ROM sockets and Flash ROMs plus DIP switch to pick one of 4 TOS versions.

ATW800/2-T – features the Inmos C011 link adapter, TRAM sockets, internal and external link connectors.

ATW800/2-RT – the full whopper 🍔

Q: If I chose not to go for a “-T” or “-R” model in the first place, can I populate those parts myself later?
A: Sure! All extra functionalities are build in Absinth already. If you’re fine with soldering and do not expect support on your additions, give it a shot.

Q: Shut up and take my money! What will it cost?
A: We’ll calculate this as soon we are 100% sure that all basic functionalities are working as expected. But according to goal #3, it won’t be incredible expensive.

Q: How will updates work?
A: As for now, Seurat (the FPGA) has to be updated via USB-C using the GoWIN Programming software (Registration required, Linux and Windows only but also works fine in VMs).
Absinth (the CPLD) needs to be updated via JTAG. This requires an Altera USB Blaster and the proper Software (part of Alteras/Intels  Quartus II IDE – 1.5GB download, registration req’d… sorry.)
We’ll provide proper documentation on this when we’re shipping.

Q: Will it work with device XYZ and/or accelerator ABC?
A: We tested the ATW800/2 with peripherals we own ourselves. That’s probably 2% of the things ever made for the Atari ST/TT – so there won’t be a guarantee that a device we don’t own will perfectly work with the ATW800/2.
That said, we will depend on your feedback and are happy to support creators of other devices to make the ATW800/2 behaving well.

As for now we positively tested the ATW800/2 against these accelerators:

    • AdSpeed
    • Turbo25

Also those devices seem to work OK up to now (more in-depth testing needed):

    • Lightning ST
    • Cloudy(-Storm)
Q: Regarding software compatibility, would you consider adding Blossom support? I mean Blossom hardware registers like blitter, screen resolutions etc.

A: No, we’re not doing anything Blossom’ish. There’s actually not much sense behind this for some reasons:

  1. Nothing supported Blossom but the Helios graphics/X11 driver.
  2. The Atari-side of the ATW800 had no access to Blossom at all.
  3. Developing VDI drivers for it requires reverse-engineering of hardware which we do not own
  4. It’s simpler to start from scratch and add things as we need them

So “Seurat”, the controller inside the FPGA is accessible by both, the Atari (VDI etc.) and the Transputer(s). Even at the same time(!) if this would make sense in some cases.
Seurat also has more possible video-modes than Blossom had with 1MB video RAM:

mode 0: 1280 by 960 pixels, 16 colors out of a palette of 4096
mode 1: 1024 by 768 pixels, 256 colors out of a palette of 16.7 million
mode 2: 640 by 480 pixels, 256 colors out of a palette of 16.7 million
mode 3: 512 by 480 pixels, 16.7 million colors

With 2MB video RAM Seurat can go from 320×200 up to 1600x1200x8. Bit depths are currently ranging from 1 to 16bit. It also supports the original Atari modes like 640x400x1 and could do 640x200x2 and 320x200x4… even there’s not much sense behind this.

Q: Hey, I have an idea: What about adding [enter cool feature here] !?
A: Sorry, we had hard times to even hold ourselves back from feature-creep. Actually, we think the ATW800/2 has enough features already. Some not implemented functionalities are just handled better by  already available devices .

Q: I don’t have an HDMI display, what about good old analog VGA?
A: We had to decide how to use the limited space at the external edge of the card. So the onboard HDMI of the used FPGA board was a natural choice.
Sadly all Nano FPGAs provide a “just enough-HDMI” signal which does not provide all needed signals for external converters etc. This includes HDMI to VGA converters or power-injectors.

Q: Why didn’t you just took a Raspberry Pi?
A: Have you read our goals? Please do so now. Thank you.

Q: Do I need a bigger power-supply?
A: It depends. If you’re still using the original power-supply of your Mega-ST this might be a good moment to replace it with something more recent.
The ATW800/2 is not tremendously demanding. With one TRAM plugged into the board, calculating Mandelbrots and displaying them in 1024×786@8bit, a 4MB Mega-ST draws 1.65 amperes in total.

Q: Can I have the source-code, schematics or gerber files?
A: Sorry, this is not an open-source project. We have to cover quite some initial R&D costs and we actually don’t like those ePay copycats.
That said, we – the extraordinary transputer gentlemen – are open for personal request in which you can explain why you need those and if there’s a convincing reason, we might share what we have.

Q: This sucks! XYZ is way better than your crap!
A: Yes, you’re right. So please move on, there is nothing to see here.

68000, Atari, DIY Transputer interfacing

Tto68k

Leave a comment

The Tto68k project started by a classic “phone call doodling” situation… but instead of drawing strange patterns I was fiddling alternately with one of Transputer TRAMs and a spare 68000 CPU I had laying on my desk.
At one point it dawned to me, that the 68000 classic 64pin DIL package perfectly fits in-between a TRAMs socket-pins 😲.

Obviously this discovery immediately had to go into a project which I called Tto68k – actually it is a spin-off from the STG[A]TW project which I recently did for the Atari Mega-ST.
So this is fully compatible and everything developed for that card (minus the VGA stuff, obviously).

Three in a row…
Ahhh… a perfect fit!
15 MIPS topping the 68k’s 1 MIPS 💪

Where space allows, the PCB offers certain features:

  • 2 LEDs showing the Transputer status (running/error)
  • An external Link, compatible with the STGATW and my CPU-relocator. Thus you can connect to another TRAM on that one.
  • Dedicated 5V/GND pins to feed-in external power (if needed)
  • Version 1.1 will have two “multi-purpose” pins (see below)

So while the features are pretty basic compared to the STGATW, it has one advantage: The 68000 socket is system-agnostic. And I don’t mean just the different ATARI ST models (520, 1040, Mega) but other systems, too. E.g. the AMIGA, the entry Macintosh line etc. As some of them have more advanced bus management than the ATARI, I saved two of the CPLDs pins as “multi-purpose” pins.
For example in the case of an AMIGA these could be used for the configuration chain (/CFGINn, /CFGOUTn).
While in the ATARI STs those will be used for TOS ROM decoding… or whatever comes to my/your mind.

All that said, this post is just an announcement for now.
Like mentioned, I’m working on a Version 1.1 which will be much more usable, especially for other systems than just the ATARI ST.

68000, Atari, STGATW

STG[A]TW programming and software

Leave a comment

Ok, you read/heard about the STG[A]TW and want to know more about how to use it and -most importantly- for what it’s good for?

First and foremost, a Transputer is a computer-system of its own connected to a host. In this case an ATARI Mega ST.
But given an available host-adapter that could also be e.g. a Unix machine, a classic PC, an Apple II or even a Commodore C64, C128 or Plus/4…
That host communicates with the Transputer over a link-interface using specific memory addresses or, if available, a library. That way the host can send executable binaries to the Transputer, send or receive data to/from it and control  it (boot, debug, etc.).

Because each host system is different, these addresses are different, too. But the transfer protocol and Transputer executables are always the same. So looking at this BASIC code example for the C64 gives you an idea, how it works – the steps are the same for every host-communication no matter which host-system used.

As usual, here’s a table of contents for those being in a rush..

Quick intro about standards & history

Yes, there have been very different ATARI ST and Transputer interfaces in the past. “Two and a half” systems were most prominent – let’s have a look at them before we go into details of the STG[A]TW.

The Atari Transputer Workstation aka ATW800

I think I’ve already wrote a lot about the ATW800 in several post on this page, even designed an expansion card for it – despite I don’t own an ATW myself.
To make a long story short: This is basically a design, where the ATARI Mega-ST is used as a boot device and after that just handles file- and user-I/O. The Transputer is attached to the ST via DMA and runs the Helios OS and has direct access to the graphics controller called ‘Blossom’. Totally different concept.

KUMA K-MAX

The KUMA  K-MAX was a box connected to the ATARI ROM-module port and thus acted as pure ‘number cruncher on a leash’.
There are two reviews still available: The English review of atarimagazines.com and the German ST-Computer article even showing some photographs of which I ‘borrowed’ this:

Transfertech

Outside “the scene” this is a relatively unknown German company which actually made a lot of Transputer-centric hardware.
For the ATARI series they had 3 host interfaces:

  • A ROM port interface (all ST models)
  • A Mega ST bus interface (ROM port design botched onto the bus)
  • A VME-card (Mega-STE, TT)

Like the KUMA K-MAX, this design also attached the Transputer(s) as number cruncher.
As I own all of them, I might write a dedicated post about them some day.

This is how we do it

As all of the above did their own thing, there is and was no standard for interfacing the ATARI ST series – So I defined one with the other ATARI ST Transputer enthusiast André Saischowa, who did some intense ATARI Transputing fiddling back in the days.

In case of the ATARI ST the link-interface ( e.g. STG[A]TW) ‘lives’ at the base address 0xFFFAC0 and uses 18 bytes from there up to 0xFFFAD2. So the complete adress-range looks like this (uneven, so we can address the lower byte of a 68000 word):

#define base 0xfffac0
#define inreg base+1 /* C012 */
#define outreg ((base)+3)
#define instat ((base)+5)
#define outstat ((base)+7)
#define reset ((base)+17) /* writing*/
#define analyse ((base)+19)
#define errflag reset /* reading*/

But you don’t have to bother with those as we provide two more convenient ways to talk to a Transputer.

☝ Some words of warning to the programmers:

  1. While the 68000 in your ATARI is big-endian, Transputers are little-endian. So data being send back and forth might need conversion.
  2. Floating-point variables used by the Transputer are IEEE 754-1985, thus 32 Bit (single precision) or 64 Bit (double precision).
    Some compilers like Turbo/Pure-C on the ATARI ST use 80bit doubles.
    Those need to be converted by e.g. the xdcnv call from the PCFLTLIB library.

The static way

The raw-way is using an include file called “trproc.h”.  It’s – like everything else – included in the program archive, located in the “DEVELOP” folder.

This include-file provides you these calls to receive (get) or send (put) data to/from your Transputer:

get/puttrchar(char) read/send one byte
get/puttrshort(short) read/send a short (2 bytes)
get/puttrint(int) read/send an integer (32 bytes)
get/puttrlong(long) read/send a long (32 bytes)
get/puttrfloat(float) read/send a float (32 bytes)
get/puttrdouble(double) read/send a double (64 bytes)
get/puttrraw(char *array, int length) read/send an array of length

The calls marked blue are doing the endian-conversion for you.

Additionally there’s a call to check for an available Transputer: checkTransputer(int checkType) 

If checkType is ‘0’, this function will return ‘1’ if it was able to find a Transputer or ‘0’ when not.
Setting checkType to ‘1’, the return value will give you the “family” of the found Transputer:

0 – No Transputer found
1 – Found a C004 link-switch
2 – A 16bit T2xx Transputer was found
4 – A 32bit T4xx/T8xx Transputer was found
-1 – Found something unknown

The elegant way – TBIOS

The much more elegant way is provided by André who extended the ‘ALIABIOS’ from a project published in the German computer magazine c’t back in 1989.
It’s a GEMDOS driver called “TBIOS.PRG” and can be put into your AUTO folder or called manually when needed. This driver has all the bells’n’whistles like a proper XBRA-ID etc.

DOS# call-name - result (D0=0 Ok) 

100 SetLinkAdr(Adr:W) D0 =-1 not ready 
101 ByteToLink(Value:W) D0 =-1 Timeout 
102 ByteFromLink() D0 =-1 " 
103 LongWordToLink(Value:L) D0 =-1 " 
104 LongWordFromLink((Value):L) D0 =-1 " 
105 SliceToLink((Buf):L,Len:L) D0 RealLen 
106 SliceFromLink((Buf):L,Len:L) D0 " 
111 TestError() D0 =1 Transputer Error 
112 SetReset() D0 =0 
113 SetAnalyse() D0 =0 
114 BootRoot((FileName):L) D0 <0 Error 
115 NewFunkOk() D0 ="ELK1" functions available 
116 BlockToLink((Buf):L,Len:L) D0= sent bytes
117 BlockFromLink((Buf):L,Len:L) D0= sent bytes -
118 BlockFromLink((Buf):L,XLen:L,YLen:L,Offset:L) without timeout
119 GetCommand(Buf) D0 =-1 no command found 
(as SliceFromLink but shorter timeout)

👉 Need short coding examples here

Programs and demos

As ATARI never planned something like this card, there’s no ready-to-use software… it’s up to you to create miracles 😊
But compared to my 8bit Transputer adapters, there’s quite some stuff to start with:

💾 Visit the Atari Transputer Software repo at GitHub (most recent) or get this ZIP archive containing everything discussed below.

Basic Testing

Yes, literally, we’re testing if your Transputer is working correctly using a BASIC program called T_TEST.GFA – so right, it’s GfA Basic in this case. But in essence it’s nearly the same used for my C64 or Apple II interfaces.
This little Program checks if it can find a link-interface, a Transputer and if so, which kind (16 or 32 bit). If that went OK, it does a little coms-speed test by reading 4KB from the Transputer and times that.

Mandelbrot fractal

You knew that this has to be the first thing to be written 😜
There are two Transputer binaries…

TMANDEL.PRG – the evil, dirty, down-to-the-metal, direct-to-screen-writing version.
This is good for getting an idea of how fast data is being pushed to the Atari ST without much handling overhead.
As this writes to the Screen directly, it only runs in “ST-High” resolution (i.e. 640x400x1).

GEMMAN.PRG – The well behaving GEM version.
It opens a window max’ed to the current resolution and starts plotting the fractal in 16 colors. This takes longer than TMANDEL, as it does quite a bit of GEM juggling before plotting a pixel…

Getting serious

So, this is the part for doing serious things with your Transputer(s) and specifically André Saischowas domain.
He did not only port all needed INMOS tools like iserver to run all the available development tools from back in the days (OCCAM, C, etc) but also ported the Helios server, i.e. the software which runs on the host (i.e. your ATARI) and communicates with the Helios Kernel(s) running on your insane Transputer Farm!
This is a good 75% of what the ATW800 offered – the missing 25% are the graphics which ran on the Blossom chip and was only accessible by the Transputer.

That said you’ll currently find 2 folders in the archive:

  • C-Code – contains the Mandelbrot demos
  • Andres – the serious stuff containing
    • AUTO – the TBIOS driver and stuff needed during ATARI bootup
    • BIN – the INMOS tools like iserver as well as the always-needed ispy utility
    • D72UNI – contains the transputer hosted compiler environment based on d7205a (OCCAM) and d7214c (C-Compiler). Visit transputer.net for plenty of documentation on those. See the README in that folder.
    • HELIOS11 – well, that’s the Helios v1.1 distribution. It’s way smaller than the v1.3 and good for an initial try. You can later switch to v1.3.1 following these steps.

There you have it (for now) – the ATARI ST is therefore the currently third best supported host platform after the PC running DOS or Windoze NT(!) or SPARCStations running Solaris 2.

68000, Atari, STGATW

The STG[A]TW

Leave a comment

This is my first ever project I did for one of my favorite computers, the ATARI Mega-ST. Like told in one of my blog posts, the ATARI ST was my 2nd greatest love ❤ (after the C64) and being part of a very  cool company back in the days I only have fond and happy memories of it.

After all the years of fiddling with nearly every machine on the market, it’s like coming home by just looking at its system font or hearing it’s specific bell-sound (even the ever-annoying key-click sound it makes by default).
And now it’s time to do something cool with it… adding, what I’ve missed back then: Color and -of course- Transputers 😉

TLDR;

Ok, so you’re in a hurry or suffer from severe ADHD?

This is a graphics card for the ATARI Mega ST internal bus including a Transputer interface.

Got it. More details please…
What about software? (links to a different post)
Why, for god’s sake!?
There’s a relocator, too?
Ok, how much?

NB: This card is now superseded by the ATW800/2

Say hello to the STG[A]TW!

What’s that about the strange naming?! Well, this card is a hybrid of a classic STGA ISA graphics-card adapter and a Transputer interface for the Mega-ST bus.
Mega-ST, high-res graphics and Transputers? Mhh, does this ring a bell? Yes, component-wise this is exactly the configuration of an ATARI ATW800, the famous and rare ATARI Transputer Workstation (for which I designed a Farmcard, just in case you own an ATW).
So adding the two, it’s an STGA-ATW or STG[A]TW for short… and it looks like this:

Looking at the top you’ll spot the 90° angled ISA Slot at the right edge, giving (selected) ET4000 graphic cards a home.
To the left there are two Transputer TRAM slots making it possible to use two size-1 or a single size-2 TRAM.
Obviously, an ISA card and the TRAMs would collide, so you have to choose… or you’re a lucky owner of a low-profile ET4000. Then you could use your VGA card plus one TRAM like this:

But even if your ET4000 card is covering the whole STG[A]TW don’t despair! Looking at the backside you can spot the external Transputer link connector (on the right edge):

Using this you can connect to e.g. an external Transputer(-farm) of any size… for example something like my 64 CPU Final Cube 🔥

Looking further around the backside you can spot a preparation for a CR2032 coin-shape battery holder. That is meant to replace the two AA batteries used in the original case-lid because depending on the TRAMs used, it might be necessary to remove the battery compartment (yes, you’d need to cut it out 😰) .

Talking about power… at the bottom you can see the external power connector which supply is mandatory – you need to connect at least 5V and ground, optionally 12V if your ET4000 needs that.
That said, I highly recommend to make sure your Mega ST’s PSU is powerful enough – best would be to replace it by e.g. a Maxwell RD-50A.

Why?!

I knew you’d ask. Well in case you haven’t noticed yet, I’m a total Transputer nut. It’s a fabulous, genius CPU and design. The more you dig into it, the more you’ll love it.

Back then I adored the ATW800 and always wanted to own one. But it was insanely expensive and -to be honest – wasn’t a real member auf the ST/TT-family anyhow.
This is because the Mega-ST1 inside the ATW was mainly used as a bootup machine for the Transputer and after that was up and running, everything the ST did was file- and user-I/O (Mouse, Keyboard, RS232).

In my humble opinion, the STG[A]TW is (somewhat) the way how ATARI should have done it back then. Instead of creating an ‘island solution’ they should have used the existing install-base and offer an expansion to it. Plug in the missing parts (graphics & Transputer) and keep the TOS/GEM eco-system in charge.
Users could keep running their applications and use the extra ‘ooomph’ to speed them up. Think of all the accelerators Apple Macintosh users had available to speed up PhotoShop filters or have it do the heavy number crunching of science applications etc.
Even all data has to travel over the bus to the Transputer and back, this is still faster than the 8MHz 68000.

Given that in 1990 about 350 ATW800 were produced and sold at 5000-7000 GBP which equaled to about 13700 DM or 8000$ (that’s about 11400 GBP, 13700 EUR or the same in US$ today),
I bet the number of a “ATW for the poor” would have been much higher.

So, again, why? Well to have Mandelbrot fractals calculated fast and  in colo(u)r, of course!
Fast means ~60sec, even using slow GEM routines. Using the same algorithm and iteration depth, the ST’s 8MHz 68000 took nearly 3 hours to calculate the same fractal.

Here’s a quick peek how ‘fast’ looks like:

Evolution – a quick excursion

If you’re into hardware development you might wonder why there’s a very vintage GAL and a semi-vintage CPLD used in this design.
Here’s my explanation and shameful justification 😉

From the very simple and basic design of the STGA I took the usual nerdy feature-creep road to hell 🙄
My initial design naturally included the GALs logic into one big CPLD. And having all address-lines available on this, that design also included (on top of the ISA and Transputer interface) a 68882 FPU, an IDE interface and a ROM decoder… everything worked fine BUT all ‘modern’ ET4000 cards didn’t.
I stared at logic-analyzer traces for weeks and weeks and compared them to the original STGA they were absolutely identical. But whatever I did, I wasn’t able to get ET4k cards with a Rev. TC6100AF chip working.
In the end I decided to keep the STGA part as-is, including the external AND-ing of /LDS & /UDS and inverting of /DTACK and put the Transputer handing into a smaller (and cheaper) CPLD.
Thus the FPU, IDE and ROM decoding was off the table and to be honest, there are other solutions which do that job better anyhow.

From left to right: STGA, the Über-STGA and the final STG[A]TW

So there you have it: Colorful high-res GEM combined with the mighty Transputer power… but I understand, that those low-profile ET4k cards are getting rarer and rarer and not everybody has an external Transputer farm to connect to.
So I made another card or better a so-called CPU relocator…

The TRAM-Relocator

Most (Mega) ST users out there already have one or more expansions to their system, mostly plugging into or onto the CPU creating a ‘stack’ of PCBs.
Because the STGA (as well as the STG[A]TW) overlaps over the Mega STs CPU socket you might want relocate the CPU a bit away from the Mega-Bus socket. Simple relocators simply move it a bit towards the front of the case. But that still results in having a stack of multiple extensions. For example here’s a Storm ST (Alt-RAM) on top of a Cloudy (4x ROM) plugged into a Lightning ST (IDE & USB):

This can get tricky in some crowded Mega ST cases…

I really liked the ‘Bus I/O port design’ of the Exxos’ STF Remake Project having multiple sockets next to each other.
And if you have your original TOS ROMs removed (and replaced by e.g. a Cloudy) there’s actually some space to roll out 4 of them having the Relocator sitting flush on the Mega-ST mainboard (make sure the backside of the Relocator is completely isolated!):

4 Sockets and a cool TRAM socket 😁

Like clearly written on the PCB, SOCK1 goes into the (to-be-retrofitted) CPU Socket and using ‘hollow pins’, it can take a CPU itself.

SOCK2-4 are available to extensions of your choice – all 3 of them are protected against power-surges by a fuse and a diode.
This design decision has been made due to my own painful experience loosing everything which had been plugged into the CPU socket… and the Blitter 😥

In the lower right corner are pins for an additional external power connector, also protected. That might be necessary depending what you’re plugging into those sockets.

Finally, the left edge is a Transputer TRAM socket which can be connected to the STG[A]TW by a 10pin flat-cable providing link signals and a 5MHz clock signal.
That way, you can use the STG[A]TW with an internal Transputer even your ET4000 card is big as a baking-tray.
It is highly recommended to use external power when doing so. The poor 68000 power-pins won’t be enough for it.

If needed, the whole TRAM part can be snapped-off from the Relocator to, uhm, relocate the TRAM elsewhere in- or outside the case or use it stand-alone. For that matter itself features an optional connector for power as well as a place to solder a required 5MHz oscillator and 2 mounting holes.

With everything in place, your “ATW800 for the poor” could look like this:

What you see here is the STG[A]TW plugged in, giving home to a low-profile ET4000 and a Size-1 TRAM.
The Relocator was plugged into the CPU socket and in its 1st slot the  Cloudy-Storm  and the 68000 sitting on top of it, took seat.
Slot 2 of the Relocator is taken by a Lightning-ST… and last but not least, a second TRAM was put onto the Relocator (you can spot the grey flat-cable connecting it to the STG[A]TW.

Want one?

All this sounds so cool that you want to own a STG[A]TW?
Well, first check out this list:

  • There’s next to no GEM user software for it yet
    👉 but we’re working on it and there’s a pretty good system support in place already – and Helios is running already! 🥳
    An extra post on that is currently in the works available here.
  • Do you have an ET4000 card of which you know it’s working with the NOVA drivers?
    👉 I am not able to support you in getting your specific card working – there are just too many models and permutations of possible TOS/GEM/Driver installations. See this atari-forum.com thread to get an idea…
  • Do you own a TRAM?
    👉 I might provide you with one at extra cost, mail me.
  • Do you have time to wait?
    I’m manually building these boards and it’s a lot of work (0.5pich SMD, lots of trough-hole pins to cut and file down etc.)

If that’s 4  times “Yes” I can build & sell you one of the 6 which I have left for 100€ (plus shipping)… yes, that’s hefty but the quite large PCB is 4 layers (for stable power-distribution), just the ISA slot connector is 10€ already, Mega Bus 5€, GAL, CPLD etc.etc…. plus, as said,  it takes quite some time to build & test them.
Drop me a mail on the bottom of that page if interested…

SOLD OUT… sorry 😥

As for the CPU-relocator, I’m selling un-populated PCBs for 8€ (Or get the gerbers here and have yours made at your favorite PCB manufacturer).
I’m not building them because the CPU ‘socket’ (SOCK1) is made of 64 single pins which you have to pry/get out of precision pin-headers.

That’s a tedious work you most likely want to do once… but not many times.

All that said – If you weren’t able to get a STG[A]TW, don’t despair.
I consider this as my stepping stone and learning platform for something cooler to come 😎.
Because I don’t like vapor-ware and hot-air-talking, I’ll tell you more when it’s a) done and b) working.

Atari, DIY Projects, DIY Transputer interfacing

ATW800 Farmcard

4 Comments

Sometimes a man has to do what a man has to do 😉 And this time it got to be an ATW800 Farmcard.
A what? ATW800 stands for ATARI Transputer Workstation – basically an Atari ST and a Transputer subsystem in a tower case (just about 250 were build and sold) and looks like this:

Atw front.jpg

Background

Even I still do not own an ATARI Transputer Workstation (yet), I “know” it from the very first presentation when working at the 1988 CeBIT Atari booth back then. The initial demo version used a standard Atari Mega-ST connected to a blunt Atari-PC3 case which housed the Transputer stuff… and the whole thing ran the Helios Operation System about which you can read quite a lot in this GeekDot chapter. Well, actually that was no wonder given that Perihelion Ltd. was not only the creator of Helios but also the birthplace of the ATW800 (Called ABAQ in the early stages).

The final version (the one in the tower case) used so-called Farmcards to expand the number of Transputers available to the system. A Farmcard featured 4 fixed Transputers (T425 or T800) with 1MB of RAM each. Here’s a piccy (click to zoom):

That might be plenty back then, but even in those days progress was made quickly and INMOS presented their TRAM Modules at nearly the same time… and these give you so much more flexibility and also save space. Actually, if you closely read the marketing material from Perihelion you will spot the announcement of a TRAM Farmcard. It just never made it…

I did it my way…

So it was just a question of time until I start to design a TRAM-Farmcard. After many years of unsuccessfully hunting an ATW which is for sale, I at least met shock__ (atari-home.de forum) a lucky ATW800 owner who was happy to help. So using the available documentation and the data provided by shock__ I created this:

Features

So what gives? Well, first of all, there aren’t any original Farmcards available anymore. Even if there were, they’re pretty limited. One Megabyte is enough for a computing slave using pure OCCAM but if you’re using Helios, 300k will already ate up by its core demons. Then there’s space for just 4 Transputers, not many given the size of the card.
That said here’s what this new Farmcard provides:

  • 8 TRAM slots. Can be used for anything. Computing, SCSI, Ethernet or graphics TRAMs. Be it size-1 to 8. There were many, many cool modules available. Today you can at least use my AM-B404 TRAM, a super-fast 2MB size-1 compute TRAM.
    This would mean twice the CPU oomp, and double the RAM.
  • Freely programmable Altera EPM7032/64 CPLD. It will implement Perihelions diagnostic-bus, meant for controlling each Transputer separately. Updates can be done in-field.
  • An external RS422-link. Using differential transceivers (26LS31/32) one can connect external Transputer networks over a distance up to 20-30 meters (vs. 30cm in pure TTL).
  • 4 layer PCB design giving stable power distribution throughout the board. Still, simple layout, easy to patch and only through-hole parts being used to make building as easy as possible.
  • 2 LEDs. Just say’in…

Because of the added Transputer-Slots the network topology looks a bit different than is used to be on the original Farmcard.
This is the “old one”, a simple square, each Transputer has two free links being available at the edge connectors J1-J8:

And this is how the 8 slots are connected:

Now each Transputer has just one link connected to the edge-connectors. Slot 7 uses link-3 to connect to the optional external RS422 connector.

Free as free beer!

Because there are probably only two handful of ATW800 owners out there, I made the schematics freely available here under the GPL license. But to make things clear:
This is untested stuff! The card is huge. It is not cheap to have it manufactured. The best price for 10 PCBs I was able to find was about $250.

The hard part

While the cards design was pretty straightforward the “firmware” of the CPLD will be a different beast. As said, Perihelion used a proprietary bus called “diagnostic bus” (DBus) – a two wire bus used to address all or just a single Transputer in a network to either reset or put him into the so-called analyze-state to do some post-mortem debugging. Pretty advanced stuff given that standard Transputer networks simply used a global reset.

Luckily the DBus is documented in the (short) Farmcard Manual (p.8-10). So we have a rough idea what’s going to be expected:

The DBus is daisy-chained through all Farmcards on the slots as well as on the edge-connectors J9 & J10 (in/out). Because I hadn’t had an original Farmcard at hand I wasn’t sure which of these signals are needed to be controlled by the CPLD. So I connected them all using all available I/O ports.  This is the pinout:

pin function
04 5_ANA
05 1_RES
06 1_ANA
08 LED1 (Error)
09 L_IN
11 L_OUT
12 FAST_IN
14 FAST_OUT
16 SLOW_IN
17 SLOW_OUT
18 GLOBAL_RESET_IN
19 GLOBAL_RESET_OUT
20 T_ERR_IN
21 T_ERR_OUT
24 LED2 (Opt)
25 4_ANA
26 4_RES
27 2_ANA
28 2_RES
29 3_ANA
31 3_RES
33 7_ANA
34 7_RES
36 6_ANA
37 6_RES
39 0_ANA
40 0_RES
41 5_RES

So, this is it for now… it’s an ongoing project and it depends on you how fast progress will be made.

  • Do you own an ATW800? We’re looking for brave testers!
  • Are you a VHDL hero? Grab the manual and do your thing!
  • Transputer nut? Feel free to check the schematic… I’m not swearing it’s 100% bug-free.

To be continued…

Blog

Atari, my love.

3 Comments

This blog post is due to the fact I was just reanimating my Atari 2080ST, which triggered lots of memories I urgently needed to write down… so here we go:
Yes, the 1st proper (i.e. not soldered) computer I owned was a C64… I loved it, really. I loved it for 3 years… and seriously dreamt about getting an C128D – until I’ve read the fist reports about that Atari 260ST.

I was hooked just by the specs on paper. For me it looked like a Macintosh but with a realistic chance to own one some fine day.
Actually there was a day in the beginning of 1985 when I sat with Heinrich-Hermann Huth, (one of the founders of later Application System Heidelberg, ASH for short) discussing what’s the best upcoming computer. He was 100% Commodore 128… until I started my Atari ST anthem.
Around June or July, he invited me to his parents house to “show me something exciting”. There it was, one of the first STs in Germany, serial number 6, directly picked-up at Frankfurt airport. TOS came on an awesome 3.5″ floppy, the included Basic was slow as hell and the the Digital Research SDK left me puzzled. C? Compiler? Linker?
It became clear that I have to learn a lot to be worthy for such a serious system.
Looking back I wonder if ASH would ever been founded without my evangelism 😉

So in early 1986 it was my turn: My Confirmation. This is a big deal over here and the most “profitable” observance. While the standard wish of kids in these days were big stereos, mine was clear.
Thanks to perfect timing, the 520ST just became 520ST+ and now had a whopping megabyte… it was heaven.

The glory of the 80s… bad jumpers and paper 3D-glasses.The right half shows the C64 moved into a far corner before it was sold to buy a 2nd floppy for my ST.

Just about that time, Application Systems Heidelberg was founded… in the child’s room of Heinrich-Herrmann, who somehow managed to get the exclusive distribution rights of Megamax C for Germany.
This proved to be a lucky pick, because the ST was taking the German market by storm and there was no good SDK available. So magazine ads were needed and I was the only one who had a design talent. This was my first design made with my brand new 520+:

The company logo was cut out and glued onto the b/w print which came out of a 9-needle-printer.

Mind the small pencil in the lower left corner. In German, that’s a “Stift”, which is also slang for “apprentice” – which was me 😆
There’s even an article about this ad in the german ST-Computer magazine over here (pg. 7/8).  Quote:

Doch selbst der Software­Gigant aus Heidelberg fing klein an: Auf einer Viertelseite bewarb die Firma in der Ausgabe 07­08/1986 das Megamax C­ Entwicklungssystem, gestaltet wurde die Anzeige mit der Systemschrift und den Füllmustern des STs.

Which translates into “Even the software giant from Heidelberg started out small: In issue 07-08/1986 the company advertised the Megamax-C SDK  on a quarter-page, designed using system fonts and the fill-patterns of the ST“.
Yeah, that’s all true. And “The Stift” was payed for this and other ads by being allowed to keep the glorious Citizen MSP-20 9-needle printer.

In the following years I spend my time mostly in 3 places: In school because I had to, at home in front of my Atari ST or in the ASH office because it was just so cool. During these days I did many thing for them:

  • Packed so many, many, many Megamax, Signum! and STAD boxes, labeled 100s of floppy-disks (was payed in M&M currency)
  • Some levels for Oxyd, Bolo and Esprit.
  • Some Signum! Fonts (forgot which ones, but they were in the 1st 251-Fonts book)
  • Phoenix Ornitho Database (containing samples of each bird singing)
  • The cartoon on the last page of their in-house magazine. Was quite a fancy oversized, glossy thing.
  • Probably 10 other things I forgot…

Icons and Infobox for Script v1

…and Scarabus.

Boy – this was definitely one of the top-5 times of my life. Thanks for this H3, Volker, Ojo (always in my heart), Karen (my heart ;)), Oili, Thomas and all the other great guys’n’gals from back then! Love y’all!

Atari, Hardware, Systems

Atari 2080STF – a prototype?

2 Comments

I bought this Atari 2080STF in 2003 and stored it as-is in my collection. The ST being my first 16bit machine I thought it could be a good point in time to un-dust and resurrect it 16 years later.

Atari 2080STF… 2080??  Yes, that’s true. There are different stories out there about their prototype/fake status.
As far as I see, there are two 2080STF versions out there:

  • The “Yugoslavian Version”
  • My Prototype

The Yugoslavian 2080STF is a pretty simple re-batching of a 1040ST which was upped to 2MB RAM and sold by a company called Mladinska Knjiga.

My 2080STF is different. In contrast to the Yugoslavian it features a proper, 3d embossed label, not some flat DIY thing.
Instead of some serial# printing looking like made with a children-stamping kit it says this:

MarkeTTing Sample… should it have been an omen?

Marketting? Well… somebody’s been in a hurry or not native to English. Anyhow, the label shows the same quality as those used with Ataris produced in greater numbers. That said, there’s no serial number and the model ist just a paper-sticker.

Next unique thing is the floppy cut-out on the right side. It’s the same square one like on a Falcon, but the plastics are in the proper ST grey. Mhhhh….

Looks Falcon’ish, but it isn’t…

Finally the mainboard: Yes, it’s very 1040STFM without the M(odulator) part. But then it features a yet undocumented issue number of C100059, production week 8813. And mind the installed Blitter at the lower right.

Lots of ugly mods to be removed ASAP! But I’ll keep that IDE controller sitting on top of the 68k.

So what do we got here? Not having any matching-numbers system like in the vintage car world, we can only guess…
It might be a real “Marketing Sample” made for a planned pimp-up of the 1040 family. On the other hand it also can be a nicely composed Frankenstein system made of parts e.g. being sold at Ataris sell-out in 1995.
Given the sum of the unique parts being used, I opt for the “real marketing sample”, probably being put together using available parts and meant for checking out, if there’s a demand/market for such model(s)… and history taught us that there wasn’t.

Anyhow, I pulled out the crap which had been “installed” over the previous years…

Boy, look at that IDE “cable adaptor”… a soldering nightmare. And who needs more than 19200 baud anyhow?

So the noisy 2.5″ 80MB harddrive got replaced by a CF-Card which nicely fits where the modulator would be, if this would be a STFM.
Additionally I 3D-printed a mounting thing for it which you can download here.
Finally, the build-in Hard & Software TOS-Card II 2.06 (that’s a long product name!) got fixed so it actually can switch between the on-board TOS and the 2.06 sitting on the card.

When everything’s done, it looks nice and tidy down there:

Yeah, that’s a 4MB card… just for testing. I took a “spliced” IDE cable I made ages ago – does a good job to squeeze underneath the keyboard.

So I think I’m all set for some pure 8MHz 68000 fun… oh boy, did I love those days.