Unveiling the Inner Workings of Early Computers: A Deep Dive into the Commodore PET

The Foundations of Computing: Exploring the Commodore PET

In today's world of advanced computing, it's easy to take for granted the intricate technologies that power our devices. Modern computers are so complex that understanding their inner workings in detail is a daunting task. However, by examining earlier, simpler machines, we can gain valuable insights into the fundamental principles of computing. This article takes an in-depth look at the Commodore PET (Personal Electronic Transactor), one of the pioneering personal computers of the late 1970s.

The Commodore PET: A Window into Early Computing

The Commodore PET, introduced in 1977, was one of the first all-in-one personal computers. Its relatively simple architecture makes it an ideal subject for understanding basic computer operations. By exploring the PET, we can learn about:

• Memory management and mapping
• CPU operations
• Video display technology
• Keyboard scanning
• Basic input/output operations

Let's dive into these aspects and uncover the inner workings of this classic machine.

The PET's Hardware Architecture

Motherboard Layout

The PET's motherboard layout provides a visual representation of its components and their relationships. The board is organized in a way that mirrors the system's memory map:

• At the bottom: System RAM
• Above RAM: Screen RAM
• To the side: Character generator ROM (not visible to the system bus)
• Above screen RAM: System ROM chips
• Near the top: CPU and I/O chips

This physical layout helps us understand how the different components interact and how data flows through the system.

Memory Map

The PET's memory map is crucial for understanding how the system organizes and accesses different types of memory:

• 0000-0FFF: System RAM (4K in the original configuration)
• 8000-83E7: Screen RAM (1000 bytes)
• 9000-BFFF: Expansion ROM sockets
• C000-DFFF: Microsoft BASIC ROMs
• E000-FFFF: KERNAL ROM and I/O chip registers

This memory layout determines how programs and data are stored and accessed by the system.

The Heart of the System: The 6502 CPU

The Commodore PET is built around the MOS Technology 6502 microprocessor. This 8-bit CPU was popular in many early personal computers and game consoles due to its relatively low cost and good performance.

Boot Sequence

When the PET is powered on, the 6502 CPU follows a specific boot sequence:

1. The CPU loads the address stored at memory locations FFFC-FFFD.
2. This address points to the 'start' label in the KERNAL ROM.
3. The startup code initializes the stack pointer, disables interrupts, turns off decimal math mode, and initializes I/O.
4. Control is then handed off to the screen editor and BASIC interpreter.

This sequence ensures that the system starts up in a known state and is ready for user input.

Memory Types: Static vs Dynamic RAM

The PET uses static RAM (SRAM) instead of dynamic RAM (DRAM). This choice has several implications:

Static RAM (SRAM)

• Holds its contents as long as power is supplied
• Does not require refresh circuitry
• More expensive than DRAM
• Used in the PET due to its simplicity and the small amount of memory required

Dynamic RAM (DRAM)

• Requires constant refreshing to maintain data
• Needs additional circuitry for refresh operations
• Less expensive than SRAM
• Used in later computers like the Commodore 64

The choice of SRAM in the PET simplified the design but increased the cost per byte of memory.

Video Display Technology

The PET's video system is a prime example of elegant simplicity in early computer design. Unlike modern computers with dedicated graphics processors, the PET uses a clever combination of ROM and simple circuitry to generate its display.

Character Generator ROM

At the heart of the PET's video system is the character generator ROM. This ROM contains bitmap definitions for each character the PET can display. Each character is defined as an 8x8 grid of pixels.

Screen Memory

The PET has a dedicated 1000 bytes of screen memory, separate from the main system RAM. This memory holds the character codes for each position on the 40x25 character display.

Display Generation Process

1. The video circuit reads a byte from screen memory.
2. This byte is used as an index into the character generator ROM.
3. The corresponding 8-byte character definition is fetched from the ROM.
4. These 8 bytes are used to control the electron beam, turning it on or off for each pixel.
5. This process repeats for each character position on the screen.

The result is a 320x200 pixel monochrome display, capable of showing 40 columns and 25 rows of text or simple graphics.

Limitations and Potential Improvements

One notable limitation of the PET's video system is the fixed character ROM. Unlike later computers like the Commodore 64, the PET does not allow for custom character definitions. This restricts its graphics capabilities, particularly for gaming applications.

