ROM, Read Only Memory

Episode 4

Introduction

In this episode, we'll learn about the ROM chip, or Read Only Memory, which provides us with read-only memory. This memory will allow us to store all the instructions for our programs.

To use this chip we designed a Dual board that will be able to run both a ROM chip and a RAM chip that share the same pinout; in this episode we will focus on the ROM.

We're going to study the chip's pinout, how it works, how to program it using an EEPROM programmer, and we're going to conduct experiments that will allow us to store and run our first program.

As always, we'll explain how to create the board from scratch and how it works.

Introduction

In this episode, we'll learn about the ROM chip, or Read Only Memory, which provides us with read-only memory. This memory will allow us to store all the instructions for our programs.

To use this chip we designed a Dual board that will be able to run both a ROM chip and a RAM chip that share the same pinout; in this episode we will focus on the ROM.

We're going to study the chip's pinout, how it works, how to program it using an EEPROM programmer, and we're going to conduct experiments that will allow us to store and run our first program.

As always, we'll explain how to create the board from scratch and how it works.

ROM board overview

Our RAM/ROM board, when configured in ROM mode, serves to store the programs that we are going to run on our 20c.

In our case, the chip we'll be using is the ATMEL AT28C256. This chip has 32,768 registers of 8 bits each, so we can store up to 32 KB of information in this type of memory. The "256K" in the name refers to the 256 individual Kbits on the board, which are equivalent to 32 KB (256/8=32).

To program this chip with instructions we will use an EEPROM memory programmer.

This chip comes in DIP (Dual Inline Pins) format.

AT28C256 Chip Pin Out Description

This chip has 28 pins with the following function:

A14 - A0 These pins allow us to select which eight-bit register we want to access within our memory. Since there are 15 pins, we can address 2^15 = 32768 eight-bit registers. These pins are connected to the address bus.

I/O 0 a I/O 7:The input/output (I/O) pins are where we will see the contents of each register previously selected to read from memory, or where we will send the data we have to write to memory. These pins are connected to the data bus.

VCC:This pin is where the chip expects a +5Volt power supply.

GND:This is the chip's ground reference pin.

/WE:The Write Enable pin, upon receiving a low or 0 Volt signal, allows writing to the memory registers. Since we are using it as a ROM, we connect this pin directly to +5 Volts to make it read-only. The bar / This means that this pin is active low, which means it waits for 0 Volts to activate.

/ARE YOUThe output enable pin connects or disconnects the I/O pins from the data bus. If the pin is at +5 volts, the memory is disconnected from the data bus, putting its data pins into a high-impedance state. The slash (/) indicates that this pin is active low, meaning it waits for 0 volts to activate.

/THIS:The chip enable pin connects or disconnects the chip's pins for reading or writing, working in conjunction with /OE and /WE. It is active low, meaning it waits for 0 volts to activate.

Memory Map

The 6502 can address up to 65,536 8-bit registers, or 64K as we like to say. This would allow us to use up to two 32K EEPROM chips.

The processor handles addresses from $0000 to $FFFF, always in hexadecimal as indicated by the dollar sign. If we wanted to divide these addresses between two chips, we could assign $0000 to $7FFF to the first and $8000 to $FFFF to the second.

Our chip has 32kb of space but we will have to decide which memory addresses we want to access it with; this is called a memory map.

The memory map indicates for each chip and peripheral of our 20c which addresses of the ADDRESS BUS will activate it to access its registers, in the case of chips with registers to configure them or in the case of ROM and RAM memory chips to read or modify their contents.

We are going to decide to place our ROM chip at addresses $8000 to $FFFF mainly because there we will have 3 very important memory positions or vectors, the two for interrupts NMI and INT and the one for RESET which as we remember is where the 20c chip looks for the address where the first program to be executed will be when we turn it on.

This memory map is the one originally recommended in the MOS Technologies Hardware and Programming manuals.

