KIM-1 vs Apple II

[Will Senn]

Hi All,

I've been off doing a bunch of other things for a while, but now I'm
looping back around on all things 6502. I rebranded my youtube channel
to focus on retro/classic exploration as bit by bit - trekking through
the tech wilderness:

https://www.youtube.com/@decuser

and I started a playlist/course on Assembly language for the Apple IIe
following Assembly Lines: The Complete Book by Roger Wagner and Chris
Torrence:

https://www.youtube.com/playlist?list=PL_z8XUfqFSXHvJ5E5r80ZmMN7LRcCI0Zx

Which is all well and good, and tons of fun, but I feel the urge to work
with real hardware and not just an emulator. At the same time, I've
owned a iie in the not too distant past and it's klunky, noisy, and
takes up way too much room. So, I've been knocking around trying to find
a more compact 6502 platform that's somewhat modern (sound familiar?). I
found the Olimex neo6502 and it looks cool, but then I got to thinking,
isn't there another 6502 that fits on the desktop? Yup, the PAL-1. But
I'm not so sure about how to work with it efficiently...

With the apple ii emulators, you fire them up, point them at whatever
disk image you like, run integer/ fp basic, call up wozmon, the
mini-assembler, even Merlin, and you can do all kinds of things quickly
and directly.... beep the buzzer, draw graphics, display charsets, save
to disk, etc. Surely, the PAL-1 could do some of that, even if not all
of it, is what I'm thinking. I remember doing machine code on the
keypad, doing machine code over serial, being able to cross compile to
it, but now that I'm way more comfortable with assembly language and the
6502 from my messing around on the emulated iie, I'm wondering what I
can do with my PAL-1 and it's accessories (ROM, RAM, etc).

The Apple iie has quite a few rom routines (home, cout, etc) that are
accessible via machine code - does the PAL-1 have a similarly functional
rom? Is there a PAL-1 (KIM-1) assembler/editor or is cross assembly from
the host, the best approach for writing assembly language for the
system. Oh, and is there monitor (as in hdmi/vga/etc) support for the PAL-1?


Later,

Will

[Hans Otten]

A KIM-1 and an Apple II are not  the same at all. So it depends on what you want to do with such a system.

Where the Apple II is a real home computer with keyboard and  video display and, with floppy drives, a real operating system, the KIM-1/PAL-1/PAL-2 is a very basic Single Board Computer with a primitive monitor program.

Now transforming a KIM-1 into a real computer can be done. Attach a floppy drive (or SD card, several options available) and with the Eduardo Casino RAM/ROM/Video card even video and a real operating system.

There is quite a lot of KIM-1 software, I have pages full of it on my website. 

If you are planning to do hardware experiments, the PAL-1 with its accessories is well suited for that. Combined with cross compilation,  lots of fun. 

[Will Senn]

Right, I don't expect the KIM-1 to act like an Apple II :). What I meant was more along the other line - experimentation and assembly coding... back in the day, did folks run an editor/assembler over serial or did they compile on a host and feed the bytes to the machine over serial? I don't have the time or interest to enter complex programs byte by byte, although I do enjoy doing that to learn the instructions and how they work, and I'm not looking to just run programs that others have written. I'm looking to explore how it was done back when. I don't mind moving up to modern era on the editing/coding side of things and targeting the machine. But, if they used to fire up an editor, edit assembly, assemble, and run/debug it on the kim itself, I'd like to start there, at least.

Also, I saw a ROM mention, so I gather there's a listing and ability to call into it from programs, yes?

Thanks,

Will

[Ronny Ribeiro]

"I have pages full of it on my website" is the answer you're looking for, Will 😂

Happy reading 6502, as Liu would say 😂

Ronny

--
You received this message because you are subscribed to the Google Groups "PAL 6502 computer" group.
To unsubscribe from this group and stop receiving emails from it, send an email to pal6502+u...@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/pal6502/535aa88b-4557-47e9-8104-f0db347f404en%40googlegroups.com.

[Neil Andretti]

Start here please:

http://retro.hansotten.nl/uploads/files/First%20Book%20of%20KIM%20Hayden.pdf

