New Parts

• 1 10kΩ resistor.

• 1 0.1μF capacitor. Tantalum, like the ones we used to bypass the power supply on the ATmega and the oscillator in chapter 2, and the 74xx00 that is our logic probe in chapter 7. Ceramic disk caps will work, but tantalums are easier to find room for.

New or Used Parts

• One Z80 CPU. Sadly, not all Z80s will work. The oldest types, the NMOS types, won’t accept a clock as slow as the one we’ll be giving it. “Modern” Z80s in the Z8400 or Z84C00 series will do just fine.

• There’s some question where the NEC clone, the μPD780 will. Its datasheet says it is effectively a static design, meaning it will accept a clock with a speed of zero, but that below a few hundred kHz is not guaranteed. I have one of these, and I think I developed the original prototype of this project with it, but as my μPD780 has since died, all I can say now is look up your specific IC’s datasheet online, and look in the AC characteristics. If, as the Z8400/Z84C00 models from Zilog do, it lists no upper limit to the clock period, this means it will accept a static clock. They’ll often mention a fully static design in the datasheet as well. You can also just plug your Z80 in and see if it works. It’s junk, right?

• If you’re ordering a new one (which might be the safest approach) any of the Zilog Z84C00 family, like the 20MHz Z84C0020, I used) will work. They differ only in their maximum clock frequency. As always, make sure it is the 40 pin through-hole DIP version, as the Z80 has been around a long time and comes in a lot of other packages.

• A tactile button. As with Chapter 10, this button needs to be a momentary switch, normally off. After that, use whatever button you like. Be advised that some tactile buttons (like mine) don’t like to stay in the breadboard, and that they may switch adjacent terminals rather than opposite terminals like you’d expect. If they really give you trouble, you can solder them to a piece of protoboard, add some pin headers, make some connections, and use the pin headers to connect the switches to your breadboard. If there were any projects in this book after this one, I’d probably do that .

Busses

We’ll start with the busses. There are four of them in the Z80, three of which have direct connections to the outside world.

Registers

Registers are memory, if you like, inside the CPU. You can also think of them as variables.

We’ve talked about registers before discussing the port registers of the ATmega, and these registers are very much in that same vein. Most hold one byte each. Some are paired and can be used with their pair-mate as a sixteen bit register, or as two eight bit registers. Some, as they are primarily for holding memory addresses, must be used as sixteen bit registers. Some are modified automatically by the CPU as the ATmega’s port registers are, and some are just a place to put data. Registers are at the heart of programming.

The ALU

The Z80’s Arithmetic/Logic Unit (ALU) is a pretty limited beast. It can Add, Subtract, AND, OR, XOR, Compare, Increment and Decrement integers. That’s it. Need multiplication and division? Write a program that does that. Need floating point math? Write a program that does that. Do you pay a huge penalty in performance using software instead of the ALU’s built-in functions? Yes, absolutely. Zilog actually fixed the multiplication/division problem with the Z180, and while they, like their older Z80 brethren are cheap and plentiful, they aren’t available in quantities of less than 120 in DIP format. If you were building a Z80-based system today, there are floating point units based on programmable DSPs, such as the Micromega uM-FPU64. You might also be able to use such an FPU for fast integer multiplication and division, although it would be worth figuring out whether the extra steps of communicating with these devices over SPI, I²c, or UART (TTL level RS232) would be slower than having the Z80 multiply by adding over and over again.

The ALU of the Z80 breaks its operations into two groups: 8 bit math and 16 bit math.

Instruction Decoding and Control Logic

In order to do its job, the Z80 has to take instructions in and carry them out. If you wondered previously how it gets from ADD A,0x12 to actually doing that, you’ve already seen part of the answer.

The Z80 doesn’t know anything about ADD A, 0x12. Add A is a mnemonic for humans. In fact, when Zilog first knocked the Z80’s instruction set off from Intel’s 8080, the first thing they did was change all the mnemonics to escape Intel’s copyright. The two CPUs remained compatible, however, because the opcodes didn’t change.

You’ve already seen some opcodes. You’ve built some, if you followed along as we talked about the ALU and its instructions. There are lots more, and no, I’m not going to get into them all. They’re all in the Z80’s mostly excellent datasheet, although as we’ve seen some construction is required for a lot of them.

Opcodes are what the CPU does understand. It may not know anything about ADD A,0x12 but put 0xC6 in a location in memory and 0x12 in the next location down, and the Z80 knows exactly what to do.

Unless told otherwise, the Z80 assumes anything it comes across in memory is an instruction. So when it hits 0xC6, the instruction decoder looks up that number, reads in the next value for data (0x12). The control logic connects the accumulator to the ALU, and passes 0x12 on the internal bus to the ALU, then triggers the ALU’s add function. That’s how it happens. It sounds like calling functions from what amounts to a menu because it is very much like calling functions from a menu. CPUs are like programs, as I said .

Putting It All Together: Operations

Let’s walk through an entire instruction cycle on the Z80, soup to nuts, so we know how the thing works. This is discussed at some length in the datasheet, so some terms need defining.

A clock cycle or T (time) cycle is one full cycle of the clock, that is, one positive pulse, and one zero pulse.

A machine cycle is a section of the instruction cycle, a given phase of the work to be done. Each machine cycle can take from three to six clock (T) cycles.

An instruction cycle is the entire process from the time an instruction is read in as an opcode until the time the CPU is ready for the next opcode.

We’ll look at an LD A, load the Accumulator, with a value of 0x10.

LD r,n is one of those opcodes like ADD A,r that we have to construct. We look up the opcode skeleton and find it’s 0b00___110. We look up the Accumulator’s object code, and it’s 0b111 Put the two together and we have 0b00111110, or 0x3E. So our instruction and data, one after the other, will be 0x3E, 0x10.

The first step of an instruction cycle is to read the the opcode from memory. The CPU puts the Program Counter’s value onto the memory bus, pulls /MREQ low, pulls /RD low, and pulls /M1 low.

/MREQ and /RD tell the memory system it’s needed, that there is a valid address on its address bus, and that it will be read rather than written to. /M1 tells the system this is an instruction fetch, machine cycle 1, the start of an instruction cycle. The CPU stays in this state for three clock (T) cycles while it waits for the value on its data lines to settle. The opcode is read during the third clock (T) cycle. The CPU has taken up 0x3E. It will spend clock cycles 4, 5, and 6 decoding the instruction and, presumably, the control logic will spend that time moving data on the internal bus and connecting the right sections of the CPU together to actually carry out the instruction.

Meanwhile, for the rest of the M1 cycle, /M1 is high, /RD is high, and /MREQ goes high briefly (for one clock cycle) then goes low again, along with the /RFSH signal, to tell memory that not only are we not using it presently, but to go refresh the row at the bottom of the memory address bus. If needed. Be thankful we’re not dealing with DRAM in this project.

Note that the M1 cycle, like all machine cycles, can be stretched if the /WAIT signal is low. This is so that slow memory (like what we’ll be using) has time to do its job before the CPU starts asking for another address.

The LD r,n instruction is listed as requiring two M cycles. One to fetch the instruction, one to read the data from memory, so we have another M cycle to go through. Since we’re reading data, this will be a memory read cycle .

The control logic is set by the decoded instruction, 0x3E, to increment the Program Counter (PC) so the next value can be read as data and not as an opcode later. As with the opcode fetch cycle, the memory read cycle begins with the memory address being set on the address bus, /MREQ going low, and /RD going low. /M1 does not go low, since this is the M2 cycle.

/MREQ and /RD stay low for the second half of the first clock cycle, all the way through the second, and halfway through the third. The data from the memory bus is actually read roughly at the start of the third clock cycle. Like the opcode fetch M1 cycle, the memory read cycle can be lengthened by pulling the /WAIT signal low.

The CPU now has the data it needs. The /MREQ and /RD signals go high, and no refresh activity happens.

The control logic has set the multiplexor so it’s looking at the correct register (A, the accumulator) and it has data on the internal data bus to put there, so the value 0x10 is set in the accumulator.

And we’re done.

LD A,n is a pretty simple instruction. There can be a lot of other M cycles involved: interrupt cycles, bus arbitration cycles, resets, and so on, but you can see from this example how things are broken down, how the opcode gets read and executed, and what happens behind the curtain.

Install the Z80

Like the ATmega1284P, the Z80 is a 40 pin DIP IC, so I recommend installing it starting with its pin 1 on line 11 of your breadboard, oriented the same way as the ATmega. It makes for a neater looking breadboard and keeps the connecting wires shorter. For high speed signals, shorter is better.

Power Circuits

First, in case you haven’t been doing this all along, unplug the Cestino from USB power.

Wire the Z80’s pin 11 (the pins on the schematic in Figure 11-2 are not in order) and pin 29 to the + and - busses, respectively, then wire the 0.1μF capacitor from pin 11 to the - bus. Nothing you haven’t seen here before. We’re giving the Z80 a bypass cap of its own to keep noise out of its power supply.

Data Bus

Let’s go ahead and wire up the data bus first. Why? Because all the data bus pins are on the left side of the Z80 as we’ve mounted it, and they all connect to port C, which is on the bottom right of the ATmega. This means that our data bus wires will be under many of the control bus wires, so its easiest to do them now .

The data bus pins are, sadly, all over the left side of the Z80 and not in any particular order. In signal order, that is, D0-D7, they are Z80 pins 14, 15, 12, 8, 7, 9, 10, 13. Wire these pins to ATmega port C, from PC0 (ATmega pin 22) to PC7 (ATmega pin 29) in that order. As usual, I hanked these wires up once I had them in place .

Control Bus

The Z80 has a lot of control signals. Of these, we use six, so let’s start by connecting the input signals we’re not using to the + bus to keep them out of trouble. Connect pins 17 and 25 on the Z80 to the + bus. These are /NMI, nonmaskable interrupt (Z80 pin 17), and /BUSRQ which requests the Z80 stop talking to the memory bus so other devices can talk to it. (Z80 pin 25).

Memory Address Bus

One more bus to go. This, by now, is standard stuff for us. Divide the 16 bit memory address bus into an 8 bit LSB and MSB, and wire each of those into the corresponding pins of an ATmega port.

Starting with the Least Significant Bits, wire A0-A7 on the Z80 (pins 30-37 in order) to PA0-PA7 on the ATmega (pins 40-33, in that order). It’s nice when pins and their signals come in order like this. It doesn’t happen most of the time.

For the MSB, we’ll need pins A8-15 on the Z80. These are, in order, 38, 39, 40, 1, 2, 3, 4, and 5. Wire these to PB0-PB7, pins 1-8 in that order, on the ATmega.

