DUINO PROTOCOL ANALIZER

Episode 3

In this episode we are going to discover the DUINO PROTOCOL ANALYZER on our 20c computer. This board will allow us to connect an Arduino Mega so we can use it as a protocol analyzer for the 20c's three buses the ADDRESS BUS, the DATA BUS and the EXPANSION BUS.

We're going to study how the board works, how to connect our Arduino Mega, how to create a program for the Arduino that allows us to analyze the 20c buses, explaining what addresses we see and even what machine code instructions are being executed.

We'll recreate this PCB from scratch and finish with an experiment that will allow us to see how our computer's bus works.

Overview of the DUINO PROTOCOL ANALYZER

Our DUINO PROTOCOL ANALYZER board is used to interpret the electrical pulses we have on the three main buses of our 20c computer: the ADDRESS BUS, the DATA BUS, and the EXPANSION BUS.

Bus Operation Description

The buses on our 20c computer, and on every 8-bit computer based on the 6502 processor, operate by sending electrical pulses between 0V and 5V. To be precise, they operate with CMOS levels in which any voltage above 2.4 volts is taken as a 1 and anything below 0.4 as a 0. In the following table based on the 6502 processor datasheet, Vss is our ground pin, which we assume is +0V.

The computer then never sees zeros and ones but rather voltage variations. For our interpretation and to be able to apply logical functions, we will say that a voltage of Vss+2.4v is a High or 1 and that a voltage less than Vss+0.4 is a Low or 0.

Computer chips synchronize with each other using a clock, which we saw in the previous episode. When a clock pulse is marked, the values of all buses are read and assumed to be simultaneous.

For example, at a given clock pulse we can read these values on the buses:

ADDRESS BUS = 1000 0000 0000 0000 (A15-A0)

DATA BUS= 1010 1001 (D7-D0)

EXPANSION BUS= SYN sync pin to 1

Let's interpret this data, the value of the address bus converted from binary to hexadecimal is $8000

The data bus value in hexadecimal is $A9

When the SYN synchronization pin has a value of 1, the 6502 processor is in an OPCODE FETCH cycle, which means that it is searching for an instruction and the instruction will have its operation code or OPCODE on the data bus.

On the data bus we see the value $A9, if we look for it among the instructions of the 6502 processor we will see that it corresponds to the instruction to load the accumulator with the value found in the next clock cycle on the data bus, this instruction is LDA in immediate mode.

If we were to look at the next clock pulse, we would read on the buses:

ADDRESS BUS= 1000 0000 0000 0001 (A15-A0)

DATA BUS= 0100 0010 (D7-D0)

EXPANSION BUS= SYN sync pin at 0

This corresponds to memory address $8001 (the next one after the previous one), the value $42, and the SYN pin at 0, which indicates that what is on the data bus is data, and the previous instruction LDA, which we already read, was waiting for it.

These two bytes that we read from the data bus are interpreted as the assembler code.

LDA #$42

And in machine code as A942

And they appear in memory as:

And on the bus as voltages.

How the DUINO PROTOCOL ANALYZER board works

Our board simply connects the bus pins of our 20c with pins present on an Arduino Mega development board.

We will have 16 pins for the ADDRESS BUS, 8 pins for the DATA BUS, and 16 pins for the EXPANSION BUS. We can see how the pins are connected in the following table:

Specifically, we mapped the Arduino Mega pins as follows

This is how our Arduino Mega would be connected to the DUINO PA board.

We connect the E1/CLK pin to pin 2 of the Arduino Mega instead of the more logical pin 40. We do this because we want to capture all the information on the bus when the CLOCK pin is at +5V or 1. We can only generate an interrupt on that pin, the Arduino only allows interrupts on pins 2, 3, 18, 19, 20, and 21.

In order for our Arduino Mega to interpret the electrical values of the bus as zeros and ones and give us information about what is happening, we will have to make a small program.

Setup Arduino

If you've never used an Arduino before, you'll need to install the Arduino IDE to run your first program. This IDE will allow you to run programs on your Arduino Mega.

We downloaded it from www.arduino.cc

As soon as we open our IDE, we will have to configure our Arduino Mega, after connecting it to the USB port of our computer.