And here are some ROM routines (taken from Jeff Tranters cheat sheet http://retro.hansotten.nl/uploads/files/KIM-1QuickReference.pdf )

DUMPT $1800 Write (Dump) to audio tape.

LOADT $1873 Read (Load) from audio tape.

ONE $199E Send 3700 Hz tone to tape.

ZRO $19C4 Send 200 Hz tone to tape.

PLLCAL $1A6B Send 300 Hz PLL reference tone to tape.

AK $1EFE Check for key depressed. A non-zero: no key down. A equal 0, key down.

SCAND $1F19 Display address and contents.

SCANDS $1F1F Output six hex characters on display. Stored in $00F9, $00FA, $00FB.

KEYIN $1F40 Open up keyboard channel. Call before using GETKEY (or call SCANDS).

INCPT $1F63 Increment display address.

GETKEY $1F6A Return key from keyboard. Value 0-F, 10(AD), 11(DA), 12(+), 13(GO), 14(PC), 15 (no keypress).

TABLE $1FE7 Table of 7-segment patterns.

$1C2A Set TTY baud rate.

PRTPNT $1E1E Prints contents of $00FB, $00FA on TTY.

CRLF $1E2F Send CRLF to TTY.

PRTBYT $1E3B Prints A as two hex characters on TTY.

GETCH $1E5A Get one ASCII character from TTY and return in A.

OUTSP $1E9E Print space on TTY.

OUTCH $1EA0 Print ASCII character in A on TTY.

GETBYT $1F9D Get two hex characters from TTY and return them packed in A.

SAVE $1C00 Normal interrupt entry point.

RST $1C22 Reset return to monitor.

START $1C4F Return to monitor entry.

But please read the First Book of KIM forst

[Jim McClanahan]

My experience is from around 1980 and with the OSI C1P as my first computer. For tinkering, most people hand assembled stuff and entered it by hand. The editor/assembler was typically something you had to buy. (There were free ones around, but they usually weren't that well documented and were tweaked to however the person writing it wanted to do stuff.) There were no hosts--you were lucky to own a computer and typically that one computer was the most powerful one you had. Some had old teletypes, but by 1980 most of those were out of use and the days of paper tape were ending. (There were exceptions, but keeping a TTY running was a time consuming and expensive proposition.)

You typically saved things off on cassette tape unless you were able to afford a disk drive. By around 1980, disk drives for hobbies t level systems was reasonable. My second computer in 1981 was a C4P-MF. OS-65D came with an editor/assembler that I used some. (Memory was also an issue. Typically your assembly source code was stored similar to how BASIC worked--as numbered lines just above the editor/assembler. The assembler might take a program meant to run at $0400 but put the object code up at $1000 because the editor assembler was setting at $0300 and had a few kilobytes of source code above it. Then you'd either save off the contents at $1000 and reload them down at $0400 or you'd use some kind of simple relocator to move them where they were supposed to be and overwrite the editor assembler in the process. So debugging was more challenging because it usually mean 1) load the assembler, 2) load the source code, 3) edit the source code for any changes or errors, 4) move the object code the assembler created to the area it was to run from, 5) test the code, and if there were issues 6) repeat the whole process. With a cassette tape as your only storage, that could take a while. Even with disks, you had to be thinking a few steps ahead to not stumble over yourself.)

I actually view Jeff's JMON as kind of the "dream" development system for tinkering with assembly. That is why I used it to build PBUG, PBUG has, to me, a similar feel to machine code development in 1980 but with some things that make life easier.

Probably the most complex program I hand assembled was a "brick out" type program for the C1P. I think it was something like 1K. With an editor assembler running under CP/M, I wrote a real-time system to make a low cost Z80 board act as a simple, low cost SCADA Remote Terminal Unit (RTU) and that was something close to 250 pages of printout when assembled. (And it took a while also. It has been many years, but I think it was close to an hour for things to fully assemble on Commodore 128 running CP/M. Commodore disk drives are a bit slow which was part of the issue.) Compared to all of that, putting together the stuff for the first PAL-1 ROM was a larger project, but easier because of the tools available to cross-assembler and test. (I originally used a RAM chip instead of a ROM for development, but switched to using EPROMs and just erasing and programming them as things were finalized.)

The Apple ][ with a disk drive was a nice setup. We had one when I was a senior in high school (1980/1981) and it could do a lot. But it was also expensive compared to what a kid in highschool could afford working part time and bringing home $80 or so a month. A few friends had the early TRS-80s. One friend's dad worked with computers and had a Heathkit H-8 with the H-19 terminal and the paper tap punch and reader, but he had built it around 1974 or so and it was long in the tooth by 1980 even if it was kind of cool to tinker with.

Thanks,

Jim W4JBM