The following is the memory map of the 20c

In this map we can see where we have the ROM chip and some other extra chips that we will study in future episodes.

How to access the Chip

The chip is not active all the time, otherwise the data bus would always be occupied. The CPU commands the computer's chips and tells the chip that it wants to read its data through the ChipSelect (CS) and OutputEnable (OE) pins.

This is where the memory map comes into play. We'll activate the /CS and /OE pins when an address defined as part of the ROM chip is written to the ADDRESS BUS. This chip, by definition, will be read-only.

Reading

To perform a read operation, we must first set the address of the memory we want to access on the addressing bus and then set the pins:

/WE en +5 Volts (High)

/OE and 0 Volts (Low)

/CE at 0 Volts (Low)

The data bus contains the information associated with the address we set in the address bus. The /WE or /CE signals must be pulsed. When we specify that a signal must be pulsed, it's because the chip reacts not to a specific voltage value, but to a change in voltage; in the case of /CE, from +5V to 0V, also known as the Falling Edge.

Writing

To perform a write operation, we must first set the address of the memory we want to write to on the ADDRESS BUS, then the information to be written on the DATA BUS, and finally connect the following pins:

/WE and 0 Volts (Low)

/OE and +5 Volts (High)

/CE at 0 Volts (Low)

Remember that since it is a ROM, we will not be writing to it; we will achieve this by always connecting the /OE output enable chip to +0v or Ground.

How do we select memory from the processor?

Our chip is located at addresses from $8000 to $FFFF. Let's see what these addresses look like in binary to see if we can find any useful patterns.

We can see that the first bit in binary is one. To address all the EEPROM registers, we need 15 pins from A0 to A14, leaving pin A15 unused.

To put the chip into read-only mode, we could then permanently connect the following pins:

/WE en +5 Volts (High)

/OE and 0 Volts (Low)

We can also connect the /WE pin to the R/W pin of the 6502 processor since it will emit a +5V pulse when performing a read, but in case it makes a mistake and sends a write, we don't want this to affect our memory, so we don't do it.

Pin A15 is set to either 1 or +5 Volts (High). We cannot connect it directly to the /CE pin because it will not activate, as the pin is Active Low. What we should do is invert the value from 1 to 0, and I propose doing this with a NAND gate.

A NAND gate has the following truth table, which is the opposite of an AND gate.

Therefore, if we connect the +5 Volts (HIGH) output of pin A15 as input A to the same NAND gate, and the +5 Volts (HIGH) output of pin A15 as input B, the result will be 0 Volts (LOW), which will enable the /CE chip enable pin.

For this we can use a classic chip such as the 74HC00 which has four NAND gates with two inputs each.

We will see how to make the connection to our board in the Connection Guide section.

Programming in Assembler

To easily program our 6502 chip, we'll use an assembler program called VASM. This assembler will allow us to compile our program into binary code. The download link is in the references.

Program

Let's start with a simple assembler program that emulates our previous experiments with resistors to encode the NOP no-operation instruction whose opcode is 0xEA.

We're going to explain line by line what our program does:

Lines 1 and 2 comments

Line 3 .org 8000

This indicates that we want to start our program at address $8000, right where our ROM begins. This will cause the compiler, when translating our program into the opcodes for each operation, to place them starting at address $8000.

Line 4 empty

Line 5 RESET

This is called a LABEL; it allows us to indicate a part of the code where we want to go without having to know the exact hexadecimal address in memory. The assembler will take care of setting the correct address during assembly (the assembler who puts together a good assembly, will be a good assembler).

This LABEL in particular is important because the 6502 automatically looks in the address $FFFC and $FFFD for the address where the first instruction to be executed is located, and we are going to ask it to be the address where the LABEL RESET is located.

Line 6comment

Line 7 to 16 NOP

Our instructions begin with the NOP (no operation) instruction. The 6502 will read it and then wait two clock cycles without doing anything. In our compiled program, it will write 10 consecutive bytes EA.

