Commodore CBM 8000 Series
CBM 8032  (1980)
◄ Back to Computers

Commodore CBM 8032

The CBM 8032 is an 8-bit desktop computer intended for the business market. It was developed in 1979 and production started in 1980. The computer consists of a single case which contains the monitor, motherboard, power supply and a full stroke keyboard. The back panel has connections for a floppy disk drive and cassette player. The monitor is a 12-inch, monochrome green, 80x25 CRT, controlled by a MOS 6545 CRT controller.

The computer has 32KByte of RAM and boots up into Commodore Basic V4. Sound capabilities are limited to a simple internal piezo buzzer.

The Commodore CBM/PET line of computers

The Commodore PET line began in 1977 with the PET 2001, one of the earliest all-in-one personal computers. It featured a MOS Technology 6502 CPU running at 1 MHz, with 4–8 KB of RAM (expandable to 32 KB in later revisions), and a built-in monochrome monitor and cassette drive. The machine used a character-based display with a 40×25 screen buffer mapped directly into memory, and graphics were limited to PETSCII, a modified ASCII set with block-drawing symbols. Its BASIC interpreter, written by Microsoft, was in ROM, ensuring instant-on usability. The PET 2001 established the architecture that would define the series: a 6502 processor, memory-mapped I/O, BASIC in ROM, and integrated display and keyboard.

The PET branding was used primarily in North America and early European Sales. Later the CBM (Commodore Business Machines) branding was applied more heavily in Europe, as PET had trademark conflicts with the Dutch Philips company, which used PET for a line of audio products.

Later models, such as the 3000 and 4000 series, refined this architecture. They introduced larger memory configurations, replacing the original "chiclet" keyboard with full-travel designs, and replacing the built-in cassette with external storage options. The 4000 series added an 80-column text mode in some variants, using additional video RAM and CRT controllers. While the core 6502 CPU and BASIC ROM remained consistent, the bus architecture was gradually expanded to support more RAM (up to 96 KB, though not all was directly addressable by BASIC). These systems also introduced IEEE-488 (GPIB) ports for disk drives and printers, a notable departure from the hobbyist S-100 or RS-232 setups common in other machines of the era.

The final iteration, the 8000 series (sometimes called “Big PETs”), pushed the PET architecture to its practical limits. With up to 96 KB of RAM and a full 80×25 display standard, these machines were targeted toward business and scientific use rather than hobbyists. They retained the 6502 core and Microsoft BASIC ROMs but added more advanced video circuitry and professional keyboard layouts. Despite their improvements, the PET line was eventually eclipsed by the Commodore 64 and the CBM-II series, which offered richer graphics and sound. Still, the PET series represents a coherent lineage: a consistent 6502-based core with incremental refinements in display, memory, and I/O, bridging the gap between early hobbyist machines and professional microcomputers.

Commodore CBM/PET Peripherals

The PET/CBM line was tightly coupled with a family of IEEE-488 (GPIB) peripherals, which gave these machines a more professional edge compared to contemporaries that relied on hobbyist interfaces. Commodore produced a range of disk drives, starting with the 2040 dual floppy (based on 5.25-inch drives with ~170 KB per side), followed by the improved 4040, 8050, and 8250 drives that expanded capacity up to over 1 MB per disk with double-sided, double-density mechanisms. All of these were “intelligent” peripherals, containing their own 6502 processors and DOS in ROM, so the PET simply issued high-level commands over the IEEE-488 bus. Printers were also available, such as the CBM 2022 and 3022 dot-matrix units, which were business-grade and designed to work seamlessly with PETSCII character encoding and Commodore’s control codes.

Beyond mass storage and printers, Commodore offered a number of specialized peripherals for the PET/CBM ecosystem. The 2020 and 3020 were daisy-wheel and line printers, respectively, catering to office needs. Tape drives like the C2N datasette remained supported for low-cost storage and software distribution, though serious users quickly moved to IEEE-488 disks. Plotters, like the 4016, extended the system into technical and educational applications, and even third-party IEEE-488 devices could be connected thanks to the standardized bus. This ecosystem of peripherals reflected the PET’s positioning as more than just a hobbyist computer—it was marketed as a complete business workstation, with robust, intelligent, and expandable hardware surrounding the familiar 6502-based core.

Video - The Motorola 6845 CRTC