A potential improvement would have been to allow the video circuit to read character definitions from RAM instead of ROM. This would have enabled custom character sets and more flexible graphics, at the cost of some additional circuitry.

Keyboard Scanning and Input

The PET's keyboard interface is another example of efficient design in early computers. Instead of dedicating an I/O line to each key, which would be impractical, the PET uses a matrix scanning technique.

Keyboard Matrix

The keyboard is wired as a matrix of rows and columns. When a key is pressed, it connects a specific row with a specific column.

Scanning Process

1. The system uses a Peripheral Interface Adapter (PIA) chip to control the keyboard scanning.
2. The ROM code cycles through rows 1 to 10 of the keyboard matrix.
3. For each row, a binary number is sent to a decoder chip, which activates one of 10 lines.
4. If a key is pressed, it will connect the active row to one of the column lines.
5. The system detects which column is active and can thus determine exactly which key was pressed.

Key Code Processing

Once a key press is detected:

1. The corresponding character code is determined.
2. This code is stored in screen memory at the current cursor position.
3. The cursor position is updated, typically moving one space to the right.

This process allows for efficient keyboard input with minimal hardware requirements.

The KERNAL: Commodore's Operating System

The KERNAL (Keyboard Entry Read, Network, And Link) is Commodore's name for the core operating system routines stored in ROM. It provides essential functions for system operation and acts as an interface between the hardware and higher-level software.

Key KERNAL Functions

• System initialization
• Input/output operations
• Memory management
• Time keeping
• Interrupt handling

KERNAL API

The KERNAL provides a set of standardized entry points for common system functions. This allows application software (including BASIC) to interact with the hardware without needing to know the specific details of the underlying system.

For example, to output a character to the screen, a program can call the KERNAL routine at $FFD2, regardless of the specific hardware configuration.

BASIC Interpreter and ROM

The PET comes with Microsoft BASIC built into ROM. This BASIC interpreter provides a user-friendly programming environment and includes several key components:

Tokenizing BASIC Interpreter

The BASIC interpreter tokenizes input lines, converting BASIC keywords into single-byte tokens. This process saves memory and speeds up program execution.

Floating Point Math Library

The BASIC ROM includes an optimized floating-point math library. This library provides essential mathematical operations for BASIC programs.

Example: Adding Two Numbers in Assembly

Here's a brief example of how to use the BASIC ROM's math routines to add two 16-bit numbers:

1. Load the first number into the Floating Point Accumulator (FAC1):

   • Put the least significant byte in the Y register
   • Put the most significant byte in the A register
   • Call the INTFP routine

2. Move the value from FAC1 to FAC2 using the FAC12 routine

3. Load the second number into FAC1 as in step 1

4. Call the ADD routine to add FAC1 and FAC2, with the result in FAC1

5. Use the FPOUT routine to print the result to the console

This example demonstrates how assembly language programs can leverage the built-in math routines for efficient numerical operations.

The Screen Editor: A Unique Approach to Input

The PET's screen editor, provided by Commodore, was innovative for its time. Unlike many contemporary systems that only allowed input on a single line, the PET's approach was more flexible and user-friendly.

Key Features of the Screen Editor

• Full-screen editing: Users could type anywhere on the screen.
• Cursor movement: The cursor keys allowed navigation to any part of the screen.
• Line execution: Pressing Enter would execute the line the cursor was on, regardless of its position on the screen.
• Easy editing: Users could move the cursor to modify existing lines without retyping them entirely.

How It Works

1. When the READY prompt appears, the cursor is placed directly below it.
2. Users can type anywhere on the screen or use cursor keys to move to a different location.
3. Pressing Enter causes the system to process the entire line the cursor is on.
4. For BASIC programming, if the line starts with a number, it's treated as a program line and stored or replaced in memory.
5. If the line doesn't start with a number, it's executed immediately as a direct command.

This system allowed for a more intuitive and efficient programming experience, especially for beginners.

Input/Output System

The PET uses a device-based I/O system, which became standard across Commodore's 8-bit computers. This system uses device numbers and secondary addresses to control various I/O operations.

Device Numbers