Line 17 empty

Line 18 comment

Line 19 .FFFA organization

Here we tell the compiler to start from this address and place the following instructions

Line 20 RESET

So, as a given, the address of the RESET label, as written by LowByte and HighByte because the processor is 6502 Little Endian, will be at address $FFFA $00 and $FFFB $80. This address loads the NMI interrupt vector.

Line 21 .FFFC org

Here we tell the compiler to start from this address and place the following instructions

Line 22 RESET

So, as a given, the address of the RESET label, as written by LowByte and HighByte because the processor is a 6502 Little Endian, will be at address $FFFC $00 and $FFFD $80. This address loads the interrupt vector for the RESET operation; after a processor reset, the first instruction loaded will be the one located here.

Line 23 comment

Line 24 .org FFFE

Here we tell the compiler to start from this address and place the following instructions

Line 25 RESET

So, as a given, the address of the RESET label, as written by LowByte and HighByte because the processor is 6502 Little Endian, will be at address $FFFE $00 and $FFFF $80. This address loads the IRQ interrupt vector.

Compiling

Now that we have our source code, let's compile our assembler code to machine code using vasm.

Here we will explore several options to use with the assembler, let's look at them

Vasm6502_oldstyle This option tells the assembler to use the Oldstyle syntax module; this will define various aspects of how to write LABELS and other details.

-Fbin We will designate the `simply binary output module` as the Output module. This module will write the output of all the instructions in our source code as a binary file. Empty spaces between `.org` sections that are not filled with instructions will contain the byte `$00`.

-dotdir which accepts special addresses in our code for the assembler, such as .org

Ep4_firstprogram.asm the name of our file with the source code

-o , we will indicate the file where to put the assembled binary code.

Ep4_firstprogram.bin the name of our binary assembled program

Machine code analysis

Now, using the hexdump program, let's examine our machine code and try to interpret where the previous instructions are located.

Let's add $8000 to the addresses we see, as shown in the hexdump file. So, where it says 00000000, we should see 000008000.

Why is this? Because the ROM only has 32KB, and we're mapping it to the memory of our 6502 starting at address $8000.

However, this address doesn't actually exist in the ROM, since 32KB ranges from $0000 to $7FFF. Hexdump only shows the actual contents of the file without revealing where we're going to map it.

Line 00000000 Here we see 10 times the EA byte which corresponds to the NOP operation code

Line 00000010 all zeros, remember how -Fbin filled in the spaces we didn't define

Line 00007ff0 Here we finally see the last 6 bytes as 00 80 00 80 00 80 which corresponds to the LOW and HIGH addresses for the reset LABEL which is defined at address $8000 for the 3 vectors of 6502 NMI, RESET and IRQ.

Now that we have our machine code, let's record it onto the EEPROM chip.

How to program the chip with an EEPROM programmer

To write the instructions for our chip, we will use an external programmer that will allow us to fill each memory location with the instructions we want.

Now that we have our first program as a 32768-byte binary file, all that remains is to program it into an EEPROM, and this is done with an EEPROM programmer. In this example, we will use an EEPROM programmer, the TL866 II Plus or the T48.

This eeprom programmer is very easy to use through the minipro program; you simply tell it what type of eeprom chip you are going to program and what file you want to program.

Before starting to program, we connect the programmer to our computer, and insert the eeprom chip into the zif socket.

We will use the minipro program to write the chip, and where to get it is included in the references of this same episode.

To save a binary file with the name, for example, ep4_firstprogram.bin, we will execute the following command.

$ minipro -p AT28C256 -w ep4_firstprogram.bin

The -p option is to specify the model of the memory we are going to write, in this case an ATMEL AT28C256.

The -w option specifies that we want to write, followed by the name of the file to be recorded.

And with this we have our first program recorded in ROM. In the experiments we will see what our computer runs with this first program.