To do this, we go to the top window and choose the port where our Arduino is connected and specify that it is a Mega or Mega 2560.

Now we need to upload the programs we want to experiment with to the Arduino; to do this we press the arrow-shaped button.

The programs for this episode can be found on OsoLabs' GitHub; they are 001_Arduino_Basico and 001_Arduino_DUINO_PA.

Finally, to activate the output of the programs and see how they work, we need to connect the Serial Monitor of the Arduino IDE, by going to tools -> Serial Monitor

First Program for capturing outputs

In this program we will see how to read the buses of our computer, synchronize them with the computer's clock to see one line of information for each tick of the clock, convert the electrical pulses to ones and zeros and finally see them on the screen.

For this, we'll use our first Arduino program, which we'll call 001_Arduino_Basico. To edit it, you'll need the Arduino IDE and either type in the program or download it from the GitHub repository for this episode.

To run our program, we will perform a few simple steps:

Define which Arduino Mega pins are the Buses
Initialize the Arduino
Sync them with the clock
Transform the voltages to ones and zeros
Display them on screen

Define Buses

Line 1 is a comment,

Line 2 in the diagram defines the variable ADDR as an array in which we will have the odd numbers from 23 to 53, these coincide with the pins of the Arduino Mega that we have connected to pins A15 to A0 of the data bus.

Line 3 defines the variable DATA as an array where the even numbers from 36 to 22 match pins D7 to D0 of the data bus.

Line 4 defines the variable EXP as an array in which we will have the consecutive numbers from 62 to 69 to represent the pins of the Expansion bus E15 to E8 and the even pins from 52 to 38 to represent the pins of the Expansion bus E7 to E0.

With the exception of the CLOCK pin, which, as we already mentioned, will be pin 2 instead of pin 40 in order to add an interrupt. Therefore, we define a constant with the name CLOCK and the value 2, corresponding to pin 2 of the Arduino Mega.

Initialize theArduino and Sync with the Clock

We will define the mandatory function setup() where we will initialize various variables.

Line 8 defines the setup function, a mandatory function of the Arduino.

Lines 9 to 11 read the contents of the ADDR array and configure each of those pins in INPUT mode to read the information that will be on them.

Lines 12 to 14 read the contents of the DATA array and configure each of those pins in INPUT mode to read the information that will be on them.

Lines 15 to 17 read the contents of the EXP array and configure each of those pins in INPUT mode to read the information that will be on them.

Line 18 configures the CLOCK pin as INPUT

Lines 19 to 21 are a comment.

Line 22 creates an interrupt on the Arduino Mega with the instructionattachInterruptwhere it tells it as the first argument to choose the CLOCK pin to analyze based on which pin to make the interrupt, as the second argument to execute the onClock function and as the last argument to execute it when the values of the CLOCK pin go from 0V to +5V or what we know as rising edge.

Line 23 We define that we want the Arduino to communicate through the serial port at a speed of 115200 bps.

Transform the voltages into ones and zeros and display them on the screen

The next function is the one that does all the magic. This is the `onClock` function, which reads the bus voltages and displays them on the screen. This function will execute every time the clock pulse goes from 0V to +5V from pin 2 of the expansion bus to pin 2 of the Arduino Mega, thanks to the interrupt we created on line 22 that executes this function.

Line 26 defines the function name as onClock

Line 27 defines an output variable as an array of 15 characters which we will use to format the way information is displayed in line 49

Line 28 we define an unsigned integer with a name address, in this we will store all the bits of the ADDRESS BUS from the most significant A15 to at least A0.

Line 29 we start a for loop that will run 16 times

Line 30 reads one bit from the ADDRESS bus. In each iteration, it will be the number corresponding to ADDR[i]. If i is zero, it will be, for example, the value of pin 23 of the Arduino Mega, corresponding to pin A15 of the Address Bus. The question mark ? followed by 1:0 will cause us to store the number 1 in the variable bit if true (+5v) or 0 if false (+0v).

Line 31 we print that bit through the Serial connection

Line 32 we shift all the bits we had in the address variable to the left and add the bit we just read (least significant place) to the empty place

Line 33 we close the for loop

Line 34 we print a space to separate the content

Lines 35 to 41 we do the same with the data bus