That’s it. That’s all the wiring there is. I suggest hanking the memory address bus lines in two groups, one for each port on the ATmega. That’s how I did it.

The Plan

This sketch has nine menu options divided into three groups.

We can reset the Z80, set the clock speed, and stop the clock in the Z80 Commands group.

We can hook the Free Run ISR up, or disconnect it in the Free Run ISR Commands Group.

The Memory Simulation and Z80 Programming group is the big one, where we can set up simulated memory, enter programs into it, run programs by attaching the mem_sim_ISRs, and dump the simulated memory to the Serial Monitor.

The Code

So that’s the plan. Let’s get started. As usual, we begin with preprocessor defines.

#define MAX_CLOCK 20000000
#define MEM_SIZE 0x2000 // 8192 Bytes
#define RESET_MS 5000 // Z80 reset: hold /RESET low this long.

String repeat(int number, char character);
String get_input_string();
uint32_t string2uint32_t(String input);
uint16_t hex_string2uint16_t(String input);
void menu();

class cpu {                                                      

  private:
    uint8_t saved_control_port = CTRL_DEFAULT;

    const uint8_t M1_MASK = 0b00010000; //Read the /M1 signal
    const uint8_t RESET = 0b10111111; // Set the /RESET signal
    const uint8_t WAIT = 0b01111111; // Set the /WAIT signal
    const uint8_t CTRL_DEFAULT = 0b11000000; // default Z80 state

    volatile uint8_t& CONTROL_PORT = PORTD;
    volatile uint8_t& CONTROL_PINS = PIND;
    volatile uint8_t& DATA_PORT = PORTC;
    volatile uint8_t& DATA_DDR = DDRC;
    volatile uint8_t& DATA_PINS = PINC;

  public:
    cpu() { // constructor
      Serial.println("CPU: Object created.");
      DDRA = 0b00000000; // Address LSB
      DDRB = 0b00000000; // Address MSB
      DDRC = 0b11111111; // Data Port;
      DDRD = 0b11100000; // control_port
      DATA_PORT = 0b00000000;
      CONTROL_PORT = CTRL_DEFAULT;
    }

    boolean M1() {
      return (CONTROL_PINS & M1_MASK);
    }

    void mode_default() {
      CONTROL_PORT = CTRL_DEFAULT;
    }
    void mode_wait() {
      CONTROL_PORT = CONTROL_PORT & WAIT;
    }
    void save_mode() {                                                                                              
      saved_control_port = CONTROL_PORT;
    }
    void restore_mode() {
      CONTROL_PORT = saved_control_port;
    }

    volatile uint8_t& addr_msb = PINB;
    volatile uint8_t& addr_lsb = PINA;

    uint8_t data_out() {
      DATA_DDR = 0b00000000;
      return DATA_PINS;
    }
    void data_in(uint8_t data) {
      DATA_DDR = 0b11111111;
      DATA_PORT = data;
    }

    void reset(void) {
      Serial.println("CPU: Resetting...");
      CONTROL_PORT = CONTROL_PORT & RESET;
      delay(RESET_MS);
      Serial.println("CPU: Done Resetting.");
      CONTROL_PORT = CTRL_DEFAULT;
    }

Here's the end of the cpu class.
};

class clock_gen {
  private:
    int prescale_values[5] = {1024, 256, 64, 8, 1};
    int prescale_bits[5] = {0b101, 0b100, 0b011, 0b010, 0b001};

  public:
    // Destructor
    ∼clock_gen() {
      TCCR1A = 0;
      TCCR1B = 0;                                                                                              
      OCR1A = 0;
      TCNT1 = 0;
      Serial.println("Clock Generator: Object Deleted.");
    }

    // Constructor
    clock_gen(uint32_t desired_frequency) {
      Serial.println("Clock: Object Created.");
      float counter_value = MAX_CLOCK / desired_frequency;
      float lowest_inaccuracy = 1.0;
      float current_steps = 0;
      int prescaler = 1;
      byte prescaler_config_bits;
      long int match;                                                                                              

      for (int c = 0; c <= 4; c++) {
        current_steps = counter_value / prescale_values[c];
        if ((current_steps - round(current_steps) < lowest_inaccuracy)
            && (current_steps <= 65535)) {
          lowest_inaccuracy = current_steps - ((int)current_steps);
          prescaler = prescale_values[c];
          match = round(current_steps);
          prescaler_config_bits = prescale_bits[c];
          if (match == 0) match = round(counter_value);
        }
      }

      Serial.print("We want to count to ");
      Serial.println(counter_value, 2);
      Serial.print("For a clock speed of ");
      Serial.println(desired_frequency, DEC);
      Serial.print("I chose a prescaler of ");
      Serial.println(prescaler, DEC);
      Serial.print("And a match of ");
      Serial.println(match, DEC);
      Serial.print("We'll count to ");                                                                                              
      Serial.println((long int)prescaler * match, DEC);

      TCCR1A = 0b01000000;
      TCCR1B = (0b00001000 | prescaler_config_bits);
      TCNT1 = 0;
      OCR1A = match;
      Serial.println("Clock Generator: Running");
    }
So ends the clock_gen class.
};

class memory_simulator {

  private:
    volatile uint8_t halt = 0x76;
    volatile uint8_t mem_array[MEM_SIZE];