ROM PCB Circuit

The following diagram shows the circuit that explains the operation of the 20c ROM board.

The circuit has the following elements:

SOCKET RAMROM

This is physically represented as a 28-pin DIP-28 socket. Each of these pins has a Netlist connected to it, representing each of the functions of these pins. For example, the netlist A0 represents pin A0, which will be connected to all the elements that need to be connected to the line or trace of address 0.

It has netlists A0 to A14, D0 to D7, and all the /RW (Write Enable signal), OE, and CS netlists connected. It is powered by the +5V and GROUND lines.

HEADER ADDRESS

This is a 16-pin female header used to connect the address bus. It has 16 netlists (or connections between several pins that carry the same information) connected to it. These netlists correspond to pins A0 through A15.

We have two of these connectors so that we can have the information on the top and bottom of the board and make interconnections with other boards.

HEADER DATA

This is an 8-pin female header used to connect the data bus. It has 8 netlists (or connections between several pins that carry the same information) connected to it. These netlists correspond to pins D0 through D7.

We have two of these connectors so that we can have the information on the top and bottom of the board and make interconnections with other boards.

HEADER EXPANSION

This is a 16-pin female header used to connect the expansion bus. It has 16 netlists connected to it (or connections between several pins that carry the same information). These netlists correspond to some netlists connected directly to RAMROM pins, such as:

RW, OE, CS

or generic signals that can transmit information to other boards, such as:

RST, CLOCK, RW, E5 hasta E15

We have two of these connectors so that we can have the information on the top and bottom of the board and make interconnections with other boards.

HEADER POWER y GROUND

This header has two pins, connected to the 5V and GROUND layers respectively. We have four of these connectors, one in each corner of the board.

CAPACITOR

We have a 0.1 microFarad capacitor so that when the CPU starts up it can have the extra power boost it needs.

SCREW HOLES

To be able to fix our plate to different places, it has 6 holes for 3mm or M3 screws.

SWITCH RAMROM SW1

This switch has no electrical characteristics and is not connected to any circuit. Since our board can function as both ROM and RAM, we will run the switch and leave it in the position where we will use the board.

NETLIST

The components are connected to each other through an object called a netlist, which allows us to have cleaner diagrams.

This works in such a way that everything with the same name belongs to the same netlist and must be connected together when we make the PCB (with traces).

In our example, all A0 connections will be connected by traces on the PCB

ROM PCB Board

The following PCB diagram explains how the components and traces are positioned to connect our circuit. The PCB we designed is made with 4 layers of copper.

TOP

In the layer called TOP, which is the one we could see as the top and front of our PCB, we will have some of the connections of our netlist through traces, which are thin copper lines that connect them as if they were cables and all the components, whether sockets, capacitors and headers.

LAYER 5V

We will connect the power connections to the +5V layer. By using these connections on a separate layer, we save many centimeters of traces that would otherwise be connected to pins with 5V voltages. We can directly connect each component's pin to this layer through a hole called VIA.

LAYER GROUND

In the GROUND layer, we connect the ground or earth connections. Having an entire layer for GROUND allows us to isolate electrical noise from the connections between components.

BOTTOM

Finally, we have the BOTTOM layer where our components are soldered and we have additional connections.

3D Modeling

When we finish making our board, we must proceed to 3D modeling of it to see how it looks and if we like the place where we put each component.

Generating of the source files

To have our PCB manufactured, we will need at least 3 files:

Gerber file where we tell the manufacturer how to assemble our board
BOM file or Bill of Materials where all the components that make up our board are found with the manufacturer's product code.
Pick and Place file where we tell the manufacturer how to place the components on our PCB board.

These files will be available pre-generated on the Osolabs GitHub repository. We've also included files that allow you to edit the circuit using EasyEDA, Kickcad, or Altium Designer software.

With these three files we will be able to manufacture our board