Lines 42 to 48 we do the same with the Expansion bus

Line 49 defines the output format to be printed within the output variable, assigning a 4-character hexadecimal number to the ADDRESS bus, a 2-character hexadecimal number to the DATA bus, and a 4-character hexadecimal number to the EXPANSION bus.

Line 50 We print the output variable to the serial console and jump to the next line

Line 51 we close the onClock function

Default Loop

Lines 52 to 54 we generate the default Arduino loop function but empty since we do not use it because we read based on the interrupts generated on pin 2 by the timing of the CLOCK.

Example of output

Here we can observe

The 16 binary numbers corresponding to the ADDRESS BUS ordered as A15 to A0.
The 8 binary numbers corresponding to the DATA BUS ordered as D7 to D0.
The 16 binary numbers corresponding to the EXPANSION BUS ordered as E15 to E0.
The 4 numbers in hexadecimal representing the ADDRESS BUS
The two hexadecimal numbers representing the DATA BUS
The 4 hexadecimal numbers representing the EXPANSION BUS

Second Program to display executed instructions

With this program we will interpret the information above and be able to see:

The information in hexadecimal,
What memory address are we looking at?
If we are doing a reading or a writing,
To determine whether or not we are dealing with an instruction OPCODE on the DATA BUS or just data.
Interpret, if it is an instruction, what instruction it is.
Show the special case of performing a reset
Show which chip we are writing to: ROM, RAM, or any I/O chip.

Define Buses

Line 1 is a comment

Line 3 defines the variable DATA as an array where the even numbers from 36 to 22 match pins D7 to D0 of the data bus.

Line 4 defines the variable EXP, we'll use an array where the consecutive numbers 62 through 69 represent the pins of the expansion bus E15 to E8, and the even-numbered pins 52 through 38 represent the pins of the expansion bus E7 to E0. The exception is the CLOCK pin, which, as we mentioned, will be pin 2 instead of pin 40, to allow for an interrupt. Therefore, we define a constant named CLOCK with the value 2, corresponding to pin 2 of the Arduino Mega.

Let's define some extra pins of the EXPANSION BUS.

Line 6 defines pin 38 as the RESET pin; when this pin has the value +0v, it means we are pressing the reset button on the processor board.

Line 7 defines pin 2 as the CLOCK pin; this pin, in its transitions from +0v to +5v and back to +0v, marks one clock cycle.

Line 8 defines pin 42 as the READ_WRITE pin; when the pin is at +0v we are writing and when it is at +5v we are reading.

Line 9 defines pin 68 as the SYNC pin; when the pin is at +0v on the DATA BUS there is data, and when it is at +5v on the DATA BUS there are instructions.

Initialize the Arduino and synchronize with the clock

We will define the mandatory function setup() where we will initialize various variables.

Line 11 defines the setup function, a mandatory function of the Arduino.

Lines 12 to 15 read the contents of the ADDR array and the EXP array, configuring each of those pins in INPUT mode to read the information that will be in them.

Lines 16 to 18 read the contents of the DATA array and configure each of those pins in INPUT mode to read the information that will be on them.

Line 19 configures the CLOCK pin as INPUT.

Line 20 configures the READ_WRITE pin as INPUT.

Line 21 configures the SYNC pin as INPUT.

Line 22 configures the RESET pin as INPUT.

Line 23 is a comment.

Line 24 creates an interrupt on the Arduino Mega with the instruction attachInterrupt where it tells it as the first argument to choose the CLOCK pin, as the second argument to execute the onClock function and as the last argument to execute it when the values go from 0V to +5V or what we know as rising edge.

Line 25 we define that we want the Arduino to communicate through the serial port at a speed of 115200 bps.

Transform the voltages into ones and zeros and display them on the screen

The next function, again, is the one that does all the magic. This is the familiar onClock function, which reads the bus voltages and displays them on the screen. It will execute every time the clock pulse goes from 0V to +5V from pin 2 of the expansion bus to pin 2 of the Arduino Mega, thanks to the interrupt we created that executes it on line 24.

Line 28 defines the function name as onClock

Line 29 defines a variable SYNC_VALUE where we will store the value S if it is at +5v and n if it is at +0v. If the variable is S then on the data bus we have the code of the instruction to be executed.