• 0: Keyboard
• 1: Cassette #1
• 2: Cassette #2
• 3: Keyboard (again, as an input device)
• 4-7: Printer
• 8-15: Disk drives

Secondary Addresses

Secondary addresses provide additional control over devices. For example, with cassette devices, different secondary addresses might control read, write, or verify operations.

KERNAL I/O Routines

The KERNAL provides several key routines for I/O operations:

• OPEN: Opens a logical file
• CLOSE: Closes a logical file
• CHKIN: Defines an input channel
• CHKOUT: Defines an output channel
• GETIN: Gets a character from the input channel
• CHROUT: Outputs a character to the output channel

These routines abstract the details of device communication, making it easier for programmers to work with different I/O devices consistently.

Expansion Capabilities

Despite its all-in-one design, the PET was built with expansion in mind. It included several features to allow for system upgrades and additional functionality.

Expansion ROM Sockets

The PET motherboard includes empty ROM sockets at addresses 9000-BFFF. These could be used for:

• Additional BASIC commands
• Machine language utilities
• Custom applications

However, a limitation of this system was that most expansion ROMs competed for the same address space, as 6502 code is not easily relocatable.

Memory Expansion

The PET could be upgraded from its initial 4K of RAM to a maximum of 32K. This expansion significantly increased the capabilities of the machine, especially for more complex BASIC programs or machine language applications.

IEEE-488 Interface

The PET included an IEEE-488 interface, which was used primarily for connecting to Commodore disk drives. This interface, while not common in home computers, provided a robust and relatively fast method of connecting peripherals.

User Port

The VIA (Versatile Interface Adapter) chip provided a user port with 8 GPIO (General Purpose Input/Output) lines. This port could be used for various purposes:

• Connecting to microcontrollers
• Implementing RS-232C serial communication
• Custom hardware projects

The user port provided a way for more advanced users to extend the PET's capabilities with custom hardware.

Legacy and Impact

The Commodore PET, while not as commercially successful as later Commodore models like the VIC-20 or Commodore 64, played a crucial role in the early personal computer market.

Educational Impact

The PET was widely adopted in schools, particularly in Canada and the United Kingdom. Its all-in-one design and built-in BASIC interpreter made it an ideal platform for teaching computer literacy and programming.

Business Use

The PET also found use in small businesses, thanks to its robust construction and the availability of business software. Its ability to connect to printers and disk drives made it suitable for tasks like word processing and accounting.

Technological Foundation

Many of the design principles and technologies used in the PET laid the groundwork for later Commodore computers:

• The KERNAL concept was refined and expanded in later models.
• The BASIC interpreter evolved into more advanced versions.
• The I/O system with device numbers became a standard across Commodore's 8-bit line.

Inspiration for Hobbyists and Developers

The relatively simple and well-documented nature of the PET made it an excellent platform for hobbyists and aspiring developers. Many programmers got their start exploring the PET's capabilities, learning valuable skills that would serve them well as the computer industry expanded.

Conclusion

The Commodore PET represents a fascinating snapshot of early personal computer technology. Its design choices, from the use of static RAM to the innovative screen editor, reflect the challenges and opportunities of its era.

By examining the PET in detail, we gain insights into fundamental computing concepts that remain relevant today:

• Memory management and addressing
• Input/output systems
• Video display technology
• Operating system design
• User interface considerations

While modern computers are vastly more powerful and complex, many of the basic principles exemplified by the PET still underpin current systems. Understanding these foundations can provide valuable context for anyone working with or studying computer technology.

The PET's legacy extends beyond its technical specifications. It played a crucial role in introducing personal computing to schools and businesses, helping to spark the digital revolution that continues to shape our world.

As we look back on machines like the Commodore PET, we're reminded of how far computing technology has come in a relatively short time. Yet, we also see that many of the fundamental challenges of computer design – balancing performance, cost, and usability – remain as relevant today as they were in the late 1970s.

The story of the Commodore PET is more than just a history lesson; it's a testament to the ingenuity of early computer designers and a reminder of the rapid pace of technological progress. By understanding where we've come from, we're better equipped to appreciate and shape the future of computing technology.

Article created from: https://youtu.be/9MKWegSQakM?si=p924SIq1aBw3ifwM