Gerber_v03_RAM_ROM_4Plane_2026-05-26.zip This file contains all the plans needed to generate our PCB board.

BOM_v03_RAM_ROM_4Plane_v03_RAM_ROM_4Plane_2026-05-26.xlsx It contains all the components of our board and the manufacturer's code that identifies that component.

PickAndPlace_v03_RAM_ROM_4Plane_2026-05-26.xlsx

Indicate where on the PCB each component goes and on which layer it should be located.

The following files are provided to enable editing of the circuit

3DModel_ramrom_front.png

It's an image of the back of our 3D-modeled plate

3DModel_ramrom_back.png

It's an image of the front of our 3D-modeled plate.

Altium_Circuit_1_v03_RAM_ROM_4Plane.schdoc

It contains the circuit design editable with the Altium Designer program.

Altium_PCB_v03_RAM_ROM_4Plane.pcbdoc

It contains the PCB design editable with the Altium Designer program.

PCB_v03_RAM_ROM_4Plane_2026-05-26.pdf

It's a PDF with a drawing of each layer of the PCB.

ProDoc_v03_RAM_ROM_4Plane_2026-05-26.epro

EasyEDAPro file with the circuit and PCB which can be edited.

SCH_v03_RAM_ROM_4Plane_2026-05-26.pdf

It is a PDF with the logic circuits of the board

ROM Board Preparation

Upon receiving our motherboard from the factory, and before we begin using it, as soon as we take it out of the box, there are a few tasks we must perform to get the most out of it:

Remove the handling edges from the board

Clean the board with isopropyl alcohol

OPTIONAL - Install a 28-pin ZIF socket in the socket present on the motherboard

Place the AT28C256 chip in the socket

Manually adjust the chip's legs to fit the socket
Align pin 1 with pin 1 on the socket
First insert one side of the chip, placing it diagonally, and then the other side.
Check that none of the legs are bent.
Apply pressure and check that they are all properly fitted into the socket.

Attach the mounting bracket screws to raise the plate above the surface, or install it; in our case, we used the 3D printed base from the 20c, which we will learn to create and print in a future episode.

Configure switch SW1 in ROM mode to remind ourselves what function the board performs.

ROM Board Connection Guide

We'll explain how to connect the various components of the board so it's ready to use in a model. Use this section as a reference when you assemble the entire 20c.

We want to activate the ROM memory to work at addresses $8000 to $FFFF. For this, we will need to have pin A15 set to one, as we have already seen.

The ROM memory has two pins to activate /OE and /CS both must be at zero for it to be activated.

/OE ROM memory

We will connect the /OE pin directly to the GROUND signal so that it is always active.

R/W memoria ROM

We will connect the R/W pin directly to +5v so that the memory is always read-only.

/CS ROM memory

We will select the chip select pin using pin A15. We will combine pin A15 with itself in a NAND gate such that when it is a logic 1 or +5V, the NAND gate will output a logic 0 or +0V. This is based on the behavior of the NAND gate, as we have already studied.

We will connect that NAND gate output through the EXPANSION BUS with the /CS pin

We will be using the 74HC00 chip, using pins 2A, 2B and output 2Y using a breadboard

Connect the 74hc00 chip to a breadboard, mounting the left side of the chip on top of the breadboard's channel and the right side on the bottom of the channel. This will ensure that the orientation of the included diagram is maintained, with PIN 1 at the bottom left.

Connect the VCC pin to the +5V or red rail of the breadboard

Connect the GND or ground +0v pin to the blue rail of the breadboard.

Connect the top and bottom channels of the breadboard for +5v and 0v or ground to each other

To achieve the effect on the NAND gate, we will connect pin A15 of the addressing bus to pin 2B of the 74HC00 and from the same breadboard we will connect pin 2B to 2A.

We connect Output 2Y to the /CS pin of the expansion bus