    void dump_page_header() {
      Serial.println("
Address	 0  1  2  3  4  5  6  7  8  9" +
                     String("  a  b  c  d  e  f   Data (text)"));
      Serial.println(repeat(75, '-'));
    }
    void m_edit_instructions() {
      Serial.println("
	*** Mem-Sim Line Editor ***");
      Serial.print("Enter an address and data in HEX ");
      Serial.println("eg: 0x0000,0x76");
      Serial.println(""exit" to quit
"dump" to view memory
");
    }

  public:
    volatile boolean m_write_enable = true;

    memory_simulator() { // constructor
      Serial.println("Memory: Initializing...");
      for (int c = 0; c < MEM_SIZE; c++) {
        mem_array[c] = 0;
      }

      Serial.println("Memory: " + String(MEM_SIZE, DEC) + 
                     " (0x" + String(MEM_SIZE, HEX) + ") bytes free.");
    }                                                                                                      

    volatile uint8_t m_seek_read(volatile uint8_t address_msb, volatile uint8_t address_lsb) {

      volatile union {
        volatile uint16_t sixteen_bit_address;
        volatile uint8_t byte_array[2];
      } addr_byte_union;
      addr_byte_union.byte_array[0] = address_lsb;
      addr_byte_union.byte_array[1] = address_msb;

      if (addr_byte_union.sixteen_bit_address >= MEM_SIZE) {
        return halt;                                                                                              
      } else {
        return mem_array[addr_byte_union.sixteen_bit_address];
      }
    }

    void m_seek_write(volatile uint8_t address_msb, volatile uint8_t address_lsb, volatile uint8_t data) {
      if (m_write_enable) {
        volatile union {
          volatile uint16_t sixteen_bit_address;
          volatile uint8_t byte_array[2];
        } addr_byte_union;
        addr_byte_union.byte_array[0] = address_lsb;
        addr_byte_union.byte_array[1] = address_msb;
        if (addr_byte_union.sixteen_bit_address >= MEM_SIZE) {
        } else {
          mem_array[addr_byte_union.sixteen_bit_address] = data;
        }
      }
    }                                                                                              

    void m_dump() {
      Serial.println("Dumping Simulated Memory");
      int c = 0;
      String line_start_address = "0x";
      uint16_t row_address = 0;
      String hex_data = "";
      String human_readable_data = "";

      dump_page_header();
      for (int row = 0; row < (MEM_SIZE / 16); row++) {
        row_address = 16 * row;
        if (row_address < 0x1000)line_start_address += "0";
        if (row_address < 0x0100)line_start_address += "0";
        if (row_address < 0x0010)line_start_address += "0";
        line_start_address += String(row_address, HEX) + "|";

        for (int col = 0; col < 16; col++) {
          if (mem_array[c] < 0x10) hex_data += "0";

          hex_data += String(mem_array[c], HEX);
          hex_data += " ";

          if (isprint(mem_array[c])) {
            human_readable_data += (char)mem_array[c];
          } else {
            human_readable_data += ".";
          }

          c++;
        }
        Serial.println(line_start_address + " " + hex_data + 
                       " | " + human_readable_data);
        hex_data = "";
        human_readable_data = "";
        line_start_address = "0x";

        if (!(c % 256)) {
          Serial.println("Continue (y/n)");
          if (get_input_string() == "n") {
            row = MEM_SIZE / 16;
          } else {
            dump_page_header();
          }
        }
      }                                                                                                      
    }

    void m_edit() {
      String input_string = "y";
      uint16_t address;
      uint8_t  data;
      int comma_index = 0;
      String temp;

      m_edit_instructions();
      do {// repeat loop until the 'while' is satisfied.
        input_string = get_input_string();

        if (input_string == "dump") {
          m_dump();
          m_edit_instructions();                                                                                              
        }

        if (input_string.startsWith("0x", 0)) {
          comma_index = input_string.indexOf(",");

          temp = input_string.substring(0, comma_index);
          temp.trim();

          address = hex_string2uint16_t(temp);

          temp = input_string.substring(comma_index + 1);
          temp.trim();
          data = (uint8_t)hex_string2uint16_t(temp);

          Serial.println(">  Addr: 0x" + String(address, HEX) + 
                         " Data: 0x" + String(data, HEX) + " [OK]");

          mem_array[address] = data;
        }

      } while (input_string != "exit");
    }
};                                                                                              

clock_gen* ourclock = NULL;
memory_simulator* mem_sim = NULL;
cpu Z80;

String repeat(int number, char character) {
  String temp = "";
  for (int c = 0; c < number; c++) {
    temp = temp + String(character);
  }
  return temp;()                                                                                                              
}

String get_input_string() {
  while (!Serial.available()) {
  }
  return (Serial.readString());
}

uint32_t string2uint32_t(String input) {
  uint32_t temp = 0;
  input.trim();
  for (int c = 0; c < input.length(); c++) {
    temp = temp * 10 + input.charAt(c) - '0';
  }
  return temp;()                                                                                                              
}

uint16_t hex_string2uint16_t(String input) {
  uint16_t temp = 0;
  char tempchar;
  input.trim();
  for (int c = 2; c < input.length(); c++) {
    temp = (temp * 0x10);

    tempchar = input.charAt(c);
    if (tempchar < ':') temp += (tempchar - '0');

    if ((tempchar > '@') && (tempchar < 'G')) temp += (tempchar - '7');

    if ((tempchar > '`') && (tempchar < 'g')) temp += (tempchar - 'W');
  }

  return temp;()                                                                                                                        

}

void menu() {
  String input_string = "";
  Serial.println("
" + repeat(15, ' ') + "*** Menu ***");
  Serial.println(repeat(42, '-'));
  Serial.println("Z80 Operations Commands");
  Serial.println(repeat(42, '-'));
  Serial.println("(1) Reset Z80");
  Serial.println("(2) Set Clock Speed");
  Serial.println("(3) Stop Clock");
  Serial.println(repeat(42, '-'));
  Serial.println("Free Run ISR Commands");
  Serial.println(repeat(42, '-'));
  Serial.println("(4) Attach Free Run ISR to INT1");
  Serial.println("(5) Detach Free Run ISR from INT1");
  Serial.println(repeat(42, '-'));
  Serial.println("Memory Simulation and Z80 Programming");
  Serial.println(repeat(42, '-'));
  Serial.println("(6) Initialize Simulated Memory");
  Serial.println("(7) Enter Program Into Simulated Memory");
  Serial.println("(8) Run Program (Attach Mem_Sim ISRs)");
  Serial.println("(9) Dump Simulated Memory");
  Serial.println(repeat(42, '-'));

  Serial.print("Clock is ");
  if (ourclock != NULL) {
    Serial.println("Running.");
  } else {
    Serial.println("Stopped.");
  }
  Serial.print("Memory is ");
  if (mem_sim != NULL) {
    Serial.println("Available.");
  } else {
    Serial.println("Not Available.");
  }
  Serial.println(repeat(42, '-'));

  switch ((int)string2uint32_t(get_input_string())) {
    case 1: Z80.reset();
      break;

    case 2:
      Serial.println("Menu: Enter Z80 Clock Speed (1 - 20000000Hz)");
      input_string = get_input_string();
      delete ourclock;
      ourclock = NULL; // clear the pointer. Otherwise things get confused.
      ourclock = new clock_gen(string2uint32_t(input_string));

      mem_sim->m_write_enable=false;
      Z80.reset();
      mem_sim->m_write_enable=true;
      break;

    case 3:
      delete ourclock;
      ourclock = NULL; // Clear the pointer, otherwise things get confused.
      break;()                                                                                                                        

    case 4:
      Serial.println("Menu: Attaching free_run_ISR to INT1");
      noInterrupts();
      detachInterrupt(1);
      attachInterrupt(1, free_run_ISR, FALLING);
      interrupts();
      Z80.reset();
      break;

    case 5:
      Serial.println("Menu: Detatching free_run_ISR from INT1");
      noInterrupts();
      detachInterrupt(1);
      interrupts();
      Z80.reset();
      break;

    case 6:
      delete mem_sim;
      mem_sim = NULL;
      mem_sim = new memory_simulator();
      break;()                                                                                                                        

    case 7:
      mem_sim->m_edit();
      break;

    case 8:
      Serial.println("Menu: Attaching mem_read_ISR to INT1.");
      Serial.println("Menu: Attaching mem_write_ISR to INT0.");
      Serial.println("Menu: Any program therein should run.");
      noInterrupts();
      detachInterrupt(1);
      detachInterrupt(0);
      mem_sim->m_write_enable=false;
      attachInterrupt(1, mem_read_ISR, FALLING);
      attachInterrupt(0, mem_write_ISR, FALLING);
      mem_sim->m_write_enable=true;
      interrupts();
      Z80.reset();
      break;

    case 9:
      mem_sim->m_dump();
      break;

  } // end of case.
} // end of menu function()                                                                                                              .

void free_run_ISR() {
  byte temp;
  String output = "";
  Z80.save_mode();

  Z80.mode_wait();
  Z80.data_in(0x0);

  output += String("free_run_ISR: Address: 0x");
  if (Z80.addr_msb < 0x10) output += String("0");
  output = output + String(Z80.addr_msb, HEX);
  if (Z80.addr_lsb < 0x10) output += String("0");
  output += String(Z80.addr_lsb, HEX);
  Serial.println(output);

  Z80.restore_mode();
}

void mem_read_ISR() {
  uint8_t tempdata = 0;
  String output = "";

  Z80.save_mode();

  Z80.mode_wait();

  tempdata = mem_sim->m_seek_read(Z80.addr_msb, Z80.addr_lsb);

  if (!Z80.M1()) {
    output += String("mem_read_ISR: Z80 Fetched Address: 0x");
  } else {
    output += String("mem_read_ISR: Z80 Read Address: 0x");
  }                                                                                                                                        

  Z80.data_in(tempdata);
  if (Z80.addr_msb < 0x10) output += String("0");
  output += String(Z80.addr_msb, HEX);
  if (Z80.addr_lsb < 0x10) output += String("0");
  output += String(Z80.addr_lsb, HEX);
  output += String("	Data: 0x");
  if (tempdata < 0x10) output += String("0");
  output += String(tempdata, HEX);
  Serial.println(output);
  Z80.restore_mode();
}

void mem_write_ISR() {
  String output = "";
  uint8_t tempdata = 0;

  Z80.save_mode();
  Z80.mode_wait();

  tempdata = Z80.data_out();
  mem_sim->m_seek_write(Z80.addr_msb, Z80.addr_lsb, tempdata);
  output += String("mem_write_ISR: Z80 Wrote Address: 0x");

  if (Z80.addr_msb < 0x10) output += String("0");
  output += String(Z80.addr_msb, HEX);
  if (Z80.addr_lsb < 0x10) output += String("0");
  output += String(Z80.addr_lsb, HEX);
  output += String("	Data: 0x");
  if (tempdata < 0x10) output += String("0");
  output += String(tempdata, HEX);

  Serial.println(output);
 Z80.restore_mode();
}

void setup() {
  Serial.begin(115200);
}

void loop() {
  menu();                                                                                                                                        
}

The Full Code

// Hardware
//-----------------------------------------------------------
// Z80 Signals Connected to ATmega1284P Port D:
//--------------------------------------------
// Signal: /WAIT /RESET /CLK       /M1 /RD /WR (-) (-)
// class: cpu    cpu    clock_gen  cpu cpu cpu (serial)
//
// All Other Z80 Signals
//----------------------
// /MREQ /IORQ /RFSH /HALT /INT   /NMI /BUSRQ
// n/c   n/c   n/c   n/c   button n/c  n/c
//-----------------------------------------------------------
// Z80 Address + Busses
// Signal:      A0-A7   A8-A15 D0-D7
// ATmega Port: PORTA   PORTB  PORTC
// Class:       cpu     cpu    cpu
//-----------------------------------------------------------

//-----------------------------------------------------------
// Preprocessor #defines
//-----------------------------------------------------------
#define MAX_CLOCK 20000000 // Maximum clock speed
#define MEM_SIZE 0x2000 // 8192 Bytes
#define RESET_MS 5000 // Z80 reset: hold /RESET low this long.

//-----------------------------------------------------------
// Function Prototypes
// Since some member functions of our classes call utility
// functions, it behooves us to declare function prototypes.
// Arduino 1.6.5 does this for us, but 1.6.7 seems to break
// that behavior.
//-----------------------------------------------------------
String repeat(int number, char character);
String get_input_string();
uint32_t string2uint32_t(String input);
uint16_t hex_string2uint16_t(String input);
void menu();                                                                              

//-----------------------------------------------------------
// Classes
//
// Since we're using software running on the ATmega1284P to
// simulate hardware, it makes sense to break the code up
// into objects along the same lines.
//-----------------------------------------------------------

//-----------------------------------------------------------
// cpu class:
//
// An object of this class reads and writes the various pins
// of PORT D to control the Z80, read its status signals,
// provide access to its address bus, and read from or write
// to its data bus.
//-----------------------------------------------------------
class cpu {
  private:
    // These are private variables, constants, and (potentially)
    // member functions. These can't be touched by code outside
    // this class.

    uint8_t saved_control_port = CTRL_DEFAULT;
    // We often need to preserve the state of the
    // control port before we change it, and we may not
    // know exactly what it is. It's stored in this private
    // variable.

    const uint8_t M1_MASK = 0b00010000; //Read the /M1 signal
    const uint8_t RESET = 0b10111111; // Set the /RESET signal
    const uint8_t WAIT = 0b01111111; // Set the /WAIT signal
    // These consts define various bit values we need to
    // set or read the named status signals of the Z80
    // with PORT D.

    const uint8_t CTRL_DEFAULT = 0b11000000; // default Z80 state
    // This is the default state for PORTD and by extension, the Z80.
    // Hold /WAIT and /RESET high. /CLK is under timer control.
    // /WR, /MREQ and /RD are all inputs from the ATmega's view.

    volatile uint8_t& CONTROL_PORT = PORTD;
    volatile uint8_t& CONTROL_PINS = PIND;
    // These are reference variables. They are run-time
    // aliases for PORTD and PIND. Note the & sign.
    // That denotes them as references. Note that they are private.                                                                              

    volatile uint8_t& DATA_PORT = PORTC;
    volatile uint8_t& DATA_DDR = DDRC;
    volatile uint8_t& DATA_PINS = PINC;
    // Reference variables for our data port, PORTC.  These
    // are private and strictly for programming convenience
    // within this class.

  public:
    cpu() { // constructor
      Serial.println("CPU: Object created.");
      DDRA = 0b00000000; // Address LSB
      DDRB = 0b00000000; // Address MSB
      DDRC = 0b11111111; // Data Port;
      DDRD = 0b11100000; // control_port
      // Initialize the DDRs for all ports. Since only PORTC
      // has a DDR reference varable, I'm using the register
      // names for everything for consistency.

      DATA_PORT = 0b00000000;
      CONTROL_PORT = CTRL_DEFAULT;
      // Initialize the values of DATA_PORT and CONTROL_PORT.
    }
    // This is the constructor of this class. It is called when
    // an object of this class is instantiated. The constructor
    // sets ports A and B up to read the low and high memory
    // address bytes, and port C up (initially) to write data
    // to the Z80, but this port can also read data sent from
    // the Z80 to the system.

    boolean M1() {

      return (CONTROL_PINS & M1_MASK);
    }
    // This function returns the status of the Z80's /M1 signal.
    // It does a logical AND of CONTROL_PINS and the M1_MASK.
    // If any pins in that AND turn up true, the function will
    // return true. Because all Z80 signals are active low,
    // this will mean /M1 is inactive.

    void mode_default() {
      CONTROL_PORT = CTRL_DEFAULT;
    }
    // Set the CONTROL_PORT to its default. Put the Z80 in
    // non-halted, non-waited mode.  Run mode, really.

    void mode_wait() {                                                                              
      CONTROL_PORT = CONTROL_PORT & WAIT;
    }
    // Lower the Z80's /WAIT signal so the Z80 will
    // not try and read until our ISRs are ready.
    // Even though the ATmega1284P is a universe
    // faster than we're running the Z80, our
    // memory is simulated in software. It's
    // really, really slow.

    void save_mode() {
      saved_control_port = CONTROL_PORT;
    }
    // Preserve the current value of CONTROL_PORT in the
    // private saved_control_port variable.

    void restore_mode() {
      CONTROL_PORT = saved_control_port;
    }
    // set CONTROL_PORT to the value in saved_control_port.
    // Note that we don't check that a save_mode was done
    // first, so use with caution.

    volatile uint8_t& addr_msb = PINB;
    volatile uint8_t& addr_lsb = PINA;
    // These two references give our sketch
    // a consistent name for the address bytes.
    // That way we can access them without
    // adding any more instructions.

    uint8_t data_out() {
      DATA_DDR = 0b00000000;
      return DATA_PINS;
    }
    // Set the DATA_PORT to read mode, and read the
    // Z80's data port for data coming FROM the Z80.
    // Return that data.
    // ATmega is READING. Z80 is WRITING.

    void data_in(uint8_t data) {
      DATA_DDR = 0b11111111;
      DATA_PORT = data;                                                                              
    }
    // Make sure the data port is in WRITE mode, and
    // set it to the value of data.
    // ATmega is WRITING, Z80 is READING.

    void reset(void) {
      Serial.println("CPU: Resetting...");
      CONTROL_PORT = CONTROL_PORT & RESET;
      delay(RESET_MS);
      Serial.println("CPU: Done Resetting.");
      CONTROL_PORT = CTRL_DEFAULT;
    }
    // Lower the Z80's /RESET signal for RESET_MS milliseconds.
    // In order to reset properly the Z80 needs its /reset
    // signal held low for multiple clock cycles. Given that
    // our clock's minimum speed is 1Hz, 5 seconds seems like
    // a safe value. This could be dynamic based on the clock
    // speed, but we're not in that much of a hurry.
};

//-----------------------------------------------------------
// clock_gen class
//
// This class configures timer/counter 1 to output a square
// wave signal on OCP1, from 1Hz to MAX_CLOCK MHz, depending
// on how we configure it. There are only two member functions,
// a constructor and the destructor. When an object in this
// class is instantiated, it's done with a text string
// parameter containing the text value the user wants
// the clock set to.
// The constructor handles the rest: generates the prescaler
// value and the match value, and tells the user what it's
// done. Note that because the Cestino has a 20MHz system
// clock, its maximum clock resolution is 50ns. Some
// speeds will be approximations since they don't divide
// evenly by 50ns.
//-----------------------------------------------------------
class clock_gen {
  private:
    int prescale_values[5] = {1024, 256, 64, 8, 1};
    int prescale_bits[5] = {0b101, 0b100, 0b011, 0b010, 0b001};
    // lookup tables for prescale bit fields and their values.

  public:
    // Destructor
    ∼clock_gen() {
      TCCR1A = 0;                                                                              
      TCCR1B = 0;
      OCR1A = 0;
      TCNT1 = 0;
      Serial.println("Clock Generator: Object Deleted.");
    }
    // The destructor is called when an object is deleted.
    // In this case, it clears all the timer registers, which
    // turns the timer off.

    // Constructor
    clock_gen(uint32_t desired_frequency) {
      Serial.println("Clock: Object Created.");
      float counter_value = MAX_CLOCK / desired_frequency;
      float lowest_inaccuracy = 1.0;
      float current_steps = 0;
      int prescaler = 1;
      byte prescaler_config_bits;
      long int match;

      for (int c = 0; c <= 4; c++) {
        current_steps = counter_value / prescale_values[c];
        if ((current_steps - round(current_steps) < lowest_inaccuracy)
            && (current_steps <= 65535)) {
          lowest_inaccuracy = current_steps - ((int)current_steps);
          prescaler = prescale_values[c];
          match = round(current_steps);
          prescaler_config_bits = prescale_bits[c];
          if (match == 0) match = round(counter_value);
        }
      }
      // Find the highest prescaler value that will both allow the
      // clock to generate the value the user wanted, with the
      // lowest inaccuracy of the resulting clock speed.
      // We do this by determining the number of steps the
      // maximum clock speed available (20MHz on the Cestino)
      // will occur for each step of our clock's output. Then we
      // iterrate from highest to lowest prescaler values to find the
      // one that divides most evenly into the number of steps.
      // We set our match value to the number of steps we want
      // divided by the prescaler.

      Serial.print("We want to count to ");
      Serial.println(counter_value, 2);                                                                              
      Serial.print("For a clock speed of ");
      Serial.println(desired_frequency, DEC);
      Serial.print("I chose a prescaler of ");
      Serial.println(prescaler, DEC);
      Serial.print("And a match of ");
      Serial.println(match, DEC);
      Serial.print("We'll count to ");
      Serial.println((long int)prescaler * match, DEC);
      // tell the user what values we generated.

      TCCR1A = 0b01000000;
      TCCR1B = (0b00001000 | prescaler_config_bits);
      TCNT1 = 0;
      OCR1A = match;
      Serial.println("Clock Generator: Running");
      // set the timer/counter registers.
    }
};

//-----------------------------------------------------------
// memory_simulator class
// This class contains the array we're using as simulated ram
// for the Z80, and functions to access it.
//-----------------------------------------------------------
class memory_simulator {
  private:
    volatile uint8_t halt = 0x76;
    volatile uint8_t mem_array[MEM_SIZE];
    // declare a variable to hold the halt instruction
    // for the Z80, and declare the array we're using
    // for simulated memory. These are private variables and
    // cannot be touched directly by outside code.

    void dump_page_header() {
      Serial.println("
Address	 0  1  2  3  4  5  6  7  8  9" +
                     String("  a  b  c  d  e  f   Data (text)"));
      Serial.println(repeat(75, '-'));
    }
    //Print the header for the dump pretty printer.

    void m_edit_instructions() {
      Serial.println("
	*** Mem-Sim Line Editor ***");
      Serial.print("Enter an address and data in HEX ");
      Serial.println("eg: 0x0000,0x76");
      Serial.println(""exit" to quit
"dump" to view memory
");
      // Print the handy instructions.
    }                                                                              

  public:
    volatile boolean m_write_enable = true;
    // If m_write_enable is false, m_seek_write() will say it
    // wrote, but it won't actually do it. A kludge used to
    // protect simulated memory during Z80 resets.

    memory_simulator() { // constructor
      Serial.println("Memory: Initializing...");
      for (int c = 0; c < MEM_SIZE; c++) {
        mem_array[c] = 0;
      }// Wipe the entire array. There's no telling what was
      // in that memory before we declared the array.

      Serial.println("Memory: " + String(MEM_SIZE, DEC) + 
                     " (0x" + String(MEM_SIZE, HEX) + ") bytes free.");
    }
    // tell the user how much memory we have.

    // The constructor of memory_simulator wipes the memory
    // array, which is declared on instantiation.after that,
    // it reports the available RAM to the user. We use the
    // default destructor, since we don't do anything special
    // there.

    volatile uint8_t m_seek_read(volatile uint8_t address_msb, volatile uint8_t address_lsb) {
      volatile union {
        volatile uint16_t sixteen_bit_address;
        volatile uint8_t byte_array[2];
      } addr_byte_union;
      addr_byte_union.byte_array[0] = address_lsb;
      addr_byte_union.byte_array[1] = address_msb;
      // We're using this union to plug in the address_msb and address_lsb
      // variables and get out a uint16_t.  Make sure to put the bytes in
      // in little endian order (lsb first) or your results will be very
      // odd once you go over address 0x0020.  Been there, did that.

      if (addr_byte_union.sixteen_bit_address >= MEM_SIZE) {
        return halt;                                                                              

      } else {
        return mem_array[addr_byte_union.sixteen_bit_address];
      }
      // Check to see if we're trying to seek a legit address. If not,
      // return a z80 halt instruction and throw an error message.
    }
    // The m_seek_read member function decodes two separate bytes (address_msb and address_lsb)
    // into a single uint16_t address, then goes to that address and returns that cell of the
    // array. If the decoded address exceeds MEM_SIZE, we return halt, otherwise we return
    // the array at that address.

    void m_seek_write(volatile uint8_t address_msb, volatile uint8_t address_lsb, volatile uint8_t data) {
      if (m_write_enable) {
        // On Z80 resets we can get spurious triggering
        // of the write ISR resulting in random writes
        // to memory. Reset sets m_write_enable to false, then
        // back to true when the reset is done.

        volatile union {
          volatile uint16_t sixteen_bit_address;
          volatile uint8_t byte_array[2];
        } addr_byte_union;
        addr_byte_union.byte_array[0] = address_lsb;
        addr_byte_union.byte_array[1] = address_msb;
        // We're using this union to plug in the address_msb and address_lsb
        // variables and get out a uint16_t.  Make sure to put the bytes in
        // in little endian order (lsb first) or your results will be very
        // odd once you go over address 0x0020.  Been there, did that.

        if (addr_byte_union.sixteen_bit_address >= MEM_SIZE) {

        } else {
          mem_array[addr_byte_union.sixteen_bit_address] = data;
        }
        // Check to see if we're trying to seek a legit address. If not,
        // fail silently. Ugh.                                                                              
      }
    }
    // The m_seek_write member function decodes the two bite field address
    // the same way m_seek_read does. If the decoded address exceeds
    // MEM_SIZE, we throw an error message, otherwise we set the
    // array[address] to data.

    void m_dump() {
      Serial.println("Dumping Simulated Memory");
      int c = 0;
      String line_start_address = "0x";
      uint16_t row_address = 0;
      String hex_data = "";
      String human_readable_data = "";
      // We have some variables. Initialize them.

      dump_page_header();
      //show the header

      for (int row = 0; row < (MEM_SIZE / 16); row++) {
        row_address = 16 * row;
        if (row_address < 0x1000)line_start_address += "0";
        if (row_address < 0x0100)line_start_address += "0";
        if (row_address < 0x0010)line_start_address += "0";
        line_start_address += String(row_address, HEX) + "|";

        for (int col = 0; col < 16; col++) {
          // We're printing blocks of 256 bytes.
          // each is 2 characters + two spaces
          // in hex, plus 1 character in text.
          if (mem_array[c] < 0x10) hex_data += "0";
          // Add leading zero for hex values below 0x10.

          hex_data += String(mem_array[c], HEX);
          hex_data += " ";
          // Add mem_array[c] as a hex string to hex_data.

          if (isprint(mem_array[c])) {
            human_readable_data += (char)mem_array[c];
          } else {
            human_readable_data += ".";
          }
          // If mem_array[c] is printable, add it to
          // human_readable_data. Otherwise add a . for
          // a placeholder.                                                                              
          c++;
        }

        Serial.println(line_start_address + " " + hex_data + 
                       " | " + human_readable_data);
        hex_data = "";
        human_readable_data = "";
        line_start_address = "0x";
        // Combine the three strings in one Serial.println.
        // Then clear them.
        if (!(c % 256)) {
          Serial.println("Continue (y/n)");
          if (get_input_string() == "n") {
            row = MEM_SIZE / 16;
          } else {
            dump_page_header();
            //show the header for each page, actually.
          }
        }
      }
    }
    // m_dump produces a human-readable dump of the memory array in // 256 byte pages, with each line 16 (0xF) items long.

    void m_edit() {
      String input_string = "y";
      uint16_t address;
      uint8_t  data;
      int comma_index = 0;
      String temp;

      m_edit_instructions();

      do {
        // repeat is loop until the 'while' is satisfied.
        input_string = get_input_string();
        // get the input string.
        if (input_string == "dump") {
          m_dump();
          m_edit_instructions();
          // If the user types "dump," dump the memory to
          // the serial console. Don't try and process it
          // into code. Show the instructions again.
        }
        if (input_string.startsWith("0x", 0)) {
          comma_index = input_string.indexOf(",");
          // find the comma in the input string                                                

          temp = input_string.substring(0, comma_index);
          temp.trim();
          // copy the string from the beginning to the comma into temp.
          // also trim it - get rid of leading and trailing spaces.

          address = hex_string2uint16_t(temp);
          // call hex_string2uint16_t with temp. Set the results into
          // address.

          temp = input_string.substring(comma_index + 1);
          temp.trim();
          data = (uint8_t)hex_string2uint16_t(temp);
          // repeat the process with the back half of the input string.

          Serial.println(">  Addr: 0x" + String(address, HEX) + 
                         " Data: 0x" + String(data, HEX) + " [OK]");
          // Print the line describing what is being entered where.

          mem_array[address] = data;
          // actually enter it.
        }
      } while (input_string != "exit");
      // if the user types "exit" stop repeating the loop.
    }
    //m_edit edits the memory array directly, allowing the user
    // to deposit a hex value in 0x notation at a hex address,
    // also in 0x notation. It allows the user to dump the
    // array to the screen at will, and exits on the exit
    //command.
};

//-----------------------------------------------------------
// Global variables
// The big advantage to using C++ objects in this project
// was the drastic reduction of global variables. There
// are still quite a few variables, but most of them are
// contained in functions or in classes and don't exist
// until an object of that class is instantiated.
//-----------------------------------------------------------
clock_gen* ourclock = NULL; // pointer to a clock_gen object.
memory_simulator* mem_sim = NULL; // pointer to memory object.
cpu Z80; // declare our CPU object. Not a pointer.                                                                              

//-----------------------------------------------------------
// Functions which are not members of a class.
//-----------------------------------------------------------

//-----------------------------------------------------------
// Repeat(int number char character)
// This function creates a string of character
// exactly /number/ long.
//-----------------------------------------------------------
String repeat(int number, char character) {
  String temp = "";
  for (int c = 0; c < number; c++) {
    temp = temp + String(character);
  }
  return temp;
}
//-----------------------------------------------------------
// get_input_string()
// This function loops forever waiting for an input string
// and returns the string when it gets one.
//-----------------------------------------------------------
String get_input_string() {
  while (!Serial.available()) {
  }
  return (Serial.readString());
}

//-----------------------------------------------------------
// string2uint32_t()
//- The String class includes no nice way to turn strings of
// digits into a numeric value. (Actually, there's an
// undocumented one. Classy.)
//
// This function goes through the string from left to right.
// For each position it advances to the right, it multiplies
// the existing value by 10 and adds the value of the
// character at that position minus the value of the
// character '0'. When we reach the end of the string,
// return temp.
//-----------------------------------------------------------
uint32_t string2uint32_t(String input) {
  uint32_t temp = 0;
  input.trim();                                                                              
  for (int c = 0; c < input.length(); c++) {
    temp = temp * 10 + input.charAt(c) - '0';
  }
  return temp;
}

//-----------------------------------------------------------
// hex_string2uint16_t()
// This function goes through the string from left to right.
// For each position it advances to the right, it multiplies
// the existing value by 16. if the new digit is 0-9 (less
// than the value of ':') add the character's numeric value
// minus the value of '0',  A-F and a-f are processed the
// same way, except that we check to make sure the new
// digit is actually in the range and subtract a different
// value.  Once we have the correct value for the character,
// we add the value of the character at that position minus
// the value of the character '0'. When we reach the end
// of the string, return temp.
//-----------------------------------------------------------
uint16_t hex_string2uint16_t(String input) {
  uint16_t temp = 0;
  char tempchar;
  input.trim();
  for (int c = 2; c < input.length(); c++) {
    temp = (temp * 0x10);
    tempchar = input.charAt(c);
    if (tempchar < ':') temp += (tempchar - '0');
    if ((tempchar > '@') && (tempchar < 'G')) temp += (tempchar - '7');
    if ((tempchar > '`') && (tempchar < 'g')) temp += (tempchar - 'W');
  }
  return temp;
}

//-----------------------------------------------------------
// menu
// This function generates the menu and selects which function
// to call, whether it's in an object or not.
//-----------------------------------------------------------
void menu() {
  String input_string = "";
  Serial.println("
" + repeat(15, ' ') + "*** Menu ***");
  Serial.println(repeat(42, '-'));
  Serial.println("Z80 Operations Commands");
  Serial.println(repeat(42, '-'));                                                                              
  Serial.println("(1) Reset Z80");
  Serial.println("(2) Set Clock Speed");
  Serial.println("(3) Stop Clock");
  Serial.println(repeat(42, '-'));
  Serial.println("Free Run ISR Commands");
  Serial.println(repeat(42, '-'));
  Serial.println("(4) Attach Free Run ISR to INT1");
  Serial.println("(5) Detach Free Run ISR from INT1");
  Serial.println(repeat(42, '-'));
  Serial.println("Memory Simulation and Z80 Programming");
  Serial.println(repeat(42, '-'));
  Serial.println("(6) Initialize Simulated Memory");
  Serial.println("(7) Enter Program Into Simulated Memory");
  Serial.println("(8) Run Program (Attach Mem_Sim ISRs)");
  Serial.println("(9) Dump Simulated Memory");
  Serial.println(repeat(42, '-'));
  // print the text of the menu.

  Serial.print("Clock is ");
  if (ourclock != NULL) {
    Serial.println("Running.");
  } else {
    Serial.println("Stopped.");
  }
  Serial.print("Memory is ");
  if (mem_sim != NULL) {
    Serial.println("Available.");
  } else {
    Serial.println("Not Available.");
  }
  Serial.println(repeat(42, '-'));
  // check to see if there's an object attached to ourclock. If not,
  // then the clock is not enabled. Tell the user one way or the other.
  // Likewise, if there's an object attached to mem_sim, memory is
  // enabled. Otherwise it's not. Tell the user.

  switch ((int)string2uint32_t(get_input_string())) {
    case 1: Z80.reset();
      break;
    // Option 1 is reset. Call the reset member function of Z80.

    case 2:                                                                              
      Serial.println("Menu: Enter Z80 Clock Speed (1 - 20000000Hz)");
      input_string = get_input_string();
      delete ourclock;
      ourclock = NULL; // clear the pointer. Otherwise things get confused.
      ourclock = new clock_gen(string2uint32_t(input_string));
      mem_sim->m_write_enable=false;
      Z80.reset();
      mem_sim->m_write_enable=true;
      break;
    // Option 2 is start the clock/set the clock. Call input_string()
    // and stash the results in a variable by the same name.
    // Delete anything that's already on the ourclock pointer                                                                              
    // and set it to null.
    // Do the delete so as not waste system resources. Do the
    // set to null so as not to get weird clock behavior.
    // Then instantiate a clock_gen object. Take input_string and
    // feed it to string2uint32_t, and feed the output of /that/
    // to the clock_gen's constructor, and let it do all the work.

    case 3:
      delete ourclock;
      ourclock = NULL; // Clear the pointer, otherwise things get confused.
      break;
    // Option 3 stops the clock. To do this, delete the object pointed to
    // by ourclock, and set ourclock to NULL so the next clock doesn't have
    // weird behavior.
    case 4:
      Serial.println("Menu: Attaching free_run_ISR to INT1");
      noInterrupts();
      detachInterrupt(1);
      attachInterrupt(1, free_run_ISR, FALLING);
      interrupts();
      Z80.reset();
      break;
    // Option 4 hooks up the free running ISR to interrupt 1, which listens
    // for /mreq events. Every time the Z80 asks for memory and pulls
    // this signal low, our ISR will fire. Free-running means we always give                                                                              
    // the Z80 NOP instructions (do nothing, go on to the next address),
    // so we can watch and see if the address signals change. Turn
    // interrupts off, attach the ISR to interrupt zero on the falling
    // edge (/MREQ is active low), then turn interrupts back on.
    // Finally, reset the Z80 so it starts from address 0x0000 in
    // the output.

    case 5:
      Serial.println("Menu: Detatching free_run_ISR from INT1");
      noInterrupts();
      detachInterrupt(1);
      interrupts();
      Z80.reset();
      break;
    // You know how the last option attached the free_run_ISR?
    // Option 5 detatches it. Turn interrupts off, detatch
    // interrupt 1, turn interrupts back on, then reset
    // the Z80 on general principles.

    case 6:
      delete mem_sim;
      mem_sim = NULL;
      mem_sim = new memory_simulator();
      break;
    // Option 6 turns on simulated RAM for the Z80. Delete anything
    // on the mem_sim pointer, and set the pointer to NULL to avoid
    // memory strangeness. Then instantiate a memory_simulator
    // object and attach it to the mem_sim pointer. Memory_simulator
    // objects' constructor takes no parameters.

    case 7:
      mem_sim->m_edit();
      break;
    // Option 7 is enter a program into simulated memory.
    // call the m_edit member function of the memory simulator.
    // This lets the user put simple, hand-assembled programs
    // into the simulated memory for the Z80 to run. It's
    // slightly less tedious than doing it with toggle switches
    // on a front panel.(but only slightly).

    case 8:                                                                              
      Serial.println("Menu: Attaching mem_read_ISR to INT1.");
      Serial.println("Menu: Attaching mem_write_ISR to INT0.");
      Serial.println("Menu: Any program therein should run.");
      noInterrupts();
      detachInterrupt(1);
      detachInterrupt(0);
      mem_sim->m_write_enable=false;
      attachInterrupt(1, mem_read_ISR, FALLING);
      attachInterrupt(0, mem_write_ISR, FALLING);
      mem_sim->m_write_enable=true;
      interrupts();
      Z80.reset();
      break;
    // Just as option 4 attached the free running ISR to interrupt 1,
    // option 8 connects the memory simulator ISR to interrupt 1.
    // This means that when the Z80 lowers its /MREQ signal and
    // requests memory, our ISR will try to service it with calls
    // to the memory_simulator object connected to mem_sim. Why
    // isn't the ISR in the object?  Because the Arduino core
    // won't let you. Same as with option 4. Stop interrupts, detatch
    // anything already connected to interrupt 1, attach mem_sim_ISR
    // to interrupt 1 on the falling edge, then turn interrupts back on
    // and reset the Z80 so our output starts at 0x0000.
    // NOTE - CHNAGED FROM FALLING TO LOW

    case 9:
      mem_sim->m_dump();
      break;
      // Option 9 dumps the simulated memory array to the serial
      // console, one 256 byte page at a time. Which gets tedious
      // going through 8 kilobytes, but it gets there. We just call
      // the m_dump() function of the memory_simulator object
      // connected to the mem_sim pointer.
      // Such a tangled web we weave.
  } // end of case.
} // end of menu function.

//-----------------------------------------------------------
// free_run_ISR()                                                                              
// This function is an interrupt service routine for
// INT1. When INT1 fires, we're in a read cycle.
// This ISR prints out the 16 bit address
// requested by the Z80, and returns a 0x00 (NOP) to the
// Z80, telling it to do nothing and go the next address,
// allowing us to observe the address lines (and make sure
// they all work and are connected correctly.
//-----------------------------------------------------------
void free_run_ISR() {
  byte temp;
  String output = "";
  Z80.save_mode();
  // Save the control signals we're sending to the Z80.

  Z80.mode_wait();
  // Set the Z80's mode to wait, so it stops asking for
  // new addresses while the ISR is trying to service
  // this request.

  Z80.data_in(0x0);
  // Always send the Z80 a NOP (0x0).

  output += String("free_run_ISR: Address: 0x");
  if (Z80.addr_msb < 0x10) output += String("0");
  output = output + String(Z80.addr_msb, HEX);
  if (Z80.addr_lsb < 0x10) output += String("0");
  output += String(Z80.addr_lsb, HEX);
  Serial.println(output);
  // Build the output string to show the user
  // what address was requested. This is what
  // free running is for.
  Z80.restore_mode();
  // un-wait the Z80.
}
//-----------------------------------------------------------
// mem_read_ISR()
// This function is an interrupt service routine for
// INT1. Like free_run_ISR, the first thing it does
// is save the Z80 control signal state, then set the Z80
// into wait mode, so we can survice this memory request
// before the Z80 asks for the next one. After that, it sends
// data FROM the memory simulator TO the Z80 (on read)
// After that, it builds up a string to tell the user what
// just happened and prints it.
//-----------------------------------------------------------
void mem_read_ISR() {
  uint8_t tempdata = 0;
  String output = "";                                                                              

  Z80.save_mode();
  // Save the Z80 control signal state.

  Z80.mode_wait();
  // Put the Z80 into wait mode.

  tempdata = mem_sim->m_seek_read(Z80.addr_msb, Z80.addr_lsb);

  if (!Z80.M1()) {
    output += String("mem_read_ISR: Z80 Fetched Address: 0x");
  } else {
    output += String("mem_read_ISR: Z80 Read Address: 0x");
  }
  Z80.data_in(tempdata);
  // On a read cycle (from the Z80's perspective)
  // tell the object pointed to by mem_sim to seek the address
  // present on the Z80's address bus, and send the data
  // stored there to the Z80's data bus.
  // Tell the user that the Z80 read the address.

  if (Z80.addr_msb < 0x10) output += String("0");
  output += String(Z80.addr_msb, HEX);
  if (Z80.addr_lsb < 0x10) output += String("0");
  output += String(Z80.addr_lsb, HEX);
  output += String("	Data: 0x");
  if (tempdata < 0x10) output += String("0");
  output += String(tempdata, HEX);
  Serial.println(output);
  // Build the rest of the output string and display it. /M1
  // is the Z80's signal to indicate it's doing an instruction
  // fetch. If it is, tell the user so.

  Z80.restore_mode();
  //Restore the Z80 to non-halted mode.
}
//-----------------------------------------------------------
// mem_write_ISR()
// This function is an interrupt service routine for INT0.
// like mem_read_ISR(), the first thing it does is
// is save the Z80 control signal state, then set the Z80
// into wait mode, so we can survice this memory request
// before the Z80 asks for the next one. After that, it sends
// data FROM the Z80 TO the memory simulator.
// After that, it builds up a string to tell the user what
// just happened and prints it.                                                                              
//-----------------------------------------------------------
void mem_write_ISR() {
  String output = "";
  uint8_t tempdata = 0;

  Z80.save_mode();
  // Save the Z80 control signal state.

  Z80.mode_wait();
  // Put the Z80 into wait mode.

  tempdata = Z80.data_out();
  mem_sim->m_seek_write(Z80.addr_msb, Z80.addr_lsb, tempdata);
  output += String("mem_write_ISR: Z80 Wrote Address: 0x");
  // On write cycle (from the Z80's perspective)
  // tell the memory simulator object to seek the address
  // present on the Z80's address bus, and set that address
  // of the memory simulator TO the value on the Z80's
  // data bus.

  if (Z80.addr_msb < 0x10) output += String("0");
  output += String(Z80.addr_msb, HEX);
  if (Z80.addr_lsb < 0x10) output += String("0");
  output += String(Z80.addr_lsb, HEX);
  output += String("	Data: 0x");
  if (tempdata < 0x10) output += String("0");
  output += String(tempdata, HEX);
  Serial.println(output);
  //Build the rest of the output string and display it.

  Z80.restore_mode();
  //Restore the Z80 to non-halted mode.
}
//-----------------------------------------------------------
// Setup
// Sets the serial console speed.
//-----------------------------------------------------------
void setup() {
  Serial.begin(115200);
}

//-----------------------------------------------------------
// Loop
// Calls the menu() function. Over and over again.
//-----------------------------------------------------------
void loop() {                                                                              
  menu();
}

Output

So what happens when you run the sketch? Here’s a log file where I reset the Z80, set the clock, delete the clock, set the clock again, and run the free_run_ISR. This log tells me my Z80 explorer is working correctly. Here’s the log file.

               *** Menu ***
------------------------------------------
Z80 Operations Commands
------------------------------------------
(1) Reset Z80
(2) Set Clock Speed
(3) Stop Clock
------------------------------------------
Free Run ISR Commands
------------------------------------------
(4) Attach Free Run ISR to INT1
(5) Detach Free Run ISR from INT1
------------------------------------------
Memory Simulation and Z80 Programming
------------------------------------------
(6) Initialize Simulated Memory
(7) Enter Program Into Simulated Memory
(8) Run Program (Attach Mem_Sim ISRs)
(9) Dump Simulated Memory
------------------------------------------
Clock is Stopped.
Memory is Not Available.
------------------------------------------

I selected option 1.

CPU: Resetting...
CPU: Done Resetting.

The menu printed again, and I selected option 2. I chose a clock speed of 5Hz.

Menu: Enter Z80 Clock Speed (1 - 20000000Hz)
Clock: Object Created.
We want to count to 4000000.00
For a clock speed of 5
I chose a prescaler of 256
And a match of 15625
We'll count to 4000000                                          
Clock Generator: Running
CPU: Resetting...
CPU: Done Resetting.

The menu printed again. Note the change where it says Clock is Running. I selected option 3, to stop the clock.

               *** Menu ***
[most of menu cut out.]
------------------------------------------
Clock is Running.
Memory is Not Available.
------------------------------------------

Clock Generator: Object Deleted.

The menu printed out again. I selected option 2 and asked for a 250Hz clock. This is about as fast as the terminal monitor can keep up with. It’s far too fast to read, but a full free run spans 65,535 addresses. It takes some time. Even the slowest Z80s normally ran 10,000 times as fast, but they weren’t waiting for a printout at 115,200 baud between every M1 cycle.

               *** Menu ***
[most of menu cut out]
------------------------------------------
Clock is Stopped.
Memory is Not Available.
------------------------------------------

I selected option 2.

Menu: Enter Z80 Clock Speed (1 - 20000000Hz)
Clock: Object Created.
We want to count to 80000.00
For a clock speed of 250
I chose a prescaler of 64
And a match of 1250
We'll count to 80000
Clock Generator: Running
CPU: Resetting...
free_run_ISR: Address: 0x0c0a
CPU: Done Resetting.

The menu printed again. I selected option 4, Attach Free Run ISR. The serial monitor got very, very busy.

               *** Menu ***                                                                              
[most of menu cut out]
------------------------------------------
Clock is Running.
Memory is Not Available.
------------------------------------------

Menu: Attaching free_run_ISR to INT1
CPU: Resetting...
CPU: Done Resetting.

The menu printed again. Why? We’re actually still in the loop() function, so menu gets called and will wait forever for input. All the Serial.printlns are coming from free_run_ISR.

               *** Menu ***
------------------------------------------
Z80 Operations Commands
------------------------------------------
(1) Reset Z80
(2) Set Clock Speed
(3) Stop Clock
------------------------------------------
Free Run ISR Commands
------------------------------------------
(4) Attach Free Run ISR to INT1
(5) Detach Free Run ISR from INT1
------------------------------------------
Memory Simulation and Z80 Programming
------------------------------------------
(6) Initialize Simulated Memory
(7) Enter Program Into Simulated Memory
(8) Run Program (Attach Mem_Sim ISRs)
(9) Dump Simulated Memory
------------------------------------------
Clock is Running.
Memory is Not Available.
------------------------------------------

free_run_ISR: Address: 0x0001
free_run_ISR: Address: 0x0002
free_run_ISR: Address: 0x0003
free_run_ISR: Address: 0x0004
free_run_ISR: Address: 0x0005
free_run_ISR: Address: 0x0006
free_run_ISR: Address: 0x0007
free_run_ISR: Address: 0x0008
free_run_ISR: Address: 0x0009
free_run_ISR: Address: 0x000a
free_run_ISR: Address: 0x000b
free_run_ISR: Address: 0x000c
free_run_ISR: Address: 0x000d
free_run_ISR: Address: 0x000e
free_run_ISR: Address: 0x000f                                                

That’s the first 16 addresses. You’ll note as you get above 0x00ff that every address whose MSB is odd (so there’s a 1 in its lowest bit) will light up the pin 1 LED. This is a good sign that things are working. At 250Hz, it will pulse on and off a little over a second at a time as we run through the whole range of addresses with an odd-numbered MSB. Here are a couple of the addresses where that occurs.

free_run_ISR: Address: 0x0500
free_run_ISR: Address: 0x0501

On and on it goes. It gets a little dull to watch if everything’s working right. Finally, after many thousands of addresses I cut out for brevity:

free_run_ISR: Address: 0xfffd
free_run_ISR: Address: 0xfffe
free_run_ISR: Address: 0xffff

After that, I sent the Cestino a 3, for option 3. Even though the menu had long since scrolled off the screen, deleting the clock object stopped the torrent of addresses.

If you got this far, and your output from the free_run_ISR looks more or less like mine, your Z80 explorer is probably working correctly. We’ll learn to program the Z80 in the next section.

Program 1: Infinite Loop

The first machine language program we’ll write is an infinite loop . Anyone who’s ever messed with a computer with a BASIC interpreter has done this:

10 print "Hello world"
20 goto 10

We’re not even going to do the printing part. We don’t have any hardware to do the job, and we don’t need it. The mem_read_ISR will show us the loop as it happens by showing us the changes in address.

The infinite loop is one instruction with a two byte memory address for a parameter. Here’s the assembly version, with the mnemonics.

JP 0x0001

Traditionally, in an assembler, we’d put a semicolon after that to explain what we were doing and why. We’re hand assembling, so that winds up in your notebook instead.

The opcode for the version of JP that goes to a literal address is 0xC3. Because our Z80 is little endian, we have to put the least significant byte of the address we want to go to first, then the most significant byte. We also need to write down what address in memory each instruction will be on, both so we know where to put it, and so, when we’re writing the code, we know what addresses to jump to.

What we wind up with is this:

0x01 0xc3
0x02 0x01
0x03 0x00

Moving forward, I’ll put the two representations together. (That’s how they are in my notes, too.)

       JP 0x0001
0x01 0xC3
0x02 0x01
0x03 0x00                                          

Go ahead and start up the Z80 Explorer, and get to the menu. Mac users, you may have to reset the Cestino manually when you start the serial monitor.

First, Initialize Simulated Memory, option 6. You’ll remember from the sketch that this instantiates the memory simulator object and points the mem_sim pointer at it. We’re at a point in the game where that no longer matters. We need to focus on the Z80.

Next, select option 7, Enter Program Into Simulated Memory.

Type the address and opcode pairs above.

Here’s what it looks like on my screen:

        *** Mem-Sim Line Editor ***
Enter an address and data in HEX eg: 0x0000,0x76
"exit" to quit
"dump" to view memory

>  Addr: 0x1 Data: 0xC3 [OK]
>  Addr: 0x2 Data: 0x1 [OK]
>  Addr: 0x3 Data: 0x0 [OK]

Typing “dump,” I get:

Dumping Simulated Memory

Address  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f   Data (text)
---------------------------------------------------------------------------
0x0000| 00 c3 01 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x0010| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x0020| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x0030| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x0040| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x0050| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x0060| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x0070| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x0080| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x0090| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x00a0| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x00b0| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x00c0| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x00d0| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x00e0| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x00f0| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
Continue (y/n)                                                                              

It looks a little strange with nothing in the human-readable part of the field, but if you look at the hex dump, you can see that, in fact, everything is fine, and our three-byte program is there.

Go ahead and answer “n” to exit from the editor, and type “exit”.

Then set the clock to about 10Hz, and attach the Memory Simulator ISRs (options 2 and 8, respectively.)

You should get output from the mem_read_ISR that looks like this:

mem_read_ISR: Z80 Fetched Address: 0x0000       Data: 0x00
mem_read_ISR: Z80 Fetched Address: 0x0001       Data: 0xc3
mem_read_ISR: Z80 Read Address: 0x0002          Data: 0x01
mem_read_ISR: Z80 Read Address: 0x0003          Data: 0x00
mem_read_ISR: Z80 Fetched Address: 0x0001       Data: 0xc3
mem_read_ISR: Z80 Read Address: 0x0002          Data: 0x01
mem_read_ISR: Z80 Read Address: 0x0003          Data: 0x00
mem_read_ISR: Z80 Fetched Address: 0x0001       Data: 0xc3
mem_read_ISR: Z80 Read Address: 0x0002          Data: 0x01
mem_read_ISR: Z80 Read Address: 0x0003          Data: 0x00
Clock Generator: Object Deleted.                                                                      

Note that because memory address 0x0000 has nothing in it, it’s a NOP. We’ll read it and go on to the next address. We fetch again from 0x0001, and get the instruction 0xC3. That’s our JP instruction.

Next we read two more addresses. Note that they’re not instruction fetches. We’re not in an M1 cycle, so the /M1 signal is not active (low). It’s reading those two bytes in 0x0002 and 0x0003 as parameters for the JP, which is exactly what it should do. Look what happens next.

All of a sudden, we’re back fetching at address 0x0001. The JP worked! I let it run for three more trips through the loop and hit option 3, Stop Clock.

The menu was scrolled off the serial monitor, but loop calls menu() every time we exit menu(), and we only exit menu when we’ve given it an option number. So menu is sitting there waiting for input the whole time while we watch our Z80 program loop endlessly from address 0x0001 to 0x003, over and over again.

Program 2: Index Controlled Loop

Infinite loops are fun for demonstrations, but they’re not the most useful of programs. For the next machine language program, we’ll write a loop controlled by an index. This is more or less the same as:.

for (PORTB = 5; PORTB == 0; PORTB--) {
    //do nothing.
  }

You could use an int, of course, and declare it right in the loop. We’ve done it lots of times, except that I sneakily decrement using PORTB--. In this case, however, using the ATmega’s PORTB register to do the job is much closer to how the loop works in machine language.

Here’s the code

        LD B,0x05 ; load register B with the value 0x05.
0x01 0x06
0x02 0x05
        DEC B; Decrement the B register
0x03 0x05
        JP Z 0x0A; Jump to 0x0A when B hits 0 and the Z flag is set.
0x04 0xCA
0x05 0x0A.                                                                      
0x06 0x00
        JP 0x03 ; If we get here, we're not done. Jump to 0x03
0x07 0xC3
0x08 0x03
0x09 0x00
        HLT ; If we get here, halt the CPU.
0x0A 0x76

All that just for a loop? Yes. We’re indexing this loop on the B register, as it’s a general purpose register. We set it to 5 in the first instruction.

LD B, 0x05.

In the next instruction we decrement B. This works, but doing it here before the test means the loop will actually only run four times. Oops.

DEC B

The next instruction is the test. You’ll find a lot of loops run backwards in assembly and machine code. It’s much simpler and much faster to decrement and check a flag than to add and compare. The DEC instruction sets the Z flag automatically if the value it decremented reaches zero. So all we have to do is test to see if the Z flag is set, and if it is, jump out of the loop. From writing out all the bytes in my notes, I know that to escape the loop, I have to go to 0x0A, so that’s where the JP Z takes us. Assemblers figure this kind of thing out for you automatically.

JP Z 0x0A

If we haven’t jumped out of the loop, we go ahead and loop with a JP call, just like we did in the infinite loop.

JP 0x03

If we get to this point, then we’ve jumped out of the loop in the JP Z instruction earlier. So we go ahead and halt the Z80, which tells it to stop running the program.

HLT

Go ahead and stop the clock on the Z80 explorer (option 3) and initialize simulated memory again (option 6), then enter the ops above. When they’re in and they look right, you should get output that looks like this:

        *** Mem-Sim Line Editor ***
Enter an address and data in HEX eg: 0x0000,0x76
"exit" to quit
"dump" to view memory.                                                                              

>  Addr: 0x1 Data: 0x6 [OK]
>  Addr: 0x2 Data: 0x5 [OK]
>  Addr: 0x3 Data: 0x5 [OK]
>  Addr: 0x4 Data: 0xca [OK]
>  Addr: 0x5 Data: 0xa [OK]
>  Addr: 0x6 Data: 0x0 [OK]
>  Addr: 0x7 Data: 0xc3 [OK]
>  Addr: 0x8 Data: 0x3 [OK]
>  Addr: 0x9 Data: 0x0 [OK]
>  Addr: 0xa Data: 0x76 [OK]

Typing “dump” I get:

Dumping Simulated Memory

Address  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f   Data (text)
---------------------------------------------------------------------------
0x0000| 00 06 05 05 ca 0a 00 c3 03 00 76 00 00 00 00 00  | ..........v.....
0x0010| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x0020| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x0030| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x0040| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x0050| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x0060| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x0070| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x0080| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x0090| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x00a0| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x00b0| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x00c0| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x00d0| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x00e0| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x00f0| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
Continue (y/n).                                                                              

Looks good. Type n to quit, then go ahead and restart the clock. This will reset the Z80, but it won’t erase memory. Set the clock to about 20Hz. When the reset finishes, you’ll get output like this:

mem_read_ISR: Z80 Fetched Address: 0x0000       Data: 0x00
mem_read_ISR: Z80 Fetched Address: 0x0001       Data: 0x06
mem_read_ISR: Z80 Read Address: 0x0002          Data: 0x05
mem_read_ISR: Z80 Fetched Address: 0x0003       Data: 0x05
mem_read_ISR: Z80 Fetched Address: 0x0004       Data: 0xca
mem_read_ISR: Z80 Read Address: 0x0005          Data: 0x0a
mem_read_ISR: Z80 Read Address: 0x0006          Data: 0x00
mem_read_ISR: Z80 Fetched Address: 0x0007       Data: 0xc3
mem_read_ISR: Z80 Read Address: 0x0008          Data: 0x03
mem_read_ISR: Z80 Read Address: 0x0009          Data: 0x00

Well, B is not zero yet, so we’ve looped back to 0x0003. I’ve cut out three more iterations of this loop in the log.

mem_read_ISR: Z80 Fetched Address: 0x0003       Data: 0x05
mem_read_ISR: Z80 Fetched Address: 0x0004       Data: 0xca
mem_read_ISR: Z80 Read Address: 0x0005          Data: 0x0a
mem_read_ISR: Z80 Read Address: 0x0006          Data: 0x00
mem_read_ISR: Z80 Fetched Address: 0x000a       Data: 0x76
mem_read_ISR: Z80 Fetched Address: 0x000b       Data: 0x00
mem_read_ISR: Z80 Fetched Address: 0x000b       Data: 0x00
mem_read_ISR: Z80 Fetched Address: 0x000b       Data: 0x00
Clock Generator: Object Deleted.

Hey look. All of a sudden we don’t get past 0x0006. That’s where the second byte of the JP Z 0x000A instruction was. B must have hit 0, and the Zero flag got set. We jumped to 0x000A. Once at 0x000A, we picked up a HLT instruction. After that we stop advancing through memory addresses (at 0x000b) and sit there forever. I stopped the clock after that..

EI ; Enable interrupts

        EI; Enable Interrupts
0x10 0xFB
        IM1; Set interrupts to mode 1
0x11 0xED
0x12 0x56

        LD HL 0x2000; Load the HL register with the highest memory address.
0x13 0x21
0x14 0x00
0x15 0x20
        LD SP HL; Load the stack pointer from HL.
0x16 0xF9

        JP 0x17; Loop infinitely
0x17 0xC3
0x18 0x17
0x19 0x00

        DI; Disable interrupts
0x38 0xF3
        EI; Enable Interrupts
0x39 0xFB                                                

        RETI; Return from interrupt
0x3A 0xED
0x3B 0x4D

        *** Mem-Sim Line Editor ***
Enter an address and data in HEX eg: 0x0000,0x76
"exit" to quit
"dump" to view memory

>  Addr: 0x38 Data: 0xf3 [OK]
Dumping Simulated Memory

Address  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f   Data (text)
---------------------------------------------------------------------------
0x0000| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x0010| fb ed 56 21 00 20 f9 c3 17 00 00 00 00 00 00 00  | ..V!. ..........
0x0020| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x0030| 00 00 00 00 00 00 00 00 f3 fb ed 4d 00 00 00 00  | ...........M....
0x0040| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x0050| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x0060| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x0070| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x0080| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................                                                                                      
0x0090| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x00a0| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x00b0| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x00c0| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x00d0| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x00e0| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
0x00f0| 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  | ................
Continue (y/n)

mem_read_ISR: Z80 Fetched Address: 0x0010       Data: 0xfb
mem_read_ISR: Z80 Fetched Address: 0x0011       Data: 0xed
mem_read_ISR: Z80 Fetched Address: 0x0012       Data: 0x56
mem_read_ISR: Z80 Fetched Address: 0x0013       Data: 0x21
mem_read_ISR: Z80 Read Address: 0x0014          Data: 0x00
mem_read_ISR: Z80 Read Address: 0x0015          Data: 0x020
mem_read_ISR: Z80 Fetched Address: 0x0016       Data: 0xf9
mem_read_ISR: Z80 Fetched Address: 0x0017       Data: 0xc3
mem_read_ISR: Z80 Read Address: 0x0018          Data: 0x17
mem_read_ISR: Z80 Read Address: 0x0019          Data: 0x00

mem_read_ISR: Z80 Fetched Address: 0x0017     Data: 0xc3
mem_read_ISR: Z80 Read Address: 0x0018        Data: 0x17
mem_read_ISR: Z80 Read Address: 0x0019        Data: 0x00

mem_read_ISR: Z80 Fetched Address: 0x0017     Data: 0xc3
mem_read_ISR: Z80 Read Address: 0x0018        Data: 0x17
mem_read_ISR: Z80 Read Address: 0x0019        Data: 0x00                                                

mem_write_ISR: Z80 Wrote Address: 0x1fff      Data: 0x00
mem_write_ISR: Z80 Wrote Address: 0x1ffe      Data: 0x17

mem_read_ISR: Z80 Fetched Address: 0x0038       Data: 0xf3
mem_read_ISR: Z80 Fetched Address: 0x0039       Data: 0xfb
mem_read_ISR: Z80 Fetched Address: 0x003a       Data: 0xed
mem_read_ISR: Z80 Fetched Address: 0x003b       Data: 0x4d

mem_read_ISR: Z80 Read Address: 0x1ffe       Data: 0x17
mem_read_ISR: Z80 Read Address: 0x1fff       Data: 0x00

mem_read_ISR: Z80 Fetched Address: 0x0017     Data: 0xc3
mem_read_ISR: Z80 Read Address: 0x0018        Data: 0x17
mem_read_ISR: Z80 Read Address: 0x0019        Data: 0x00

Clock Generator: Object Deleted.

Program 4: Fun with the Stack

In the last program we touched the stack only briefly. The stack is one of those functions that is incredibly useful in the Z80. It’s a staple of machine language (and assembly) programming, so we should talk about it a little more.

For those who haven’t had formal computer programming classes, stacks are a data structure best visualized by plate dispensers (seriously, that’s what they’re called), those gadgets in cafeterias that hold stacks of plates. You can put a plate on the top of the dispenser. In programming we’d call this pushing a plate. When you put a second plate on the top, the spring in the dispenser compresses so the plates sink in and only the topmost plate is visible. This goes on for dozens of plates. When you want a plate out, you take one from the top, the springs expands, and the next plate becomes available. In software, this is called popping a plate. Push the plate on, pop the plate off. You only have access to the top of the stack, and it’s the last plate you put in. Stacks are last-in, first-out (LIFO) data structures .

In the Z80, the stack is defined by the Stack Pointer (SP) register.

When you PUSH an 8 bit value onto the stack, the SP decrements and your value is put in memory at that address. When you push a 16 bit value onto the stack, the bytes are pushed onto the stack, but they’re pushed there in reverse order, so the MSB is at the next highest address, and the LSB is at the next highest after that. If you were to read memory in the normal order, however, you’d find that little endian-ness has been respected. It’s fairly arbitrary, since you normally take things off the stack with a POP, and POP will put the bytes in the order they were in when they were PUSHed.

POPping the stack copies the byte or bytes on the stack (a 16 bit push had better be followed by a 16 bit pop, or the stack will probably stop making sense).

If you’ve ever had programming teachers mention that “recursive programming is bad because you run out of stack space,” consider that if you wind up using a CALL and RET to call your function, and it calls itself again and again, every call pushes more stuff onto the stack. Eventually, yes, you do run out of stack space (or in the Z80, your stack clobbers something important). If this hasn’t happened to you, don’t worry. It’s an argument out of academic circles, mostly.

So now that we know what the stack is, and we’ve seen the mnemonics go by that make it work, let’s do one more machine language program that demonstrates the stack. It’ll put the stack pointer at 0x00FF, which is the end of the first 256 byte page of memory, so we can see what’s in the stack in dumps, and it will show the last in/first out nature of the stack to give you a message

The program is called Fun with the Stack.

Here’s the code. We start with an initialization section.

        LD HL 0x00FF; Set the HL register to 0x00FF.
0x10 0x21
0x11 0xFF
0x12 0x00
        LD SP HL; Load the SP from HL
0x13 0xF9                                          

We’ll have data starting at 0x0040. We’ll use HL as a pointer to that address.

        LD HL 0x0040; Load HL with the address of the start of data.
0x14 0x21
0x15 0x40
0x16 0x00

There are two loops in this program, and we start the first one here, at 0x17. The first loop will load B with a byte of data, then copy that data to A, compare A with 0xFF to see if we’re done. If not we’ll add 16 to A and push the result onto the stack. That’s why the data doesn’t look like anything in the memory dump. Not only is it out of order, it’s slightly encrypted. Then we’ll increment HL and go back to 0x17.

        LD B, (HL); Load B with the contents of memory at address HL.
0x17 0x46
        LD A, B; Load the accumulator A with the value in B.
0x18 0x78
        CP 0xFF; Compare 0xFF to register A.
0x19 0xFE
0x1A 0XFF
        JP Z 0x0026; If the zero flag is set (A=0xFF) jump to 0x0026
0x1B 0xCA
0x1C 0x26
0x1D 0x00
        LD A, B; Copy B into A again, in case the accumulator changed.
0x1E 0x78
        ADD A 10;
0x1F 0xC6
0x20 0x10
        PUSH AF; Do a 16 bit push of AF, even though all we want is A.
0x21 0xF5
        INC HL; Increment HL
0x22 0x23
        JP 0x17; Jump to 0x0017 to repeat our loop.
0x23 0xC3
0x24 0x17
0x25 0x00                                          

The first loop pushed our message onto the stack after decoding it. The second loop will pop it back off the stack into a new area of memory starting at 0x0050. We initialize the second loop by setting HL to 0x0050.

        LD HL 0x50; Load HL with 0x50, the start of our output area.
0x26 0x21
0x27 0x50
0x28 0x00

We’re into loop two, and already doing something a little underhanded. We know that we have less than 16 items of data, so we know that the low order byte of HL is the only one that will ever change. So we index the loop on L. When L hits 0x58, the maximum address we’ve allowed for output, the loop will end. Elegant programming this is not.

        LD A, L; Load A with the low order byte of HL.
0x29 0x7D
        CP 0x57 ;Compare 0x58 and Register A.
0x2A 0xFE
0x2B 0x58
        JP Z 0x35; If the Z flag is set, jump to 0x35.
0x2C 0xCA
0x2D 0x35
0x2E 0x00

If we get here, we haven’t escaped from our loop. So we go ahead and pop AF (16 bit pop), and write A to location HL in memory. Then increment HL and repeat.

        POP AF; Pop AF from the stack.
0x2F 0xF1
        LD(HL),A; Load memory location HL with the value of A.
0x30 0x77
        INC HL; Increment HL to the next memory location.
0x31 0x23
        JP 0x29; Jump to 0x0029 to repeat the loop.
0x32 0xC3
0x33 0x29
0x34 0x00
        HLT; Halt the CPU when we're done.
0x35 0x76

That’s all the code, but we still need the data. It’s short.

0x40 0x11
0x41 0x62
0x42 0x55
0x43 0x58
0x44 0x64
0x45 0x62
0x46 0x65
0x47 0x36
0x48 0xFF                                          

Normally I’d put the log here, but that would spoil the secret message. You already know what will happen. Loop one will read the data from 0x40 to 0x48, add 10 to it, and push it on the stack. Loop two will iterate from 0x50 to 0x57, pop the data back off the stack and write it to that address of memory. Make sure to do a dump so you can see the secret message this program will leave in memory for you.

And enjoy.