Related
Recommended
Engagement
  • Author Author: kellyhensen
  • Date Created: Date Created
  • Last Updated Last Updated:
  • Views 4416 views
  • Likes 12 likes
  • Comments 10 comments

Emulate an EPROM - How Hard Could it Be? -- Episode 517

 

The Apple IIe uses a custom microcontroller and ROM chip to put ASCII values into the computer’s memory. How hard could it be to replace that dual-chip setup with a microcontroller to emulate another kind of keyboard? Bald Engineer tries using an Arduino Mega 2560, Teensy 4.0, and a Pi Pico to replace a vintage ROM chip. See what works AND what does not!

 

In the attached zip file are:

 

  • KiCad files for the ROM Interposer Board
  • Arduino code for ROM test
  • Teensy code to test interrupt latency
  • Python code that can respond to an Output Enable signal

 

A couple of notes that keep coming up:

 

Q: Why do you need to emulate a ROM chip anyway?

A: Like most 8-bit computers, the keyboard interface eventually talks directly to the memory bus. In an Apple IIe (and IIc), that is done through a ROM chip.

 

Q: Why not just replace the keyboard matrix?

A: The final design will not use the original keyboard microcontroller or ROM. Ideally, I want to have an interface for a USB keyboard (and possibly Apple Desktop Bus: ADB.)

 

Q: The Teensy was only 200 nanoseconds, why not just use that?

A: The Mini-Apple IIe is based on the MEGA-II ASIC from an Apple IIgs. Its timing is tighter and slightly different from the Apple IIe’s MMU. The Teensy is slightly too slow.

 

Q: What is “Golden Delicious”?

A: Originally, I was naming this project “Golden Delicious.” So, let’s call it a code name. Now, I call it “Mini Apple IIe.” But, the final project has a different name.

 

Supplemental Content:

 

 

Bill of Material:

 

Product Name Manufacturer Quantity Buy Kit
Pi Pico (RP2040) Raspberry Pi Foundation 1 Buy Now
Mega 2560 Arduino 1 Buy Now
Analog Discovery 2 Digilent 1 Buy Now
Digital Discovery Digilent 1 Buy Now

 

Additional Parts:

 

Product Name
Teensy 4.0 from PJRC

 



Attachments:
emulating_rom_with_mcu_v2.zip
Actions
Parents

  • Arduino is a High Level Lenguaje,
    but AVR allows to write directly to pins at MHz / 2 speeds "ultra fast".

    it seems very strange when you say AVR is Not fast enoigh...
    if you only want to create a Keyboard translator with LUT.
    also AVR has EPROM, RAM, and Flash Memory,even more confusing..

    There are many projects usign HW card readers to automatically type passwords on a keybaord, and stuff...

    i don't understand your projects, too over-simplified for a begginer...
    your audience has developed Telepathy.

  • in reply to juanpc2021

    No, it has nothing to do with the Arduino library (it isn't a language) nor how fast you can directly read/write the GPIO pins.

    The fundamental problem is that it takes a minimum of 1.5 microseconds for an AVR to respond to an interrupt. In the case of the Apple IIe's keyboard access, we have less than 500 nanoseconds to respond and output a value. (And then less than 10ns to get back off the bus.)

    The best case for an AVR is 1.5 microseconds. The Arduino library adds about another microsecond of overhead.

    i don't understand your projects, too over-simplified for a begginer ...

    I'm sorry you feel that way. But the point of this video was not to explain the entire project. The point was to show the steps I went through to solve one specific problem of a much larger project.

  • in reply to baldengineer

    interrupts create latency, required for multitasking.
    500ns requires 2MHz
    https://www.unitjuggler.com/convert-frequency-from-ns(p)-to-Hz.html?val=500

    AVR has 16MHz XO standard,
    most AVR instructions have 2 clocks per cicle... some 3, some 4,
    but can be overclocked to 20MHz "most people do, in complex projects."

    ...
    AVR has a 8 clocks available "heardroom" at 16Mhz and 500ns,
    see my point? very confusing...

  • in reply to juanpc2021

    That's great. Except, I can't rely on polling the "OUTPUT ENABLE" signal if the microcontroller is going to do anything else (like interface to a keyboard.)

    I need an interrupt. The AVR datasheet says:

    The interrupt execution response for all the enabled AVR interrupts is five clock cycles minimum.
    After five clock cycles the program vector address for the actual interrupt handling routine is executed.
    During these five clock cycle period, the Program Counter is pushed onto the Stack. The
    vector is normally a jump to the interrupt routine, and this jump takes three clock cycles. If an
    interrupt occurs during execution of a multi-cycle instruction, this instruction is completed before
    the interrupt is served.

    There is a minimum of 5 clocks (312 nanoseconds) and up to 8 clocks (500 nanoseconds) as a MINIMUM latency. That's assuming the processor can even start servicing the interrupt on the next clock. So at a MINIMUM, it will take longer to get into an ISR than I have to service it. And even if I could get into the ISR within the 5 clocks, I only have 3 single-cycle instructions left (at best) to do something.

    Yes, I could get into the ISR faster without the Arduino library. (Which then means I have to write *everything* from scratch. Wow.) And even if I did that, it still IS NOT FAST ENOUGH.

    So, none of your math on how fast you can toggle a pin matters.

    See MY point?

Comment
  • in reply to juanpc2021

    That's great. Except, I can't rely on polling the "OUTPUT ENABLE" signal if the microcontroller is going to do anything else (like interface to a keyboard.)

    I need an interrupt. The AVR datasheet says:

    The interrupt execution response for all the enabled AVR interrupts is five clock cycles minimum.
    After five clock cycles the program vector address for the actual interrupt handling routine is executed.
    During these five clock cycle period, the Program Counter is pushed onto the Stack. The
    vector is normally a jump to the interrupt routine, and this jump takes three clock cycles. If an
    interrupt occurs during execution of a multi-cycle instruction, this instruction is completed before
    the interrupt is served.

    There is a minimum of 5 clocks (312 nanoseconds) and up to 8 clocks (500 nanoseconds) as a MINIMUM latency. That's assuming the processor can even start servicing the interrupt on the next clock. So at a MINIMUM, it will take longer to get into an ISR than I have to service it. And even if I could get into the ISR within the 5 clocks, I only have 3 single-cycle instructions left (at best) to do something.

    Yes, I could get into the ISR faster without the Arduino library. (Which then means I have to write *everything* from scratch. Wow.) And even if I did that, it still IS NOT FAST ENOUGH.

    So, none of your math on how fast you can toggle a pin matters.

    See MY point?

Children
No Data