Finally, for the 74HC00 chip to function, we cannot leave any of its inputs floating, so we connect them all to +5V. These are pins 1A, 1B, 2A, 2B, 4A, and 4B.

Connecting the rest of the boards

To carry out our experiments we need to configure the CLOCK and the CPU 6502 of the 20c as well as power it on +5v.

We connect a power module to our breadboard, selecting the +5v rail, making sure to put the pin of the module that says + on the red +5v rail.

We connect the red rail of the breadboard to the +5v pin of the RAM/ROM board.

We placed the CLOCK board next to the RAM/ROM board and connected the +5V power and GROUND pins between the two boards.

We connect the output of the stepper clock from the CLOCK board to the CLOCK pin of the RAM/ROM board, but on the lower header pin, the one closest to the breadboard.

We placed the CPU board on top of the RAM/ROM board and connected all the ADDRESS BUS and DATA BUS headers. We also connected the CLOCK pin and the +5V and GROUND pins together.

We installed the DUINO PROTOCOL ANALYZER boards along with your Arduino Mega on the top header of the CPU 6502 board.

Finally, we verify that all the connections look like this.

Experiment 1 - Recording only NOPs

We will reproduce the experiment we used by recording the NOP no-operation instruction, whose opcode is 0xEA, as we have been doing so far, and we will study how the 20c behaves using the DUINO PROTOCOL ANALYZER board.

We're going to use the program we created in the machine code section. This program mainly uses the NOP instruction:

For a line-by-line explanation of what the program does, go to the Programming in Assembler section.

Let's compile it using vasm.

And now we place the EEPROM in the programmer

We run the minipro command and save the compiled binary to the EEPROM

Now we are going to study the processor output using the DUINO PROTOCOL ANALYZER, using the script 001_Arduino_DUINO_PA that we already saw in Episode 3 about the DUINO PA and we will analyze the output of our experiment.

Reset followed by reading NOP instructions

We connect the CLK pin of the headerCLOCK_555_OUT

Let's select the switch for the stepper clock.

Let's press the reset button on our CPU and hold it down.

Press the STEP BUTTON button on our CLOCK plate 3 times

Release the RESET button on your CPU

Let's continue pressing the STEP BUTTON on our CLOCK board and we'll see that each time we do so, one cycle advances in our CPU; some instructions take up one clock cycle and others take more.

We observed in detail the data given to us by our DUINO PROTOCOL ANALYZER through the Arduino Mega.

The processor will turn on and search in positions $FFFC and $FFFD for the address of the first instruction to be executed, ordered as Low Byte and High Byte.

$FFFC contains $00 = %0000 0000

$FFFD contains $80 = %1000 0000

In it you will find bytes $00 and $80. Using little-endian notation, the address that the CPU 6502 will load into its program counter register will be $8000.

If we sort it by the address bus pins, we would see:

Pin A15 is a 1 which through the NAND gate is transformed into 0 equivalent to 0 Volts or Low, and as it is connected to the /CE pin our EEPROM will be activated.

This will load the Program Counter with the first position of our fictitious program, which will be $8000, and will look for the code of the next instruction to execute, which will be EA, since it is the only thing we have on the data bus.

The next instruction read from the data bus is the instruction EA, which means no operation NOP. We know it is an operation code because the SYNC flag S is set on our EXPANSION BUS, signifying an OP-FETCH cycle.

This execution will last two clock cycles, and then the program counter will advance to 8001 and read the data bus again in search of the next instruction, which will still be EA, and so on.

The execution cycle of the first instruction is as follows:

8000 reads the opcode from the databus. There is +5V on the SYNC pin, which it interprets as an instruction. Increment the program counter.
Execute the EA instruction, i.e., NOP (no operation) (cycle 1 of 2), and set 8001 to the address bus.
It finishes executing the NOP instruction (cycle 2 of 2) and fetches the next instruction from address 8001 on the address bus. It increments the program counter.