Line 30 defines a variable RESET_VALUE where we will store the value n if it is at +5v and R if it is at +0v. If the variable is R then the processor board is receiving the signal to start executing a reset.

Line 31 defines a READ_WRITE_VALUE variable where we will store the value r if it is at +5v and W if it is at +0v. If the variable is r then we are doing a read, if it is W we are doing a write.

Line 32 defines an output variable as an array of 40 characters which we will use to format the information to be displayed on line 48

Line 33 defines an unsigned integer named address. In this, we will combine all the bits of the ADDRESS BUS from the most significant A15 to at least A0.

Line 34 we start a for loop that will run 16 times

Line 35 reads a bit from the ADDRESS bus. In each iteration, it will be the number corresponding to ADDR[i]. If i is zero, it will be, for example, the value of pin 23 of the Arduino Mega corresponding to the Address Bus pin A15. The question mark ? followed by 1:0 will make us store the number 1 in the variable bit if it is true (+5v) or 0 if it is false (+0v).

Line 36 we print that bit through the Serial connection.

Line 37 we shift all the bits we had in the address variable to the left and add the bit we just read (least significant place) to the empty place.

Line 38 we close the for loop.

Line 39 we print a space to separate the content

Lines 40 to 45 we do the same with the data bus

Line 46 we run the function sync_string which based on the variablesSYNC_VALUE, RESET_VALUE and data It will be stored in a character type variable instruction the instruction that was executed in the processor if we are in an instruction cycle or the word RESET if the reset button is being pressed.

Line 47 we run the function find_chip which takes the address bus bits as parameters and will tell us which chip on the 20c (ROM, RAM, VIA1, etc.) we are addressing.

Line 48 defines the output format to be printed within the output variable by putting:

a 4-character hexadecimal number with the ADDRESS bus,
a character if it is a read or write,
a character if we are in a SYNC cycle also called an opcode fetch cycle,
a 2-character hexadecimal number with the DATA bus,
Five characters to define the chip we are using
the instruction we are executing if it is a SYNC cycle, or the word RESET if we are pressing the reset button, or nothing if we are in a data cycle

Line 49 we print the variable output and we skip a line.

Line 50 we close the onClock function

Finding which instruction we are executing

The sync_string function tells us which instructions we are executing, taking into account 3 parameters:

whether or not we are in a SYNC cycle,
whether or not we are in a RESET cycle and
the data bus values.

Line 53 we define the sync_string function

Lines 54-56: If the RESET variable has the letter R, we are in a reset loop and therefore return the word RESET.

Line 57 If the SYNC_VALUE variable has the letter S, we are in an opcode fetch cycle, therefore on the data bus we will have the opcode of the instruction we are going to execute.

On line 58, we create a case statement using the data from the data bus in the variable DATA. A case statement is an instruction that allows us to compare several constant values against a variable and return a different response depending on each value. In our case, we will return the name of the executed instruction using its opcode as input.

Line 59 for example we run case so that if the variable data has the hexadecimal values 0x00 it returns the string that represents the instruction BREAK in this case BRK.

Lines 61 to 300 we continue analyzing the data variable to see different instructions.

Lines 301-302 create the default case in case we don't find the data value in any of our cases

Line 305 we end the IF by returning an empty string if we were not in a SYNC loop

Finding out which chip we are communicating with

Our 20c has different chips such as ROM, RAM, and I/O chips. To allow the processor to communicate with each of them, we will use a different address on the ADDRESS BUS. The function find_chip It returns a string with the chip name depending on which address we are using.

Line 310 defines the find chip function accepting all bits of the address bus as a parameter

Line 311-312 if the address is greater than 0x8000 returns that it is the ROM chip

Line 313-314 if the address is greater than 0x0100 and less than 0x0200 returns that it is the STACK a special area of memory.

Line 315-316 if the address is greater than 0x0000 and less than 0x4000 returns that it is the RAM chip.

Line 317-318 if the address is greater than 0x6000 and less than 0x7000 returns that it is the I/O chip VIA1.

Line 319-320 if the address is greater than 0x7000 and less than 0x8000 returns that it is the VIA2 I/O chip.

Line 321-322 if the number is different from those indicated above returns that it does not know the chip.