The Motorola 6845 CRT Controller (CRTC), later second-sourced by Hitachi (HD6845), Rockwell, and others, was one of the most influential video timing chips of the late 1970s and 1980s. It was not a graphics generator in itself; instead, it produced the precise timing signals needed to drive a raster display, such as horizontal and vertical sync pulses, row and character addresses, and memory fetch cycles. Systems attached external character generators (ROMs) or pixel logic to interpret the memory data, while the 6845 ensured the scanlines appeared in the correct order and at stable refresh rates. Its programmability, registers controlling horizontal total, vertical total, sync widths, cursor position, and so forth, made it adaptable across a wide range of systems, from text terminals to microcomputers.

The 6845’s flexibility came from its ability to map arbitrary chunks of RAM to display regions using start address registers, row address counters, and cursor control. For instance, a designer could allocate just 2 KB of RAM for a 40×25 text screen, or more for bitmapped graphics, with the 6845 providing the address sequencing. Many early microcomputers such as the BBC Micro, Amstrad CPC, and Commodore PET derivatives used the chip, often combining it with a custom video gate array or ULA to generate the pixel stream. IBM also adopted the 6845 in its original Monochrome Display Adapter (MDA) and Color Graphics Adapter (CGA), cementing its influence on the emerging PC standard.

Although by itself the 6845 did not support modern concepts like sprites or hardware scrolling, its register set was exploited creatively. Programmers discovered that by rewriting registers mid-frame (a technique known as “raster tricks”), they could produce split-screen effects, palette changes, or smooth scrolling beyond the documented capabilities. Over time, more integrated graphics controllers absorbed the 6845’s functionality into larger chips that combined timing, pixel generation, and sometimes even acceleration. Nonetheless, the 6845’s architectural model, separating timing control from pixel memory, shaped early video hardware design and left a strong legacy in the personal computer industry.

The 6845s main function is to properly time access to the display memory, and to calculate the memory address of the next portion to be drawn. Other circuitry in the machine then uses the address provided by the 6845 to fetch the pattern and then draw it. The implementation of that hardware is entirely up to the designer and varied widely among machines. The 6845 is intended for character displays, but could also be used for pixel-based graphics, with some clever programming.

Computers that used the 6845 are, among others:

  • BBC Micro
  • Amstrad CPC
  • Videx VideoTerm display cards for Apple II
The Chip is also used in some of the early PC video cards such as the MDA, the Hercules Graphics Adapter, the Color Graphics Adapter (CGA) and the Plantronics Plus graphcis card. The functionality was later duplicated on EGA and VGA hardware for backward compatibility.

Source: WikiPedia

CPU - The Motorola 6502

The 6502 is an 8-bit MicroProcessor designed by MOS Technology. The team was led by Chuck Peddle and had also worked on the Motorola 6800. The 6502 is a simplified, but faster and cheaper design than the 6800.

The 6502 was introduced in 1975 and was the cheapest microprocessor on the market. Together with the Zilog Z80, the 6502 helped start the home computer revolution of the 1980s. The 6502 was used in a wide range of devices: the Atari 2600, the 8-bit Atari home computers, the Apple II, the Nintendo Entertainment System, the Commodore 64, the BBC Micro and many others. All used the 6502 or a variation of it.

The 6502 is a 1MHz design, while the 6502A is designed for 2MHz. The 6502A is 100% compatible with the original 6502.

Commodore soon bought MOS Technology, but conitnued to sell the microprocessor to competitors and licensed the design to other manufacturers.

Source: WikiPedia - MOS Technology 6502

The 650x Instruction Set

