Re: What Tektronix means to me


Michael A. Terrell
 

I repaired Commodore computers from the PET era, to the 128 at the
component level. MOst failures were bad RAM. Some brands were always bad,
while others were rare. The 4164? chips were in short supply, so they used
whatever they could get. I wrote a decompiler in Commodore basic to look at
the ROM based DOS of their 1581, 3.5" floppy drives that wrote the output
to a blank in the drive. Club members made fun of it, but the commercial
software they had would hang after about 5%.

The Exorcisor based computers were built and sold to the Cable TV industry.
The pair of computers, and one 8" floppy subsystem cost us over $60,000 in
1980. Then they went out of business in 1983.

I still have a couple Intel Multibus computers that I've never fired up.
They came from an auction at the old Orlando Naval Training Center.

I have worked with VME/VXI and PC104 based systems. Microdyne used the
MC68340 for several embedded controllers in their later Analog products.
They used 6803 and some others in early products. I troubleshot the MC68340
boards at the factory, without a logic analyzer. I couldnt even get a JTAG
interface because only engineers were allowed to use that. They insisted
that only the commercial units would work, and the simple one in the
databook would destroy to processor. Not a lot f fun, but it gave me more
skills to repair poorly documented test equipment. :)

On Mon, Jan 20, 2020 at 8:06 PM Harvey White <madyn@...> wrote:

comments interleaved:

On 1/20/2020 7:50 PM, Michael A. Terrell wrote:
Did you ever use the 6510 processor? It was a 6502 with an
onboard I?O port that was made foe the Commodore 64.
By the time the commodore 64 came out, I had either almost stopped my
own designs or I had used Apple ][ clone boards from Japan. I had, in a
way, more software than could had in some versions of the commercial
systems (and in some cases, far less).

I had a console run inverse assembler, that took the 6502's assembler
and ran it backwards to produce the opcode from the mnemonic. The
operating system had a system call table so that the user programs could
be complied with just the table, and the program would still work.
Didn't have to assemble it with a specific version of the OS. It ran
Tiny Forth, and also had (at one time) a tape (paper tape) reader, since
I could get that at work. If I wanted to upgrade the OS, well, still
needed to program Proms.

Story about someone who was building a system. The nomenclature 27xx
where the xx showed the size in K bits was common for the proms.

He said, "well, I could use 2716's, but they're really small and I
really want to use something bigger. I'll wait until I can get some
2732's."

A year later, or so, I asked him how his system was working... He said.
"Well, I was going to use 2732's, but I really like the 2764s, and
they're going to be available in about 3 months....."

Not sure what he ever built....



There were several
undocumented opcodes thet were different on different production runs.
Some commercial software would only run on a specific group, so I fad to
keep as many different runs on hand, as possible to get someone's sytem
back up and running.
Nope, ran into a similar problem with generations of the 6502 from
ground zero....


Also: Did any of you work with Motorola's 6800 based
Exorcisor bus? I had to maintain a pair of six NTSC output character
generators built with those boards. Each video output had its own card,
but
each computer only had 32KB of RAM.
I pretty much was in the camp of having to build my own boards, so I did
what I could from essentially bare metal. Never (other than Apple ][
boards) used anyone else's design.


Harvey



On Mon, Jan 20, 2020 at 1:21 PM Harvey White <madyn@...>
wrote:

I (very early on) tried to build a Tektronix calculator out of TTL,
jumps, program flow, and then an FPU.

Got the jumps and program flow working, you could do an indirect jump
through a location in hardware (and yes, this was very early....)

I built an 8 trace scope switch to be able to look at digital traces on
my 513D (I got lucky getting the 513D, P11 phosphor).

Simple enough, sync a counter to the sweep trigger output, take the
counter, run it to a multiplexer and weight the multiplexer output as
'1' in a very crude D/A.

Take the appropriate counter outputs and weight them 2, 4 and 8.

Instant 8 traces on a 1 channel scope, for 5 volt TTL, of course.

Then along came the 6502, for 30 dollars, one each (while the 8080 was
still 100 dollars or so). I looked at my 130 chip wirewrapped design
(still not done), and felt a bit bad.......

I bought two (and literally, drove to the MOS technology factory to pick
them up with the original books). Still have them, I think.

There were some bugs in the microcode, some things not implemented, and
I seem to remember being bitten by that once I got the "newer"
processors.

Naturally, the whole thing was in assembly language. Program the thing
at work (someone tweaked the DG macro assembler), program the UVPROMS,
take it home and single step (hardware) through the program.

Everything was wirewrap then. Just everything.

Harvey


On 1/20/2020 9:39 AM, Chuck Harris wrote:
Many of us early adopters to microprocessors got bit by
the discovery that not all of the 8080's made were truly
compatible.

Everyone knows that Intel developed the 8080, but some might
not remember that the Japanese company NEC, almost immediately
introduced a cheaper, unauthorized, second source to the 8080...
only theirs was partly done from Intel's design, and partly
done on their own.

Some of the subtle differences were in the settings of flags
after some arithmetic operations, and in the numbers of clock
cycles used by some common instructions.

I discovered the flag problem, when I found some code that
should have branched, only it didn't... NEC fixed a mistake in
the Intel microcode.

I discovered the clock cycle problem when I was writing a music
program, that played on a transistor radio... using timing loops.

I meticulously counted cycles, ala the Intel data book, but
several notes were coming out sharp.

It turns out that Intel used 5 cycles for one instruction, and
NEC found a way to do it in 4 cycles...

And, I had stacks of these instructions, inside of loops that
timed the note pitch.

-Chuck Harris

Dave Seiter wrote:
Grin! Things were different back then. In high school we had dial
up line to a HP2000 at the Stanford business school using DECWriters,
and
one could wander through the directories, browsing students projects. It
was usually very responsive, but sometimes it would really bog down, and
we'd have to use one of the in-class micros (PET/APPLEII/TRS80) to work
on
our projects. But they were all more reliable than our PDP8/E; we had
to
use that for Fortran, and it was always breaking down. I think I was
one
of the last people to learn how to use a keypunch machine!
-Dave




Join TekScopes@groups.io to automatically receive all group messages.