There aren’t many of these left, and according to the news on Mike’s blog, we might not see another production run of these kits.

Permission has been received from The Byte Works to release the six chapters that were completed, along with the corresponding code samples, as freeware. They’re now available from the Syndicomm web site.

The following message came from the BrainSystems team this morning:

We are pleased to announce that the GSBarndoor team has been hard at work and is moving right along on the GSBarndoor accelerator project. Within the next two months, we will be contacting certain individuals within the Apple II community that have the technical expertise to Beta test our progress thus far. Stay tuned and be sure to check your email boxes, as it could be you. For more information on the project, check out http://www.gsbarndoor.com

We checked the site and aside from the update we’ve reposted here, there isn’t anything obviously new — no information or pictures yet from the secretive, Wonka-esque development team.

The Original Time Master ][ Revealed at KFest 2010

KansasFest 2011 - You've got ][ Be there! - 19-24, July - 2011 - Rockhurst University, Kansas City.

The Datanetics keyboard was the most common keyboard used with an Apple 1. You can see several of them in photos of original Apple 1. I am working on a reproduction Datanetics PCB.

There were several versions of the Datanetics keyboard. In fact early Apple II keyboards were made by Datanetics and have basically the same design as the Datanetics keyboard. The version of the original Datanetics keyboard that I am working on is the Rev B.

This board has no solder mask or silkscreen, so it looks rather primitive. Parts are extremely hard to find, especially the MM5740/AAE keyboard encoder. Keyswitches are also nearly impossible to find, except by parting out early Apple II Plus keyboards. Keycaps are another problem, though the Apple II plus keyboards used similar keycaps. Because of this parts problem, I am planning on building only 1 batch of probably 10-20 PCBs. My current plan is to sell only bare PCBs, and the purchaser will have to deal with finding components.

If you are interested in obtaining one of these bare PCBs, let me know, The artwork for the PCB is nearly done, so I may be pulling the trigger on this batch fairly soon. What I can’t sell right away, I might possibly try moving on ebay. At this time, I’m thinking of a price of around $75 to $100 for one of these bare PCBs. This is subject to change.

A couple of things about this PCB:

1) there is an error on the original PCB, that requires a couple of cuts and a jumper. I’m leaving this error in my reproduction.

2) The matrix of vias in the upper left corner of the PCB should not have plated through holes. Plating some holes and not others results in a special order that costs extra time and money. In order to save money, I have decided to have the holes made plated and also drilled smaller than the original. In order to make this board work, the plating will need to be drilled out of these holes.

Speaking of components, the stiffeners are kind of a unique problem for me, because I haven’t had to deal with sheet metal fabrication, since junior high school. If one of you has experience with sheet metal fabrication, let me know — we can possibly work out some kind of special deal for you.

A picture of an original Rev B and some information about it, including schematics and the dimensions of the stiffeners can be seen on the datanetics keyboard page on my website.

http://www.willegal.net/appleii/apple1-datanetics.htm

If you are interesting in this project let me know, so I can build the right number of boards to suit demand.

Regards,
Mike Willegal

EDIT: we blinked, and suddenly AppleWin 1.19.0 was available.

You can download the source code for this program.

Comments

Before we do anything else, let’s take a moment to talk about comments. Comments are text in your source code that are human-readable, intended to help you remember what your code is doing (and so others can read your code more easily).

There are two formats for comments. Comments starting with a semicolon (”;”) can be placed stand-alone on a line of code, or can be at the end of any line of code. Comments starting with an asterisk (”*”) can only be placed on a line by themselves. In both cases, the comment extends from the character that starts the comment to the end of the line.

We’ve been using these already, but it just occurred to me that I haven’t actually talked about them yet, so there you go.

Our First Subroutine

Let’s start by creating our first subroutine. This simple routine just takes the value in the X register and prints it to the screen, followed by a carriage return. We’ve used the PRBYTE and CROUT firmware routines in the past, so we won’t dwell on them.

Let’s look at the code:

*
* xcr
*
* Prints the byte in X then a carriage return.
*
xcr      start
         txa                            ;Copy X to A
         jsr   PRBYTE                   ;Print the byte in A
         jsr   CROUT                    ;Print CR
         rts                            ;Return to caller
         end

The first thing this code does is use the implied mode instruction TXA (Transfer X register to Accumulator) to copy the value in the X register into (believe it or not) the accumulator. We do this because the PRBYTE firmware routine prints the value in the accumulator, but we want to use the X register in this case.

Then we call CROUT to output a carriage return, and use RTS to return to the caller.

Incrementing and Decrementing

A very common operation is the need to add or subtract one from a number. For this reason, the 6502 has special instructions just for that purpose. This time, we’re going to look specifically at incrementing and decrementing the index registers.

The INX (INcrement X register) and INY (INcrement Y register) instructions add one to the value of the respective registers. Similarly, DEX (DEcrement X register) and DEY (DEcrement Y register) subtract one from these registers.

Let’s take a look at a code sample:

* Demo increment and decrement

         ldx   #$00                     ;Start with zero
         jsr   xcr                      ;Print it
         inx                            ;Increment X
         jsr   xcr                      ;Print it
         dex                            ;Decrement X
         jsr   xcr                      ;Print it
         dex                            ;Oooh, now what?
         jsr   xcr                      ;Print that

We start by setting the X register to zero and calling our xcr routine to print that value to the screen.

Then we increment X and print the resulting value (in this case, $01).

Then we decrement X and print the result again (this time, $00).

Now, let’s see what happens when you decrement the X register again. The result is $FF (255). That’s right, they wrap around. if you then incremented X again, the result would wrap back to $00.

This is called carry, and it’s similar to what you do when you’re doing addition and subtraction by hand. You have to carry the result from one column to the next when adding or subtracting by hand; similarly, when doing math byte by byte, you have to carry the result from one byte to the next.

We’ll be looking in more detail as to how the carry bit works and how to perform multi-byte mathematics later.

Next Time

Next time, we’re going to apply this knowledge about incrementing and decrementing values to build our first loop to repeat an operation several times until the desired result is achieved.