Experiment 2 - Running a Loop

In this experiment we will study a simple loop and how the 20c behaves using the DUINO PROTOCOL ANALYZER board.

In this new experiment we will mainly use two instructions:

Let's create a second program where we'll execute the LDA load instruction, loading the number 42 (in hexadecimal, $42). We'll use the JMP jump instruction to re-execute the LDA load instruction in an infinite loop and observe what happens.

Let's look at what our program does, line by line.

Lines 1 and 2 comments

Line 3 .org 8000

Line 4 empty

Line 5 RESET

This particular LABEL is important because the 6502 automatically looks in the $FFFC and $FFFD addresses for the address where the first instruction to be executed is located, and we are going to ask it to use the address where the RESET LABEL is located.

Line 6 comment

Line 7 LDA #$42

Our instructions begin with the instruction LDA #$42. This instruction loads the value 42 in hexadecimal into the accumulator. It is an immediate mode instruction since we are loading a literal number, not a memory location, and its OPCODE is A9.

Line 8 JMP RESET

Here we execute the JMP or Jump instruction to the RESET label. This will cause our program counter to take the value of the RESET label, in this case $8000, and then run the LDA #$42 instruction again in an infinite loop. The OPCODE for the JMP instruction is $4C.

Line 9 empty

Line 10 comment

Line 11 .org FFFA organization

Here we tell the compiler to start from this address and place the following instructions

Line 12 RESET

Line 13 .org FFFC

Here we tell the compiler to start from this address and place the following instructions

Line 14 RESET

Line 15 comment

Line 16 .org FFFE

Here we tell the compiler to start from this address and place the following instructions

Line 17 RESET

Let's compile it with vasm.

And now we place the EEPROM in the programmer

We run the minipro command and save the binary

And now we are going to study the processor output using the DUINO PROTOCOL ANALYZER, using the script 001_Arduino_DUINO_PA that we already saw in Episode 3 about the DUINO PA and we will analyze the output of our experiment.

Reset followed by reading NOP instructions

We connect the CLK pin of the headerCLOCK_555_OUT

Let's select the switch for the stepper clock.

Let's press the reset button on our CPU and hold it down.

Press the STEP BUTTON button on our CLOCK plate 3 times

Release the RESET button on your CPU

Let's continue pressing the STEP BUTTON on our CLOCK board and we'll see that each time we do so, one cycle advances in our CPU; some instructions take up one clock cycle and others take more.

We observed in detail the data given to us by our DUINO PROTOCOL ANALYZER through the Arduino Mega.

In the first three lines we can read the word RESET, that means we have the reset button pressed.

Then we count 7 clock cycles, which is how long a reset lasts, and we see that in the next two cycles we look for the reset vector at addresses FFFC and FFFD.

The processor will turn on and search in positions $FFFC and $FFFD for the address of the first instruction to be executed, ordered as Low Byte and High Byte.

The first instruction will be $8000

At $8000, the opcode A9 of the LDA instruction will load a value into the accumulator.

$8001 will be the amount to be charged to the accumulator, in this case $42

At $8002 we will have the value $4C which is the indication to make a JMP instruction

At $8003 we will have the value $00 which is the Low byte of the address where the JMP has to jump

At $8004 we will have the value $80 which is the High byte of the address where the JMP has to jump. With these two values, the JMP already has where to jump to, address $8000, and that is what it loads into the Program Counter and starts the Loop again.

Conclusions

The RAM_ROM board allows us to include a ROM chip in our system. This gives us the great advantage of being able to have assembled programs programmed into our 20c to execute different tasks. We'll review how the ROM chip works, how to create our board, and how to perform a couple of experiments to learn how it functions.

The RAM ROM board in operation

To visually demonstrate how to connect the 20c's RAM-ROM board, I've included a detailed video from the series, as always. In this video, we'll see how the pins are connected, and our experiment will be visually illustrated.

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