Hi mkube402,

that looks like a cool project (C64 fan myself 😊 )!
Apologies - I took the liberty to copy the code and imagine into the post (since you haven't posted enough yet, the forum will not allow you to do this). I hope you don't mind.

Your correction on line 50 seems to be correct. "LED" has not been defined and probably should have been HIGH indeed.

Note : I did find this more detailed alternative ... worth taking a look at that one.

Without having the means to test any of this, give this a try.
Cleaned up a few things and modified debouncing and LED flashing.

#include <EEPROM.H>

// C64 Kernel Switcher and Restore Key Reset/Selector
// version 1.1 -- 26-March-2019
// By Adrian Black

// restore key mod:  https://www.breadbox64.com/blog/c64-restore-mod/ 

const int PowerLED = 4;      // Output Power LED
const int PowerLEDAlt = 13;  // Output Power LED (onboard LED)
const int A13 = 5;           // Output EPROM Address Line 13
const int A14 = 6;           // Output EPROM Address Line 14
const int ResetLine = 7;     // Output to /RESET line
const int EXROMLine = 3;     // Output the /EXROM line
const int RestoreKey = 8;    // Input Restore key

int RestoreDelay = 2000;  // 2000ms delay for restore key
const int FlashSpeed = 75; // LED Flash delay

const unsigned long repeatdelay = 500; // used for debouncing
 
int CurrentROM; // which rom is select (0-3)
int debouncecounter = 0;       // how many times we have seen new value (for debounce)
int debouncereading;
int debounce_count;
int RestoreHeld;
unsigned long TimeHeld; // amount of time Resotre is held down

int buttonDuration = 0; // for keeping track of how long restore is held down
boolean buttonHeld = 0; // for keeping track when you are holding down 
boolean Released = 0; // Keeping track when the restore key is released
boolean holdingRestore = 0; // Keeping track if you are holding restore
boolean resetSystem = 0; // keep track wheter to reset

int buttonInput; // used to return if restore is held
unsigned long time; //used to keep track of millis output
unsigned long htime; //used to keep track of millis output
unsigned long btime; //used to keep track of bounce millis output

void setup() {
  pinMode(PowerLED, OUTPUT);
  pinMode(PowerLEDAlt, OUTPUT);
  pinMode(A13, OUTPUT);
  pinMode(A14, OUTPUT);
  pinMode(ResetLine, INPUT);
  pinMode(EXROMLine, INPUT);
  pinMode(RestoreKey, INPUT);

  digitalWrite(PowerLED, HIGH); // turn on the power LED (Fixed typo?)

  digitalWrite(ResetLine, LOW); // keep the system reset
  pinMode(ResetLine, OUTPUT); // switch reset line to OUTPUT so it can hold it low
  digitalWrite(ResetLine, LOW); // keep the system reset

  CurrentROM = EEPROM.read(1);
  SetSlot(CurrentROM);
  delay(200);
  pinMode(ResetLine, INPUT); // set the reset pin back to high impedance which releases the INPUT line
  delay(1000); // wait 1000ms
  FlashLED(CurrentROM); // flash the power LED to show the current state

  // all set!
}

void loop() {
  buttonInput = readButton();
  delay(500);
  time = millis(); // load the number of milliseconds the arduino has been running into variable time
  if (buttonInput == 1) {
    if (!buttonHeld) {
      htime = time;
      TimeHeld = 0;
      buttonHeld = 1;
    } //restore button is pushed
    else {
      TimeHeld = time–htime;
    } // button is being held down, keep track of total time held.
  }
  if (buttonInput == 0) {
    if (buttonHeld) {
      Released = 1;
      buttonHeld = 0;
      htime = millis();
      TimeHeld = 0; //restore button not being held anymore
    }
  }

  if (TimeHeld > RestoreDelay && !Released) { // do this when the time the button is held is longer than the delay and the button is released
    htime = millis();
    if (holdingRestore == 0) {
      FlashLED(CurrentROM);
      holdingRestore = 1;
      resetSystem = 1;
    } // first time this is run, so flash the LED with current slot and reset time held. Set the holding restore variable.
    else {
      // modified for fun: increment selected ROM, or reset to first
      CurrentRom++;
      if(CurrentRom>4) { CurrentRom=0; }

      SaveSlot(CurrentROM);

      if (TimeHeld > RestoreDelay) {
        TimeHeld = 0;
      } // reset the time held
      FlashLED(CurrentROM); //flash the LED
    }
  }

  if (Released) {
    //if time held greater than restore delay, reset the system, set the current rom slot, reselt the time held and holding restore
    if (resetSystem) { // on do this if the reset system has been set above
      htime = millis();
      resetSystem = 0;
      holdingRestore = 0;
      Released = 0;
      digitalWrite(ResetLine, LOW); // keep the system reset
      digitalWrite(EXROMLine, LOW); // keep the EXROM line low
      pinMode(ResetLine, OUTPUT);
      pinMode(EXROMLine, OUTPUT);
      digitalWrite(ResetLine, LOW); // keep the system reset
      digitalWrite(EXROMLine, LOW); // keep the EXROM line low
      delay(50); // wait 50ms
      SetSlot(CurrentROM); // select the appropriate kernal ROM
      delay(200); // wait 200ms before releasing RESET line
      pinMode(ResetLine, INPUT); // set the reset pin back to high impedance so computer boots
      delay(300); // wait 300ms before releasing EXROM line
      pinMode(EXROMLine, INPUT); // set the reset pin back to high impedance so computer boots
    } else { //otherwise do nothing
      htime = millis();
      Released = 0;
      resetSystem = 0;
      holdingRestore = 0;
    }
  }
  // finished with loop
}

int readButton() { // updated code I found elsewhere
 if (!digitalRead(RestoreKey) && (millis() - btime >= repeatdelay)) {
  for(int i = 0; i < 10; i++)
    {
      debouncereading = !digitalRead(RestoreKey);

      if(!debouncereading && debouncecounter > 0)
      {
        debouncecounter--;
      }
      if(debouncereading)
      {
        debouncecounter++; 
      }
      // If the Input has shown the same value for long enough let's switch it
      if(debouncecounter >= debounce_count)
      {
        btime = millis();
        debouncecounter = 0;
        RestoreHeld = 1;
      }
    delay (10); // wait 10ms
    }
   } else {
    RestoreHeld = 0;
   }
  return RestoreHeld;
}

void SaveSlot(int CurrentRomSlot) {
  // Save Current ROM selection (0-3) into EPROM
  EEPROM.write(1,CurrentRomSlot);
}

// More efficient way to flash the power LED
void FlashLED(int flashcount) {

  // Flash the LED to represent which ROM slot is selected
  for (int i = 0; i <= flashcount; i++) {
    digitalWrite(PowerLED, LOW);
    digitalWrite(PowerLEDAlt, LOW);
    delay(FlashSpeed);
    digitalWrite(PowerLED, HIGH);
    digitalWrite(PowerLEDAlt, HIGH);
    delay(FlashSpeed);
  }
}

// Note this can be done more effeicient with "and" (&1, &2) but this is more readable
void SetSlot(int DesiredRomSlot) {
    // Select the actual ROM slot being used
    switch (DesiredRomSlot) {
    case 0:
      digitalWrite(A13, LOW);
      digitalWrite(A14, LOW);
      break;
    case 1:
      digitalWrite(A13, HIGH);
      digitalWrite(A14, LOW);
      break;
    case 2:
      digitalWrite(A13, LOW);
      digitalWrite(A14, HIGH);
      break;
    case 3:
      digitalWrite(A13, HIGH);
      digitalWrite(A14, HIGH);
      break;
    default:
      digitalWrite(A13, LOW);
      digitalWrite(A14, LOW);
      break;
  }
}

Here the sketch as a file you can download:

@hans 

thanks ill give it a test! 

i just tried to upload it and its failing to compile 

Posted by: @mkube402

i just tried to upload it and its failing to compile 

Shoot, my apologies ... let me take a look.

Note: for next time, please post the error messages 😉 

So I did find that some characters got mangled through copy and paste (like the minus symbol), and a typo by me (CurrentROM), and a poorly chosen variable name by the original developer (time).

So this compiles, but again: I have no means to testing the code:

#include <EEPROM.h>

// C64 Kernel Switcher and Restore Key Reset/Selector
// By Adrian Black
// Modified version 1.1
//  https://www.tweaking4all.com/forum/miscellaneous-software/c64-arduino-kernal-switcher/ 

const int PowerLED = 4;      // Output Power LED
const int PowerLEDAlt = 13;  // Output Power LED (onboard LED)
const int A13 = 5;           // Output EPROM Address Line 13
const int A14 = 6;           // Output EPROM Address Line 14
const int ResetLine = 7;     // Output to /RESET line
const int EXROMLine = 3;     // Output the /EXROM line
const int RestoreKey = 8;    // Input Restore key

int RestoreDelay = 2000;  // 2000ms delay for restore key
const int FlashSpeed = 75; // LED Flash delay

const unsigned long repeatdelay = 500; // used for debouncing
 
int CurrentROM; // which rom is select (0-3)

int debouncecounter = 0;       // how many times we have seen new value (for debounce)
int debouncereading;
int debounce_count;
int RestoreHeld;
unsigned long TimeHeld; // amount of time Resotre is held down

int buttonDuration = 0; // for keeping track of how long restore is held down
boolean buttonHeld = 0; // for keeping track when you are holding down 
boolean Released = 0; // Keeping track when the restore key is released
boolean holdingRestore = 0; // Keeping track if you are holding restore
boolean resetSystem = 0; // keep track wheter to reset

int buttonInput; // used to return if restore is held
unsigned long ntime; //used to keep track of millis output (now)
unsigned long htime; //used to keep track of millis output (hold start)
unsigned long btime; //used to keep track of bounce millis output

void setup() {
  pinMode(PowerLED, OUTPUT);
  pinMode(PowerLEDAlt, OUTPUT);
  pinMode(A13, OUTPUT);
  pinMode(A14, OUTPUT);
  pinMode(ResetLine, INPUT);
  pinMode(EXROMLine, INPUT);
  pinMode(RestoreKey, INPUT);

  digitalWrite(PowerLED, HIGH); // turn on the power LED (Fixed typo?)

  digitalWrite(ResetLine, LOW); // keep the system reset
  pinMode(ResetLine, OUTPUT); // switch reset line to OUTPUT so it can hold it low
  digitalWrite(ResetLine, LOW); // keep the system reset

  CurrentROM = EEPROM.read(1);
  SetSlot(CurrentROM);
  delay(200);
  pinMode(ResetLine, INPUT); // set the reset pin back to high impedance which releases the INPUT line
  delay(1000); // wait 1000ms
  FlashLED(CurrentROM); // flash the power LED to show the current state

  // all set!
}

void loop() {
  buttonInput = readButton();
  delay(500);
  ntime = millis(); // load the number of milliseconds the arduino has been running into variable time
  if (buttonInput == 1) {
    if (!buttonHeld) {
      htime = ntime;
      TimeHeld = 0;
      buttonHeld = 1;
    } //restore button is pushed
    else {
      TimeHeld = ntime-htime;
    } // button is being held down, keep track of total time held.
  }
  if (buttonInput == 0) {
    if (buttonHeld) {
      Released = 1;
      buttonHeld = 0;
      htime = millis();
      TimeHeld = 0; //restore button not being held anymore
    }
  }

  if (TimeHeld > RestoreDelay && !Released) { // do this when the time the button is held is longer than the delay and the button is released
    htime = millis();
    if (holdingRestore == 0) {
      FlashLED(CurrentROM);
      holdingRestore = 1;
      resetSystem = 1;
    } // first time this is run, so flash the LED with current slot and reset time held. Set the holding restore variable.
    else {
      // modified for fun: increment selected ROM, or reset to first
      CurrentROM++;
      if(CurrentROM>4) { CurrentROM=0; }

      SaveSlot(CurrentROM);

      if (TimeHeld > RestoreDelay) {
        TimeHeld = 0;
      } // reset the time held
      FlashLED(CurrentROM); //flash the LED
    }
  }

  if (Released) {
    //if time held greater than restore delay, reset system, set current rom slot, reset time
    if (resetSystem) { // on do this if the reset system has been set above
      htime = millis();
      resetSystem = 0;
      holdingRestore = 0;
      Released = 0;
      digitalWrite(ResetLine, LOW); // keep the system reset
      digitalWrite(EXROMLine, LOW); // keep the EXROM line low
      pinMode(ResetLine, OUTPUT);
      pinMode(EXROMLine, OUTPUT);
      digitalWrite(ResetLine, LOW); // keep the system reset
      digitalWrite(EXROMLine, LOW); // keep the EXROM line low
      delay(50); // wait 50ms
      SetSlot(CurrentROM); // select the appropriate kernal ROM
      delay(200); // wait 200ms before releasing RESET line
      pinMode(ResetLine, INPUT); // set the reset pin back to high impedance so computer boots
      delay(300); // wait 300ms before releasing EXROM line
      pinMode(EXROMLine, INPUT); // set the reset pin back to high impedance so computer boots
    } else { //otherwise do nothing
      htime = millis();
      Released = 0;
      resetSystem = 0;
      holdingRestore = 0;
    }
  }
  // finished with loop
}

int readButton() { // updated code I found elsewhere
 if (!digitalRead(RestoreKey) && (millis() - btime >= repeatdelay)) {
  for(int i = 0; i < 10; i++)
    {
      debouncereading = !digitalRead(RestoreKey);

      if(!debouncereading && debouncecounter > 0)
      {
        debouncecounter--;
      }
      if(debouncereading)
      {
        debouncecounter++; 
      }
      // If the Input has shown the same value for long enough let's switch it
      if(debouncecounter >= debounce_count)
      {
        btime = millis();
        debouncecounter = 0;
        RestoreHeld = 1;
      }
    delay (10); // wait 10ms
    }
   } else {
    RestoreHeld = 0;
   }
  return RestoreHeld;
}

void SaveSlot(int CurrentRomSlot) {
  // Save Current ROM selection (0-3) into EPROM
  EEPROM.write(1,CurrentRomSlot);
}

// More efficient way to flash the power LED
void FlashLED(int flashcount) {

  // Flash the LED to represent which ROM slot is selected
  for (int i = 0; i <= flashcount; i++) {
    digitalWrite(PowerLED, LOW);
    digitalWrite(PowerLEDAlt, LOW);
    delay(FlashSpeed);
    digitalWrite(PowerLED, HIGH);
    digitalWrite(PowerLEDAlt, HIGH);
    delay(FlashSpeed);
  }
}

// Note this can be done more effeicient with "and" (&1, &2) but this is more readable
void SetSlot(int DesiredRomSlot) {
    // Select the actual ROM slot being used
    switch (DesiredRomSlot) {
    case 0:
      digitalWrite(A13, LOW);
      digitalWrite(A14, LOW);
      break;
    case 1:
      digitalWrite(A13, HIGH);
      digitalWrite(A14, LOW);
      break;
    case 2:
      digitalWrite(A13, LOW);
      digitalWrite(A14, HIGH);
      break;
    case 3:
      digitalWrite(A13, HIGH);
      digitalWrite(A14, HIGH);
      break;
    default:
      digitalWrite(A13, LOW);
      digitalWrite(A14, LOW);
      break;
  }
}

@hans Hi,

This code uses one LED and flashes number of times for the rom selected.

I have a color LED I want to use, how would it be possible to implement this in the code?

The basics of letting a LED flash and everything I know... but getting it her is a bit tricky for me, getting error all the time ;)