Mnemonic Operation Description
ADCAdd with CarryAdds a memory location and the carry bit to the accumulator.
ANDLogical ANDPerforms a logical AND between memory and the accumulator.
ASLArithmetic Shift LeftShifts all bits one position to the left (in memory or accumulator).
BCCBranch on Carry ClearBranches to a new address if the carry flag is clear (0).
BCSBranch on Carry SetBranches to a new address if the carry flag is set (1).
BEQBranch on Equal (Zero Set)Branches to a new address if the zero flag is set (1).
BITBit TestTests bits in memory with the accumulator without modifying the accumulator.
BMIBranch on MinusBranches to a new address if the negative flag is set (1).
BNEBranch on Not EqualBranches to a new address if the zero flag is clear (0).
BPLBranch on PlusBranches to a new address if the negative flag is clear (0).
BRKForce BreakForces an interrupt request and pushes status and PC to the stack.
BVCBranch on Overflow ClearBranches to a new address if the overflow flag is clear (0).
BVSBranch on Overflow SetBranches to a new address if the overflow flag is set (1).
CLCClear Carry FlagClears the processor carry flag.
CLDClear Decimal ModeClears the processor decimal mode flag.
CLIClear Interrupt DisableClears the interrupt disable flag, allowing maskable interrupts.
CLVClear Overflow FlagClears the processor overflow flag.
CMPCompare AccumulatorCompares the contents of a memory location with the accumulator.
CPXCompare X RegisterCompares the contents of a memory location with the X register.
CPYCompare Y RegisterCompares the contents of a memory location with the Y register.
DECDecrement MemorySubtracts one from the value held at a specified memory location.
DEXDecrement X RegisterSubtracts one from the X register.
DEYDecrement Y RegisterSubtracts one from the Y register.
EORExclusive ORPerforms a logical Exclusive OR between memory and the accumulator.
INCIncrement MemoryAdds one to the value held at a specified memory location.
INXIncrement X RegisterAdds one to the X register.
INYIncrement Y RegisterAdds one to the Y register.
JMPJumpSets the program counter to a new address.
JSRJump to SubroutinePushes the return address to the stack and jumps to a new address.
LDALoad AccumulatorLoads a byte of memory into the accumulator.
LDXLoad X RegisterLoads a byte of memory into the X register.
LDYLoad Y RegisterLoads a byte of memory into the Y register.
LSRLogical Shift RightShifts all bits one position to the right (in memory or accumulator).
NOPNo OperationPerforms no operation, consuming 2 machine cycles.
ORALogical Inclusive ORPerforms a logical OR between memory and the accumulator.
PHAPush AccumulatorPushes a copy of the accumulator onto the stack.
PHPPush Processor StatusPushes a copy of the status flags onto the stack.
PLAPull AccumulatorPulls a byte from the stack into the accumulator.
PLPPull Processor StatusPulls a byte from the stack into the processor status flags.
ROLRotate LeftRotates all bits one position left through the carry flag.
RORRotate RightRotates all bits one position right through the carry flag.
RTIReturn from InterruptPulls the processor flags and program counter from the stack.
RTSReturn from SubroutinePulls the program counter from the stack and resumes execution.
SBCSubtract with CarrySubtracts memory and the inverse of the carry bit from the accumulator.
SECSet Carry FlagSets the processor carry flag.
SEDSet Decimal FlagSets the processor decimal mode flag.
SEISet Interrupt DisableSets the interrupt disable flag, preventing maskable interrupts.
STAStore AccumulatorStores the contents of the accumulator in memory.
STXStore X RegisterStores the contents of the X register in memory.
STYStore Y RegisterStores the contents of the Y register in memory.
TAXTransfer Accumulator to XCopies the current value of the accumulator into the X register.
TAYTransfer Accumulator to YCopies the current value of the accumulator into the Y register.
TSXTransfer Stack Pointer to XCopies the current value of the stack pointer into the X register.
TXATransfer X to AccumulatorCopies the current value of the X register into the accumulator.
TXSTransfer X to Stack PointerCopies the current value of the X register into the stack pointer.
TYATransfer Y to AccumulatorCopies the current value of the Y register into the accumulator.
Technical Details
Released
1980
Country
United States
Brand
Commodore
Type
Commodore CBM 8000 Series
Name
CBM 8032
CPU Class
650x
CPU
MOS 6502 @1MHz
Memory
RAM: 32kB
ROM: 18kB
Sound Chip
none
Sound
no sound
Display Chip
discrete TTL Logic
Display
80x25 text
640x200 mono graphics
Best Text
80x25
Best Color
monochrome
Graphics
620x200
Sprites
n/a
System OS
BASIC 4.0
Related Systems 💾
Commodore PET/CBM - 2001/3000 Series
Commodore CBM 4000 Series
Commodore CBM 8000 Series
Commodore CBM-II 500 Series
Commodore CBM-II 600 Series
Commodore CBM-II 700 Series
Commodore C16
Commodore Vic/C64
Commodore Amiga
Commodore Amiga Desktops
Commodore Personal Computer
External Links 🌐
Video - Motorola 6845 Display Controller
Wikipage about the Motorola 6845 CRTC Display Controller Chip.
MOS 6502 CPU Wiki Page
The 6502 is an 8-bit MicroProcessor designed by MOS Technology.