Default Loop

Lines 326 to 327 generate the default Arduino loop function but empty, since we do not use it because we read based on the interrupts generated by pin 2 with the timing of the CLOCK.

Example of output

Here we can observe

16 binary numbers representing the ADDRESS BUS, ordered from A15 to A0
8 binary numbers representing the DATA BUS, ordered from D7 to D0
4 numbers in hexadecimal representing the ADDRESS BUS.
1 character representing a reading like “r” or a writing like the letter “W”
1 character representing an opfetch cycle as “S” or a data cycle as the letter “n”
2 hexadecimal numbers representing the DATA BUS.
5 characters representing which chip we are addressing
10 characters explaining which instruction we are looking for from the data bus in case SYNC is +5v (S in our output)

DUINO PROTOCOL ANALYZER 20c Board Circuit

The following diagram shows the circuit that explains the operation of the DUINO PROTOCOL ANALYZER

The circuit has the following elements:

Pin HEADER PZ254

This pin header has 34 pins and we're going to use it to connect to the upper terminals of our Arduino Mega.

Pin HEADER H12,H16 y H18

These are 3 pin headers of 8 pins that will serve to terminate the connections to our Arduino Mega and give it structural support when we connect to it.

Pin HEADER H3,H13

These are two 16-pin headers that will allow us to connect to the ADDRESS BUS and the EXPANSION BUS

Pin HEADER H1

An 8-pin header that will allow us to connect to the DATA BUS

HEADERs H6 y H14 POWER y GROUND

These headers have two pins and are connected to the 5V and GROUND layers respectively. We have two of these connectors, one in each corner of the board.

SCREW HOLES

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

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 CLOCK connections will be connected by traces on the PCB

DUINO PROTOCOL ANALYZER 20c Board PCB

The following PCB diagram explains how the components and traces are arranged to connect our circuit. The PCB has four layers, with the top layer containing all the netlist connections made via traces, which are thin copper lines connecting the components like wires.

We have two special layers called 5V and GROUND where we will connect the power and ground connections. By using these connections on separate layers, we save many centimeters of traces that would otherwise be connected to pins with the 5V and GROUND voltages, and we can connect these pins directly to the corresponding layer.

LAYER 5V

LAYER GROUND

Another advantage of having an entire layer for GROUND is being able to isolate electrical noise from the connections between components.

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 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 or Altium Designer software.

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

Gerber_v03_PROTOCOL_ANALYZER_DUINO_4Plane_2025-04-02.zip This file contains all the plans needed to generate our PCB board.

BOM_v03_PROTOCOL_ANALYZER_DUINO_4Plane_v03_PROTOCOL_ANALYZER_DUINO_4Plane_2025-04-02.xls It contains all the components of our board and the manufacturer's code that identifies that component.

PickAndPlace_v03_PROTOCOL_ANALYZER_DUINO_4Plane_2025-04-02.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_duino_pa_front.png

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

3DModel_duino_on_back.png

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

Altium_Circuit_1_v03_02_PROTOCOL_ANALYZER_DUINO_4Plane.schdoc

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

Altium_PCB_v03_02_PROTOCOL_ANALYZER_DUINO_4Plane.pcbdoc

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

PCB_v03_PROTOCOL_ANALYZER_DUINO_4Plane_2025-04-02.pdf

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

ProDoc_v03_02_PROTOCOL_ANALYZER_DUINO_4Plane_2025-05-19.epro

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

SCH_v03_PROTOCOL_ANALYZER_DUINO_4Plane_2025-04-02.pdf

It is a PDF with the logic circuits of the board

Preparation of the DUINO PROTOCOL ANALYZER Plate

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 plate.

Clean the plate with isopropyl alcohol

Connect the Arduino Mega to the DUINO PROTOCOL ANALYZER Board

Properly align the pins of the DUINO PA with the sockets of the arduino Mega

Connect the cable USB 2.0 Type A, which will go to our computer on the Arduino Mega

Connect to the top of one of the 20c boards

DUINO PROTOCOL ANALYZER 20c Board Connection Guide

We'll explain how to connect the various components of the board to get it ready to use in a model. This is a configuration with all the boards we'll be using, even though we haven't seen them all yet. You can use this section as a reference when you assemble the entire 20c.