Hope you are willing to push me a bit in the right direction.

Hi Olaf,

not sure what type of color LED you're having in mind?
For example we have color LEDs with multiple pins (one common pin, and one pin per color), LEDs where RGB and are combined and need to be fed individually, or programmable color LEDs like the Ws2812 (used in LED strips for example).

p.s. the LED color selection should probably take place in the "FlashLED(int flashcount)" function.

@hans Thanks for the quick response, I want to use the one common and one per color LED. Will check the FlashLED section and see how far I will come.

I'd then assign each color to one pin on your Arduino and set the right ones high or low depending on the color you'd like.

Something like this should dot the trick I'd assume:

// x, y, z should be the pin numbers you'd like to use for the LED pins
#define LEDPIN_RED  x
#define LEDPIN_BLUE y
#define LEDPIN_WHITE z

...

// More efficient way to flash the power LED
void FlashLED(int selectedROMSlot) {
  // all colors OFF
  digitalWrite(LEDPIN_RED, LOW);
  digitalWrite(LEDPIN_BLUE, LOW);
  digitalWrite(LEDPIN_WHITE, LOW);
  
  // caution: CurrentROM counts from 0 to 3, however the 
  // previously used LED flash option probably uses 1 to 4 instead
  switch(selectedROMSlot) {
    case 1: digitalWrite(LEDPIN_RED, HIGH);
            break;
    case 2: digitalWrite(LEDPIN_BLUE, HIGH);
            break;
    case 3: digitalWrite(LEDPIN_WHITE, HIGH);
            break;
  }
}

Hope this helps 😊 

p.s. in case you have the schematics and/or related links available: please feel free to share them here for others 😊