DUINO PROTOCOL ANALYZER

To configure the DUINO PROTOCOL ANALYZER board, we will make the following connections.

We connect the Arduino Mega to the internal pins of the DUINO PROTOCOL ANALYZER.

We connected a USB 2.0 type A cable to the Arduino Mega

We connected the same cable to our notebook.

Connect the BUS pins of the DUINO PA board to the top of one of the boards we use in our model.

Experiment - Testing the DUINO PROTOCOL ANALYZER with the RESET Process and the NOP Instruction

We will repeat this experiment, testing our DUINO PROTOCOL ANALYZER, but this time showing in much detail when a Reset is performed and how the NOP instruction is executed.

We reviewed what the NOP instruction configuration looks like and the basis of the experiment.

We are going to tell Mano to our CPU 6502 to execute the no-operation instruction NOP, which is coded as EA in the 6502 machine language instructions.

EA translates to 1110 1010 in binary, and this is what our processor will expect on its data pins to read that instruction. To do this, we will connect 8 resistors to our data pins as follows:

Here we can see our DUINO board connected to a USB cable leading to our LAPTOP, the 6502 CPU board, the CLOCK board, and a BREADBOARD with the EA instruction wired in.

We will upload the 001_Arduino_DUINO_PA program to our Arduino Mega and then open the Serial Monitor.

If we run a reset sequence by pressing the RESET button on the CPU 6502 board and observe the result, we'll see how it executes the reset in 7 clock cycles and searches memory locations FFFC and FFFD for the vector (another memory location) containing the first instruction to be executed. It takes 7 cycles because RESET is simply a BRK or BREAK instruction loaded by hardware through the RESET pin.

The reset must be held at 0v for at least two clock cycles to be recognized.

Reset followed by reading NOP instructions

We connect the CLK pin of the header CLOCK_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.

Analysis of the buses

We will use the script 001_Arduino_DUINO_PA and analyze the output of our experiment.

Let's review the OUTPUT

Here we can observe:

16 binary numbers representing the ADDRESS BUS, ordered from A15 to A0
8 binary numbers representing the DATA BUS, ordered from D7 to D0
4 numbers in hexadecimal representing the ADDRESS BUS.
1 character representing a reading like “r” or a writing like the letter “W”
1 character representing an opfetch cycle as “S” or a data cycle as the letter “n”
2 hexadecimal numbers representing the DATA BUS.
5 characters representing which chip we are addressing
10 characters explaining which instruction we are looking for from the data bus in case SYNC is +5v (S in our output)

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.

Since we have the data bus wired, we will always receive 11101010, which is the hexadecimal equivalent of EA. That's why, when reading it twice, the program counter will point to the address EAEA.

The next instruction read from the data bus is the instruction EA, which means NOP (no operation). We know it is an operation code because the SYNC flag S is set on our expansion bus, signifying an opfetch cycle.

This operation takes two clock cycles to execute, that's why we can see address pairs EAEB, EAEB, EAEC, EAEC, etc.

Each time the instruction is executed and two cycles pass, the program counter is incremented by one, as we can see in EAEB, EAEC, EAED, etc.

The execution cycle of the first instruction is as follows:

EAEA 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 place EAEB in the address bus.
It finishes executing the NOP instruction (cycle 2 of 2) and fetches the next instruction from the next EAEB address on the address bus. It increments the program counter.

And so it continues.

We can also see that it indicates the ROM chip is being used, but in reality, we don't have a ROM chip! This is because our program interprets that whenever pin A15 is 1 or +5V, we are communicating with the ROM chip.

This will be very useful when we analyze the ROM chip in a future episode.

Conclusions

The DUINO PROTOCOL ANALYZER board will allow us to use an Arduino Mega as if it were a Protocol Analyzer, being able to see the content of each bus and the interpretation of its operation by translating the instructions.

The DUINO PROTOCOL ANALYZER board in operation

To see visually how to connect the DUINO PROTOCOL ANALYZER board to the 20c, I've included a detailed video from the series, as always. In this video, we'll see how to connect the pins, and our experiment will be visually demonstrated.

https://youtu.be/kvjKdjx_K9g

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