SA-RPU.cpp

/**************************************************************************
 *     This file is part of the RPU for Arduino Project.

    I, Dick Hamill, the author of this program disclaim all copyright
    in order to make this program freely available in perpetuity to
    anyone who would like to use it. Dick Hamill, 3/31/2023

    RPU is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    RPU is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    See <https://www.gnu.org/licenses/>.
 */


 
#include <Arduino.h>
#include <EEPROM.h>
//#define DEBUG_MESSAGES    1
#define RPU_CPP_FILE
#include "RPU_config.h"
#include "SA-RPU.h"

#ifndef RPU_OS_HARDWARE_REV
#define RPU_OS_HARDWARE_REV 1
#endif

/******************************************************
 *   The board type, MPU architecture, and supported
 *   features are all controlled through the 
 *   RPU_Config.h file. 
 */
#include "RPU_Config.h"


/******************************************************
 *   Defines and library variables
 */
#if (RPU_MPU_ARCHITECTURE >= 10) 
#define NUM_SWITCH_BYTES              8
#define MAX_NUM_SWITCHES              64
#ifndef INTERRUPT_OCR1A_COUNTER
#define INTERRUPT_OCR1A_COUNTER         16574
#endif

volatile byte BoardLEDs = 0;
volatile boolean UpDownSwitch = false;
unsigned short ContinuousSolenoidBits = 0;

volatile byte DisplayCreditDigits[2];
volatile byte DisplayCreditDigitEnable;
volatile byte DisplayBIPDigits[2];
volatile byte DisplayBIPDigitEnable;

#endif // End of condition based on RPU_MPU_ARCHITECTURE

// Global variables
volatile byte DisplayDigits[5][RPU_OS_NUM_DIGITS];
volatile byte DisplayDigitEnable[5];
volatile boolean DisplayOffCycle = false;
volatile byte CurrentDisplayDigit=0;
volatile byte LampStates[RPU_NUM_LAMP_BANKS], LampDim1[RPU_NUM_LAMP_BANKS], LampDim2[RPU_NUM_LAMP_BANKS];
volatile byte LampFlashPeriod[RPU_MAX_LAMPS];
byte DimDivisor1 = 2;
byte DimDivisor2 = 3;

volatile byte SwitchesMinus2[NUM_SWITCH_BYTES];
volatile byte SwitchesMinus1[NUM_SWITCH_BYTES];
volatile byte SwitchesNow[NUM_SWITCH_BYTES];
#ifdef RPU_OS_USE_DIP_SWITCHES
byte DipSwitches[4];
#endif


#define SOLENOID_STACK_SIZE 60
#define SOLENOID_STACK_EMPTY 0xFF
volatile byte SolenoidStackFirst;
volatile byte SolenoidStackLast;
volatile byte SolenoidStack[SOLENOID_STACK_SIZE];
boolean SolenoidStackEnabled = true;
volatile byte CurrentSolenoidByte = 0xFF;
volatile byte RevertSolenoidBit = 0x00;
volatile byte NumCyclesBeforeRevertingSolenoidByte = 0;

#define TIMED_SOLENOID_STACK_SIZE 30
struct TimedSolenoidEntry {
  byte inUse;
  unsigned long pushTime;
  byte solenoidNumber;
  byte numPushes;
  byte disableOverride;
};
TimedSolenoidEntry TimedSolenoidStack[TIMED_SOLENOID_STACK_SIZE] = {0, 0, 0, 0, 0};

#define SWITCH_STACK_SIZE   60
#define SWITCH_STACK_EMPTY  0xFF
volatile byte SwitchStackFirst;
volatile byte SwitchStackLast;
volatile byte SwitchStack[SWITCH_STACK_SIZE];


// The WTYPE1 and WTYPE2 sound cards can only play one sound at a time,
// so these structures allow the app to send in as many calls as they
// want, but with a priority and requested amount of time to let 
// it play. This could be ported over to other architectures 
// like S&T or -51, etc., but right now I've only implemented it for
// MPU Architecture > 9
#if (RPU_MPU_ARCHITECTURE >= 10) 

#define SOUND_STACK_SIZE  64
#define SOUND_STACK_EMPTY 0x0000
volatile byte SoundStackFirst;
volatile byte SoundStackLast;
volatile unsigned short SoundStack[SOUND_STACK_SIZE];

#define TIMED_SOUND_STACK_SIZE  20
struct TimedSoundEntry {
  byte inUse;
  unsigned long pushTime;
  unsigned short soundNumber;
  byte numPushes;
};
TimedSoundEntry TimedSoundStack[TIMED_SOUND_STACK_SIZE] = {0, 0, 0, 0};
#endif


#if (RPU_OS_HARDWARE_REV>=100)
#if (RPU_MPU_ARCHITECTURE<10)
#define ADDRESS_U10_A           0x88
#define ADDRESS_U10_A_CONTROL   0x89
#define ADDRESS_U10_B           0x8A
#define ADDRESS_U10_B_CONTROL   0x8B
#define ADDRESS_U11_A           0x90
#define ADDRESS_U11_A_CONTROL   0x91
#define ADDRESS_U11_B           0x92
#define ADDRESS_U11_B_CONTROL   0x93
#define ADDRESS_SB100           0xA0
#define ADDRESS_SB100_CHIMES    0xC0
#define ADDRESS_SB300_SQUARE_WAVES  0xA0
#define ADDRESS_SB300_ANALOG        0xC0
#else
#define PIA_DISPLAY_PORT_A      0x2800
#define PIA_DISPLAY_CONTROL_A   0x2801
#define PIA_DISPLAY_PORT_B      0x2802
#define PIA_DISPLAY_CONTROL_B   0x2803
#define PIA_SWITCH_PORT_A       0x3000
#define PIA_SWITCH_CONTROL_A    0x3001
#define PIA_SWITCH_PORT_B       0x3002
#define PIA_SWITCH_CONTROL_B    0x3003
#define PIA_LAMPS_PORT_A        0x2400
#define PIA_LAMPS_CONTROL_A     0x2401
#define PIA_LAMPS_PORT_B        0x2402
#define PIA_LAMPS_CONTROL_B     0x2403
#define PIA_SOLENOID_PORT_A     0x2200
#define PIA_SOLENOID_CONTROL_A  0x2201
#define PIA_SOLENOID_PORT_B     0x2202
#define PIA_SOLENOID_CONTROL_B  0x2203
#if (RPU_MPU_ARCHITECTURE==13)
#define PIA_SOUND_COMMA_PORT_A      0x2100
#define PIA_SOUND_COMMA_CONTROL_A   0x2101
#define PIA_SOUND_COMMA_PORT_B      0x2102
#define PIA_SOUND_COMMA_CONTROL_B   0x2103
#endif
#if (RPU_MPU_ARCHITECTURE==15)
#define PIA_SOUND_11_PORT_A             0x2100
#define PIA_SOUND_11_CONTROL_A          0x2101
#define PIA_SOLENOID_11_PORT_B          0x2102
#define PIA_SOLENOID_11_CONTROL_B       0x2103
#define PIA_ALPHA_DISPLAY_PORT_A        0x2C00
#define PIA_ALPHA_DISPLAY_CONTROL_A     0x2C01
#define PIA_ALPHA_DISPLAY_PORT_B        0x2C02
#define PIA_ALPHA_DISPLAY_CONTROL_B     0x2C03
#define PIA_NUM_DISPLAY_PORT_A          0x3400
#define PIA_NUM_DISPLAY_CONTROL_A       0x3401
#define PIA_WIDGET_PORT_B               0x3402
#define PIA_WIDGET_CONTROL_B            0x3403
#endif
#endif

#endif 


#if (RPU_OS_HARDWARE_REV==1000)

void RPU_DataWrite(int portAddress, byte val) {
  // STM32 port mapping here to pins or internal registers 
}

byte RPU_DataRead(int portAddress) {
  // STM32 port mapping here to pins or internal registers 
  return 0xFF;
}

#else
#error "RPU Hardware Definition Not Recognized"
#endif


void RPU_InitializePIAs() {
  RPU_DataWrite(PIA_DISPLAY_CONTROL_A, 0x31);
  RPU_DataWrite(PIA_DISPLAY_PORT_A, 0xFF);
  RPU_DataWrite(PIA_DISPLAY_CONTROL_A, 0x3D);
  RPU_DataWrite(PIA_DISPLAY_PORT_A, 0xC0);

  RPU_DataWrite(PIA_DISPLAY_CONTROL_B, 0x31);
  RPU_DataWrite(PIA_DISPLAY_PORT_B, 0xFF);
  RPU_DataWrite(PIA_DISPLAY_CONTROL_B, 0x3D);
  RPU_DataWrite(PIA_DISPLAY_PORT_B, 0x00);

  RPU_DataWrite(PIA_SWITCH_CONTROL_A, 0x38);
  RPU_DataWrite(PIA_SWITCH_PORT_A, 0x00);
  RPU_DataWrite(PIA_SWITCH_CONTROL_A, 0x3C);

  RPU_DataWrite(PIA_SWITCH_CONTROL_B, 0x38);
  RPU_DataWrite(PIA_SWITCH_PORT_B, 0xFF);
  RPU_DataWrite(PIA_SWITCH_CONTROL_B, 0x3C);
  RPU_DataWrite(PIA_SWITCH_PORT_B, 0x00);

  RPU_DataWrite(PIA_LAMPS_CONTROL_A, 0x38);
  RPU_DataWrite(PIA_LAMPS_PORT_A, 0xFF);
  RPU_DataWrite(PIA_LAMPS_CONTROL_A, 0x3C);
  RPU_DataWrite(PIA_LAMPS_PORT_A, 0xFF);  

  RPU_DataWrite(PIA_LAMPS_CONTROL_B, 0x38);
  RPU_DataWrite(PIA_LAMPS_PORT_B, 0xFF);
  RPU_DataWrite(PIA_LAMPS_CONTROL_B, 0x3C);
  RPU_DataWrite(PIA_LAMPS_PORT_B, 0x00);

#if (RPU_MPU_ARCHITECTURE<15)
  RPU_DataWrite(PIA_SOLENOID_CONTROL_A, 0x38);
  RPU_DataWrite(PIA_SOLENOID_PORT_A, 0xFF);
  RPU_DataWrite(PIA_SOLENOID_CONTROL_A, 0x3C);
#endif
  RPU_DataWrite(PIA_SOLENOID_PORT_A, 0x00);

#if (RPU_MPU_ARCHITECTURE<15)
  RPU_DataWrite(PIA_SOLENOID_CONTROL_B, 0x30);
  RPU_DataWrite(PIA_SOLENOID_PORT_B, 0xFF);
  RPU_DataWrite(PIA_SOLENOID_CONTROL_B, 0x34);
  RPU_DataWrite(PIA_SOLENOID_PORT_B, 0x00);
#endif

#if (RPU_MPU_ARCHITECTURE==15)
  RPU_DataWrite(PIA_SOLENOID_11_CONTROL_B, 0x38);
  RPU_DataWrite(PIA_SOLENOID_11_PORT_B, 0xFF);
  RPU_DataWrite(PIA_SOLENOID_11_CONTROL_B, 0x3C);
  RPU_DataWrite(PIA_SOLENOID_11_PORT_B, 0x00);

  RPU_DataWrite(PIA_ALPHA_DISPLAY_CONTROL_A, 0x38);
  RPU_DataWrite(PIA_ALPHA_DISPLAY_PORT_A, 0xFF);
  RPU_DataWrite(PIA_ALPHA_DISPLAY_CONTROL_A, 0x3C);
  RPU_DataWrite(PIA_ALPHA_DISPLAY_PORT_A, 0x00);

  RPU_DataWrite(PIA_ALPHA_DISPLAY_CONTROL_B, 0x38);
  RPU_DataWrite(PIA_ALPHA_DISPLAY_PORT_B, 0xFF);
  RPU_DataWrite(PIA_ALPHA_DISPLAY_CONTROL_B, 0x3C);
  RPU_DataWrite(PIA_ALPHA_DISPLAY_PORT_B, 0x00);

  RPU_DataWrite(PIA_NUM_DISPLAY_CONTROL_A, 0x38);
  RPU_DataWrite(PIA_NUM_DISPLAY_PORT_A, 0xFF);
  RPU_DataWrite(PIA_NUM_DISPLAY_CONTROL_A, 0x3C);
  RPU_DataWrite(PIA_NUM_DISPLAY_PORT_A, 0x00);

  RPU_DataWrite(PIA_SOUND_11_CONTROL_A, 0x38);
  RPU_DataWrite(PIA_SOUND_11_PORT_A, 0xFF);
  RPU_DataWrite(PIA_SOUND_11_CONTROL_A, 0x3C);
  RPU_DataWrite(PIA_SOUND_11_PORT_A, 0x00);

  RPU_DataWrite(PIA_WIDGET_CONTROL_B, 0x38);
  RPU_DataWrite(PIA_WIDGET_PORT_B, 0xFF);
  RPU_DataWrite(PIA_WIDGET_CONTROL_B, 0x3C);
  RPU_DataWrite(PIA_WIDGET_PORT_B, 0x00);
#endif

#if (RPU_MPU_ARCHITECTURE==13)
  RPU_DataWrite(PIA_SOUND_COMMA_CONTROL_A, 0x38);
  RPU_DataWrite(PIA_SOUND_COMMA_PORT_A, 0xFF);
  RPU_DataWrite(PIA_SOUND_COMMA_CONTROL_A, 0x3C);
  RPU_DataWrite(PIA_SOUND_COMMA_PORT_A, 0x00);  

  RPU_DataWrite(PIA_SOUND_COMMA_CONTROL_B, 0x38);
  RPU_DataWrite(PIA_SOUND_COMMA_PORT_B, 0xFF);
  RPU_DataWrite(PIA_SOUND_COMMA_CONTROL_B, 0x3C);
  RPU_DataWrite(PIA_SOUND_COMMA_PORT_B, 0x00);
#endif

}


unsigned long RPU_TestPIAs() {
  unsigned long piaErrors = 0;
  
  byte piaResult = RPU_DataRead(PIA_DISPLAY_CONTROL_A);
  if (piaResult!=0x3D) piaErrors |= RPU_RET_PIA_1_ERROR;
  piaResult = RPU_DataRead(PIA_DISPLAY_CONTROL_B);
  if (piaResult!=0x3D) piaErrors |= RPU_RET_PIA_1_ERROR;

  piaResult = RPU_DataRead(PIA_SWITCH_CONTROL_A);
  if (piaResult!=0x3C) piaErrors |= RPU_RET_PIA_2_ERROR;
  piaResult = RPU_DataRead(PIA_SWITCH_CONTROL_B);
  if (piaResult!=0x3C) piaErrors |= RPU_RET_PIA_2_ERROR;
  
  piaResult = RPU_DataRead(PIA_LAMPS_CONTROL_A);
  if (piaResult!=0x3C) piaErrors |= RPU_RET_PIA_3_ERROR;
  piaResult = RPU_DataRead(PIA_LAMPS_CONTROL_B);
  if (piaResult!=0x3C) piaErrors |= RPU_RET_PIA_3_ERROR;

  piaResult = RPU_DataRead(PIA_SOLENOID_CONTROL_A);
  if (piaResult!=0x3C) piaErrors |= RPU_RET_PIA_4_ERROR;
  piaResult = RPU_DataRead(PIA_SOLENOID_CONTROL_B);
  if (piaResult!=0x3C) piaErrors |= RPU_RET_PIA_4_ERROR;

#if (RPU_MPU_ARCHITECTURE==13)
  piaResult = RPU_DataRead(PIA_SOUND_COMMA_CONTROL_A);
  if (piaResult!=0x3C) piaErrors |= RPU_RET_PIA_5_ERROR;
  piaResult = RPU_DataRead(PIA_SOUND_COMMA_CONTROL_B);
  if (piaResult!=0x3C) piaErrors |= RPU_RET_PIA_5_ERROR;
#endif

  return piaErrors;
}

void RPU_SetBoardLEDs(boolean LED1, boolean LED2, byte BCDValue) {
  BoardLEDs = 0;
  if (BCDValue==0xFF) {
    if (LED1) BoardLEDs |= 0x20;
    if (LED2) BoardLEDs |= 0x10;
  } else {
    BoardLEDs = BCDValue * 16;
  }
}




/******************************************************
 *   Switch Handling Functions
 */

int SpaceLeftOnSwitchStack() {
  if (SwitchStackFirst>=SWITCH_STACK_SIZE || SwitchStackLast>=SWITCH_STACK_SIZE) return 0;
  if (SwitchStackLast>=SwitchStackFirst) return ((SWITCH_STACK_SIZE-1) - (SwitchStackLast-SwitchStackFirst));
  return (SwitchStackFirst - SwitchStackLast) - 1;
}

void PushToSwitchStack(byte switchNumber) {
  //if ((switchNumber>=MAX_NUM_SWITCHES && switchNumber!=SW_SELF_TEST_SWITCH)) return;
  if (switchNumber==SWITCH_STACK_EMPTY) return;

  // If the switch stack last index is out of range, then it's an error - return
  if (SpaceLeftOnSwitchStack()==0) return;

  // Self test is a special case - there's no good way to debounce it
  // so if it's already first on the stack, ignore it
  if (switchNumber==SW_SELF_TEST_SWITCH) {
    if (SwitchStackLast!=SwitchStackFirst && SwitchStack[SwitchStackFirst]==SW_SELF_TEST_SWITCH) return;
  }

  SwitchStack[SwitchStackLast] = switchNumber;
  
  SwitchStackLast += 1;
  if (SwitchStackLast==SWITCH_STACK_SIZE) {
    // If the end index is off the end, then wrap
    SwitchStackLast = 0;
  }
}

void RPU_PushToSwitchStack(byte switchNumber) {
  PushToSwitchStack(switchNumber);
}


byte RPU_PullFirstFromSwitchStack() {
  // If first and last are equal, there's nothing on the stack
  if (SwitchStackFirst==SwitchStackLast) return SWITCH_STACK_EMPTY;

  byte retVal = SwitchStack[SwitchStackFirst];

  SwitchStackFirst += 1;
  if (SwitchStackFirst>=SWITCH_STACK_SIZE) SwitchStackFirst = 0;

  return retVal;
}


boolean RPU_ReadSingleSwitchState(byte switchNum) {
  if (switchNum>=MAX_NUM_SWITCHES) return false;

  int switchByte = switchNum/8;
  int switchBit = switchNum%8;
  if ( ((SwitchesNow[switchByte])>>switchBit) & 0x01 ) return true;
  else return false;
}


byte RPU_GetDipSwitches(byte index) {
#ifdef RPU_OS_USE_DIP_SWITCHES
  if (index>3) return 0x00;
  return DipSwitches[index];
#else
  return 0x00 & index;
#endif
}


void RPU_SetupGameSwitches(int s_numSwitches, int s_numPrioritySwitches, PlayfieldAndCabinetSwitch *s_gameSwitchArray) {
  NumGameSwitches = s_numSwitches;
  NumGamePrioritySwitches = s_numPrioritySwitches;
  GameSwitches = s_gameSwitchArray;
}


void RPU_ClearUpDownSwitchState() {
  UpDownSwitch = false;
}

boolean RPU_GetUpDownSwitchState() {
  return UpDownSwitch;
}

byte RPU_GetSwitchCount() {
#if (RPU_MPU_ARCHITECTURE>=10)
  return MAX_NUM_SWITCHES + 3; // added one for self-test switch, one for up/down, and one for clear high score
#else 
  return MAX_NUM_SWITCHES + 1; // added one for self-test switch
#endif
}



/******************************************************
 *   Solenoid Handling Functions
 */

int SpaceLeftOnSolenoidStack() {
  if (SolenoidStackFirst>=SOLENOID_STACK_SIZE || SolenoidStackLast>=SOLENOID_STACK_SIZE) return 0;
  if (SolenoidStackLast>=SolenoidStackFirst) return ((SOLENOID_STACK_SIZE-1) - (SolenoidStackLast-SolenoidStackFirst));
  return (SolenoidStackFirst - SolenoidStackLast) - 1;
}


void RPU_PushToSolenoidStack(byte solenoidNumber, byte numPushes, boolean disableOverride) {
  if (solenoidNumber>14) return;

  // if the solenoid stack is disabled and this isn't an override push, then return
  if (!disableOverride && !SolenoidStackEnabled) return;

  // If the solenoid stack last index is out of range, then it's an error - return
  if (SpaceLeftOnSolenoidStack()==0) return;

  for (int count=0; count<numPushes; count++) {
    SolenoidStack[SolenoidStackLast] = solenoidNumber;
    
    SolenoidStackLast += 1;
    if (SolenoidStackLast==SOLENOID_STACK_SIZE) {
      // If the end index is off the end, then wrap
      SolenoidStackLast = 0;
    }
    // If the stack is now full, return
    if (SpaceLeftOnSolenoidStack()==0) return;
  }
}

void PushToFrontOfSolenoidStack(byte solenoidNumber, byte numPushes) {
  // If the stack is full, return
  if (SpaceLeftOnSolenoidStack()==0  || !SolenoidStackEnabled) return;

  for (int count=0; count<numPushes; count++) {
    if (SolenoidStackFirst==0) SolenoidStackFirst = SOLENOID_STACK_SIZE-1;
    else SolenoidStackFirst -= 1;
    SolenoidStack[SolenoidStackFirst] = solenoidNumber;
    if (SpaceLeftOnSolenoidStack()==0) return;
  }
  
}

byte PullFirstFromSolenoidStack() {
  // If first and last are equal, there's nothing on the stack
  if (SolenoidStackFirst==SolenoidStackLast) return SOLENOID_STACK_EMPTY;
  
  byte retVal = SolenoidStack[SolenoidStackFirst];

  SolenoidStackFirst += 1;
  if (SolenoidStackFirst>=SOLENOID_STACK_SIZE) SolenoidStackFirst = 0;

  return retVal;
}

boolean RPU_PushToTimedSolenoidStack(byte solenoidNumber, byte numPushes, unsigned long whenToFire, boolean disableOverride) {
  for (int count=0; count<TIMED_SOLENOID_STACK_SIZE; count++) {
    if (!TimedSolenoidStack[count].inUse) {
      TimedSolenoidStack[count].inUse = true;
      TimedSolenoidStack[count].pushTime = whenToFire;
      TimedSolenoidStack[count].disableOverride = disableOverride;
      TimedSolenoidStack[count].solenoidNumber = solenoidNumber;
      TimedSolenoidStack[count].numPushes = numPushes;
      return true;
    }
  }
  return false;
}

void RPU_UpdateTimedSolenoidStack(unsigned long curTime) {
  for (int count=0; count<TIMED_SOLENOID_STACK_SIZE; count++) {
    if (TimedSolenoidStack[count].inUse && TimedSolenoidStack[count].pushTime<curTime) {
      RPU_PushToSolenoidStack(TimedSolenoidStack[count].solenoidNumber, TimedSolenoidStack[count].numPushes, TimedSolenoidStack[count].disableOverride);
      TimedSolenoidStack[count].inUse = false;
    }
  }
}



void RPU_SetDisableFlippers(boolean disableFlippers, byte solbit) {
  (void)solbit;
  if (disableFlippers) RPU_DataWrite(PIA_SOLENOID_CONTROL_B, 0x34);
  else RPU_DataWrite(PIA_SOLENOID_CONTROL_B, 0x3C);
}


void RPU_SetContinuousSolenoid(boolean solOn, byte solNum) {
  unsigned short oldCont = ContinuousSolenoidBits;
  if (solOn) ContinuousSolenoidBits |= (1<<solNum);
  else ContinuousSolenoidBits &= ~(1<<solNum);

  if (oldCont!=ContinuousSolenoidBits) {
    byte origPortA = RPU_DataRead(PIA_SOLENOID_PORT_A);
    byte origPortB = RPU_DataRead(PIA_SOLENOID_PORT_B);
    if (origPortA!=(ContinuousSolenoidBits&0xFF)) RPU_DataWrite(PIA_SOLENOID_PORT_A, (ContinuousSolenoidBits&0xFF));
    if (origPortB!=(ContinuousSolenoidBits/256)) RPU_DataWrite(PIA_SOLENOID_PORT_B, (ContinuousSolenoidBits/256));
  }
}

byte RPU_ReadContinuousSolenoids() {
  return ContinuousSolenoidBits;
}


void RPU_SetCoinLockout(boolean lockoutOn, byte solNum) {
  RPU_SetContinuousSolenoid(lockoutOn, solNum);  
}

void RPU_DisableSolenoidStack() {
  SolenoidStackEnabled = false;
  RPU_DataWrite(PIA_SOLENOID_CONTROL_B, 0x34);
}


void RPU_EnableSolenoidStack() {
  SolenoidStackEnabled = true;
  RPU_DataWrite(PIA_SOLENOID_CONTROL_B, 0x3C);
}


byte RPU_GetSolenoidCount() {
  // 16 pulsed and 6 triggered solenoids
  return 16 + 6;  
}

boolean RPU_GetSolenoidStatus(byte solNumber) {
  boolean solOn = false;
  if (solNumber>21) return false;
  if (solNumber>15) {
    // TODO:
    // Caller is asking for the status of a triggered
    // solenoid. We can't tell if it's triggered on, 
    // but we can tell if it's turned on by software
  } else {
    unsigned short currentSolenoids = 0;
    // For System 4, 6, and 7 architectures, 
    // all solenoids are on PIA_SOLENOID_PORT_A and PORT_B    
#if (RPU_MPU_ARCHITECTURE<15)
    currentSolenoids = RPU_DataRead(PIA_SOLENOID_PORT_A);
    currentSolenoids += ((unsigned short)RPU_DataRead(PIA_SOLENOID_PORT_B))*256;
#else 
    currentSolenoids = Sys11LastLowerSol;
    currentSolenoids += ((unsigned short)RPU_DataRead(PIA_SOLENOID_11_PORT_B))*256;
#endif    
    if (currentSolenoids & (1<<solNumber)) solOn = true;
  }
  return solOn;
}

byte RPU_ConvertMSToSolenoidTime(byte solMilliseconds) {
  // ISR runs at 960, and solenoids are decremented every other time  
  // so it's just about 2ms per tick
  return solMilliseconds / 2; 
}





/******************************************************
 *   Display Handling Functions
 */
#if (RPU_MPU_ARCHITECTURE<15)
byte RPU_SetDisplay(int displayNumber, unsigned long value, boolean blankByMagnitude, byte minDigits) {
  if (displayNumber<0 || displayNumber>4) return 0;

  byte blank = 0x00;

  for (int count=0; count<RPU_OS_NUM_DIGITS; count++) {
    blank = blank * 2;
    if (value!=0 || count<minDigits) blank |= 1;
    DisplayDigits[displayNumber][(RPU_OS_NUM_DIGITS-1)-count] = value%10;
    value /= 10;    
  }

  if (blankByMagnitude) DisplayDigitEnable[displayNumber] = blank;

  return blank;
}

byte RPU_SetDisplayBCDArray(int displayNumber, byte *bcdArray, boolean blankByMagnitude) {
  if (displayNumber<0 || displayNumber>5) return 0;
  boolean bcdDataFinished = false;
  byte blank = 0x00;
  byte curBlankBit = 0x01;
  byte curBCD;

  if (displayNumber<4) {
    for (byte count=0; count<RPU_OS_NUM_DIGITS; count++) {      
      curBCD = bcdArray[count];
      if (!bcdDataFinished && curBCD!=0) {
        if (curBCD>='0' && curBCD<='9') {
          DisplayDigits[displayNumber][count] = curBCD - '0';
          blank |= curBlankBit;
        } else {
          DisplayDigits[displayNumber][count] = 0x0F;
        }
      } else {
        bcdDataFinished = true;
      }
      curBlankBit *= 2;
    }
    if (blankByMagnitude) DisplayDigitEnable[displayNumber] = blank;
  } else {
    if (displayNumber==4) {
      // Credit display

#if (RPU_MPU_ARCHITECTURE<15)
      curBCD = bcdArray[0];
      if (curBCD>='0' && curBCD<='9') {
        DisplayCreditDigits[0] = curBCD - '0';
        blank |= 1;
      }
      curBCD = bcdArray[1];
      if (curBCD>='0' && curBCD<='9') {
        DisplayCreditDigits[1] = curBCD - '0';
        blank |= 2;
      }
      if (blankByMagnitude) DisplayCreditDigitEnable = blank;
#endif       
    } else if (displayNumber==5) {
      // BIP display
#if (RPU_MPU_ARCHITECTURE<15)
      curBCD = bcdArray[0];
      if (curBCD>='0' && curBCD<='9') {
        DisplayBIPDigits[0] = curBCD - '0';
        blank |= 1;
      }
      curBCD = bcdArray[1];
      if (curBCD>='0' && curBCD<='9') {
        DisplayBIPDigits[1] = curBCD - '0';
        blank |= 2;
      }
      if (blankByMagnitude) DisplayBIPDigitEnable = blank;
#endif         
    }
  }
  
  return blank;
}

#endif


#if (RPU_MPU_ARCHITECTURE<15)

void RPU_SetDisplayCredits(int value, boolean displayOn, boolean showBothDigits) {
  byte blank = 0x02;
  value = value % 100;
  if (value>=10) {
    DisplayCreditDigits[0] = value/10;
    blank |= 1;
  } else {
    DisplayCreditDigits[0] = 0;
    if (showBothDigits) blank |= 1;
  }
  DisplayCreditDigits[1] = value%10;
  if (displayOn) DisplayCreditDigitEnable = blank;
  else DisplayCreditDigitEnable = 0;
}

void RPU_SetDisplayBallInPlay(int value, boolean displayOn, boolean showBothDigits) {
  byte blank = 0x02;
  value = value % 100;
  if (value>=10) {
    DisplayBIPDigits[0] = value/10;
    blank |= 1;
  } else {
    DisplayBIPDigits[0] = 0;
    if (showBothDigits) blank |= 1;
  }
  DisplayBIPDigits[1] = value%10;
  if (displayOn) DisplayBIPDigitEnable = blank;
  else DisplayBIPDigitEnable = 0;  
}

#endif

void RPU_CycleAllDisplays(unsigned long curTime, byte digitNum) {
  int displayDigit = (curTime/250)%10;
  unsigned long value;
#if (RPU_OS_NUM_DIGITS==7)
  value = displayDigit*1111111;
#else  
  value = displayDigit*111111;
#endif

  byte displayNumToShow = 0;
  byte displayBlank = RPU_OS_ALL_DIGITS_MASK;

  if (digitNum!=0) {
    displayNumToShow = (digitNum-1)/6;
#if (RPU_OS_NUM_DIGITS==7)
    displayBlank = (0x40)>>((digitNum-1)%7);
#else    
    displayBlank = (0x20)>>((digitNum-1)%6);
#endif    
  }

  for (int count=0; count<5; count++) {
    if (digitNum) {
      RPU_SetDisplay(count, value);
      if (count==displayNumToShow) RPU_SetDisplayBlank(count, displayBlank);
      else RPU_SetDisplayBlank(count, 0);
    } else {
      RPU_SetDisplay(count, value, true);
    }
  }
}

void RPU_SetDisplayMatch(int value, boolean displayOn, boolean showBothDigits) {
  RPU_SetDisplayBallInPlay(value, displayOn, showBothDigits);
}


// This is confusing -
// Digit mask is like this
//   bit=   b7 b6 b5 b4 b3 b2 b1 b0
//   digit=  x  x  6  5  4  3  2  1
//   (with digit 6 being the least-significant, 1's digit
//  
// so, looking at it from left to right on the display
//   digit=  1  2  3  4  5  6
//   bit=   b0 b1 b2 b3 b4 b5
void RPU_SetDisplayBlank(int displayNumber, byte bitMask) {
  if (displayNumber<0 || displayNumber>4) return;
    
  DisplayDigitEnable[displayNumber] = bitMask;
}

byte RPU_GetDisplayBlank(int displayNumber) {
  if (displayNumber<0 || displayNumber>4) return 0;
  return DisplayDigitEnable[displayNumber];
}



void RPU_SetDisplayFlash(int displayNumber, unsigned long value, unsigned long curTime, int period, byte minDigits) {
  // A period of zero toggles display every other time
  if (period) {
    if ((curTime/period)%2) {
      RPU_SetDisplay(displayNumber, value, true, minDigits);
    } else {
      RPU_SetDisplayBlank(displayNumber, 0);
    }
  }
  
}

void RPU_SetDisplayFlashCredits(unsigned long curTime, int period) {
  if (period) {
    if ((curTime/period)%2) {
      DisplayDigitEnable[4] |= 0x06;
    } else {
      DisplayDigitEnable[4] &= 0x39;
    }
  }
}


#if (RPU_MPU_ARCHITECTURE==15)
byte RPU_SetDisplayText(int displayNumber, char *text, boolean blankByLength) {
  if (displayNumber>1 || displayNumber<0) return 0;
  byte stringLength = 0xff;
  boolean writeSpace = false;
  byte blank = 0;
  byte placeMask = 0x01;

  for (stringLength=0; stringLength<RPU_OS_NUM_DIGITS; stringLength++) {
    if (text[stringLength]==0) writeSpace = true;
    if (!writeSpace) DisplayText[displayNumber][stringLength] = (byte)text[stringLength]-0x20;
    else DisplayText[displayNumber][stringLength] = 0;

    if (DisplayText[displayNumber][stringLength]) blank |= placeMask;
    placeMask *= 2;
  }

  if (blankByLength) DisplayDigitEnable[displayNumber] = blank;

  return stringLength;
}

// Architectures with alpha store numbers as 7-seg
byte RPU_SetDisplay(int displayNumber, unsigned long value, boolean blankByMagnitude, byte minDigits) {
  if (displayNumber<0 || displayNumber>3) return 0;

  byte blank = 0x00;

  for (int count=0; count<RPU_OS_NUM_DIGITS; count++) {
    blank = blank * 2;
    if (value!=0 || count<minDigits) {
      blank |= 1;
      if (displayNumber/2) DisplayDigits[displayNumber][(RPU_OS_NUM_DIGITS-1)-count] = SevenSegmentNumbers[value%10];
      else DisplayText[displayNumber][(RPU_OS_NUM_DIGITS-1)-count] = (value%10)+16;
    } else {
      if (displayNumber/2) DisplayDigits[displayNumber][(RPU_OS_NUM_DIGITS-1)-count] = 0;
      else DisplayText[displayNumber][(RPU_OS_NUM_DIGITS-1)-count] = 0;
    }
    value /= 10;    
  }
  
  if (blankByMagnitude) DisplayDigitEnable[displayNumber] = blank;
  
  return blank;
}


void RPU_SetDisplayCredits(int value, boolean displayOn, boolean showBothDigits) {
  byte blank = 0x02;
  value = value % 100;
  if (value>=10) {
    DisplayCreditDigits[0] = SevenSegmentNumbers[value/10];
    blank |= 1;
  } else {
    DisplayCreditDigits[0] = SevenSegmentNumbers[0];
    if (showBothDigits) blank |= 1;
  }
  DisplayCreditDigits[1] = SevenSegmentNumbers[value%10];
  if (displayOn) DisplayCreditDigitEnable = blank;
  else DisplayCreditDigitEnable = 0;
}

void RPU_SetDisplayBallInPlay(int value, boolean displayOn, boolean showBothDigits) {
  byte blank = 0x02;
  value = value % 100;
  if (value>=10) {
    DisplayBIPDigits[0] = SevenSegmentNumbers[value/10];
    blank |= 1;
  } else {
    DisplayBIPDigits[0] = SevenSegmentNumbers[0];
    if (showBothDigits) blank |= 1;
  }
  DisplayBIPDigits[1] = SevenSegmentNumbers[value%10];
  if (displayOn) DisplayBIPDigitEnable = blank;
  else DisplayBIPDigitEnable = 0;  
}

#endif


/******************************************************
 *   Lamp Handling Functions
 */

void RPU_SetDimDivisor(byte level, byte divisor) {
  if (level==1) DimDivisor1 = divisor;
  if (level==2) DimDivisor2 = divisor;
}

void RPU_SetLampState(int lampNum, byte s_lampState, byte s_lampDim, int s_lampFlashPeriod) {
  if (lampNum>=RPU_MAX_LAMPS || lampNum<0) return;
  
  if (s_lampState) {
    int adjustedLampFlash = s_lampFlashPeriod/50;
    
    if (s_lampFlashPeriod!=0 && adjustedLampFlash==0) adjustedLampFlash = 1;
    if (adjustedLampFlash>250) adjustedLampFlash = 250;
    
    // Only turn on the lamp if there's no flash, because if there's a flash
    // then the lamp will be turned on by the ApplyFlashToLamps function
    if (s_lampFlashPeriod==0) LampStates[lampNum/8] &= ~(0x01<<(lampNum%8));
    LampFlashPeriod[lampNum] = adjustedLampFlash;
  } else {
    LampStates[lampNum/8] |= (0x01<<(lampNum%8));
    LampFlashPeriod[lampNum] = 0;
  }

  if (s_lampDim & 0x01) {    
    LampDim1[lampNum/8] |= (0x01<<(lampNum%8));
  } else {
    LampDim1[lampNum/8] &= ~(0x01<<(lampNum%8));
  }

  if (s_lampDim & 0x02) {    
    LampDim2[lampNum/8] |= (0x01<<(lampNum%8));
  } else {
    LampDim2[lampNum/8] &= ~(0x01<<(lampNum%8));
  }

}

byte RPU_ReadLampState(int lampNum) {
  if (lampNum>=RPU_MAX_LAMPS || lampNum<0) return 0x00;
  byte lampStateByte = LampStates[lampNum/8];
  return (lampStateByte & (0x01<<(lampNum%8))) ? 0 : 1;
}

byte RPU_ReadLampDim(int lampNum) {
  if (lampNum>=RPU_MAX_LAMPS || lampNum<0) return 0x00;
  byte lampDim = 0;
  byte lampDimByte = LampDim1[lampNum/8];
  if (lampDimByte & (0x01<<(lampNum%8))) lampDim |= 1;

  lampDimByte = LampDim2[lampNum/8];
  if (lampDimByte & (0x01<<(lampNum%8))) lampDim |= 2;

  return lampDim;
}

int RPU_ReadLampFlash(int lampNum) {
  if (lampNum>=RPU_MAX_LAMPS || lampNum<0) return 0;

  return LampFlashPeriod[lampNum]*50;
}

void RPU_ApplyFlashToLamps(unsigned long curTime) {
  int curLampByte = 0;
  byte curLampBit = 0;
  int curLampNum = 0;

  for (curLampByte=0; curLampByte<RPU_NUM_LAMP_BANKS; curLampByte++) {
    curLampBit = 0x01;
    for (byte curBit=0; curBit<8; curBit++) {
      if ( LampFlashPeriod[curLampNum]!=0 ) {
        unsigned long adjustedLampFlash = (unsigned long)LampFlashPeriod[curLampNum] * (unsigned long)50;
        if ((curTime/adjustedLampFlash)%2) {
          LampStates[curLampByte] &= ~(curLampBit);
        } else {
          LampStates[curLampByte] |= (curLampBit);
        }
      }

      curLampBit *= 2;
      curLampNum += 1;
    }
  }
}

void RPU_FlashAllLamps(unsigned long curTime) {
  for (int count=0; count<RPU_MAX_LAMPS; count++) {
    RPU_SetLampState(count, 1, 0, 500);  
  }

  RPU_ApplyFlashToLamps(curTime);
}

void RPU_TurnOffAllLamps() {
  for (int count=0; count<RPU_MAX_LAMPS; count++) {
    RPU_SetLampState(count, 0, 0, 0);  
  }
}

int RPU_GetLampCount() {
  return RPU_MAX_LAMPS;
}



/******************************************************
 *   Helper Functions
 */

void RPU_ClearVariables() {
  // Reset solenoid stack
  SolenoidStackFirst = 0;
  SolenoidStackLast = 0;

  // Reset switch stack
  SwitchStackFirst = 0;
  SwitchStackLast = 0;

#if (RPU_MPU_ARCHITECTURE > 9) 
  // Reset sound stack
  SoundStackFirst = 0;
  SoundStackLast = 0;
#endif

  CurrentDisplayDigit = 0; 

  // Set default values for the displays
  for (int displayCount=0; displayCount<5; displayCount++) {
    for (int digitCount=0; digitCount<RPU_OS_NUM_DIGITS; digitCount++) {
      DisplayDigits[displayCount][digitCount] = 0;
    }
    DisplayDigitEnable[displayCount] = 0x00;
  }

  // Turn off all lamp states
  for (int lampBankCounter=0; lampBankCounter<RPU_NUM_LAMP_BANKS; lampBankCounter++) {
    LampStates[lampBankCounter] = 0xFF;
    LampDim1[lampBankCounter] = 0x00;
    LampDim2[lampBankCounter] = 0x00;
  }

  for (int lampFlashCount=0; lampFlashCount<RPU_MAX_LAMPS; lampFlashCount++) {
    LampFlashPeriod[lampFlashCount] = 0;
  }

  // Reset all the switch values 
  // (set them as closed so that if they're stuck they don't register as new events)
  byte switchCount;
  for (switchCount=0; switchCount<NUM_SWITCH_BYTES; switchCount++) {
    SwitchesMinus2[switchCount] = 0xFF;
    SwitchesMinus1[switchCount] = 0xFF;
    SwitchesNow[switchCount] = 0xFF;
  }

  for (byte count=0; count<TIMED_SOLENOID_STACK_SIZE; count++) {
    TimedSolenoidStack[count].inUse = 0;
    TimedSolenoidStack[count].pushTime = 0;
    TimedSolenoidStack[count].solenoidNumber = 0;
    TimedSolenoidStack[count].numPushes = 0;
    TimedSolenoidStack[count].disableOverride = 0;
  }

#if (RPU_MPU_ARCHITECTURE > 9) 
  for (byte count=0; count<TIMED_SOUND_STACK_SIZE; count++) {
    TimedSoundStack[count].inUse = 0;
    TimedSoundStack[count].pushTime = 0;
    TimedSoundStack[count].soundNumber = 0;
    TimedSoundStack[count].numPushes = 0;
  }  
#endif
  
}




#if defined(RPU_OS_USE_WTYPE_1_SOUND) || defined(RPU_OS_USE_WTYPE_2_SOUND)
#if defined(RPU_OS_USE_WTYPE_2_SOUND) 
unsigned short SoundLowerLimit = 0x0000;
unsigned short SoundUpperLimit = 0x0080;
#else 
unsigned short SoundLowerLimit = 0x0100;
unsigned short SoundUpperLimit = 0x1F00;
#endif


void RPU_SetSoundValueLimits(unsigned short lowerLimit, unsigned short upperLimit) {
  SoundLowerLimit = lowerLimit;
  SoundUpperLimit = upperLimit;
}
 
int SpaceLeftOnSoundStack() {
  if (SoundStackFirst>=SOUND_STACK_SIZE || SoundStackLast>=SOUND_STACK_SIZE) return 0;
  if (SoundStackLast>=SoundStackFirst) return ((SOUND_STACK_SIZE-1) - (SoundStackLast-SoundStackFirst));
  return (SoundStackFirst - SoundStackLast) - 1;
}

void RPU_PushToSoundStack(unsigned short soundNumber, byte numPushes) {  
  // If the solenoid stack last index is out of range, then it's an error - return  
  if (SpaceLeftOnSoundStack()==0) return;
  if (soundNumber<SoundLowerLimit || soundNumber>SoundUpperLimit) return;

  for (int count=0; count<numPushes; count++) {
    SoundStack[SoundStackLast] = soundNumber;
    
    SoundStackLast += 1;
    if (SoundStackLast==SOUND_STACK_SIZE) {
      // If the end index is off the end, then wrap
      SoundStackLast = 0;
    }
    // If the stack is now full, return
    if (SpaceLeftOnSoundStack()==0) return;
  }

}


unsigned short PullFirstFromSoundStack() {
  // If first and last are equal, there's nothing on the stack
  if (SoundStackFirst==SoundStackLast) {
    return SOUND_STACK_EMPTY;
  }
  
  unsigned short retVal = SoundStack[SoundStackFirst];

  SoundStackFirst += 1;
  if (SoundStackFirst>=SOUND_STACK_SIZE) SoundStackFirst = 0;

  return retVal;
}


boolean RPU_PushToTimedSoundStack(unsigned short soundNumber, byte numPushes, unsigned long whenToPlay) {
  for (int count=0; count<TIMED_SOUND_STACK_SIZE; count++) {
    if (!TimedSoundStack[count].inUse) {
      TimedSoundStack[count].inUse = true;
      TimedSoundStack[count].pushTime = whenToPlay;
      TimedSoundStack[count].soundNumber = soundNumber;
      TimedSoundStack[count].numPushes = numPushes;
      return true;
    }
  }
  return false;
}


void RPU_UpdateTimedSoundStack(unsigned long curTime) { 
  for (int count=0; count<TIMED_SOUND_STACK_SIZE; count++) {
    if (TimedSoundStack[count].inUse && TimedSoundStack[count].pushTime<curTime) {
      RPU_PushToSoundStack(TimedSoundStack[count].soundNumber, TimedSoundStack[count].numPushes);
      TimedSoundStack[count].inUse = false;
    }
  }
}
#endif

#ifdef RPU_OS_USE_WTYPE_11_SOUND
void RPU_PlayW11Sound(byte soundNum) {
  RPU_DataWrite(PIA_SOUND_11_PORT_A, soundNum);
  // Strobe CA2
  RPU_DataWrite(PIA_SOUND_11_CONTROL_A, 0x34);
  RPU_DataWrite(PIA_SOUND_11_CONTROL_A, 0x3C);
}

void RPU_PlayW11Music(byte songNum) {
  RPU_DataWrite(PIA_WIDGET_PORT_B, songNum);
  // Strobe CA2
  RPU_DataWrite(PIA_WIDGET_CONTROL_B, 0x34);
  RPU_DataWrite(PIA_WIDGET_CONTROL_B, 0x3C);
}
#endif

byte RPU_GetSoundCount() {
  byte numSounds = 0;

#if defined(RPU_OS_USE_WTYPE_1_SOUND)
  numSounds = 32;
#endif

#if defined(RPU_OS_USE_WTYPE_2_SOUND)
  numSounds = 32;
#endif

#if defined(RPU_OS_USE_W11_SOUND)
  numSounds = 255;
#endif

  return numSounds;
}




/******************************************************
 *   EEPROM Helper Functions
 */

void RPU_WriteByteToEEProm(unsigned short startByte, byte value) {
  EEPROM.write(startByte, value);
}

byte RPU_ReadByteFromEEProm(unsigned short startByte) {
  byte value = EEPROM.read(startByte);

  // If this value is unset, set it
  if (value==0xFF) {
    value = 0;
    RPU_WriteByteToEEProm(startByte, value);
  }
  return value;
}


unsigned long RPU_ReadULFromEEProm(unsigned short startByte, unsigned long defaultValue) {
  unsigned long value;

  value = (((unsigned long)EEPROM.read(startByte+3))<<24) | 
          ((unsigned long)(EEPROM.read(startByte+2))<<16) | 
          ((unsigned long)(EEPROM.read(startByte+1))<<8) | 
          ((unsigned long)(EEPROM.read(startByte)));

  if (value==0xFFFFFFFF) {
    value = defaultValue; 
    RPU_WriteULToEEProm(startByte, value);
  }
  return value;
}


void RPU_WriteULToEEProm(unsigned short startByte, unsigned long value) {
  EEPROM.write(startByte+3, (byte)(value>>24));
  EEPROM.write(startByte+2, (byte)((value>>16) & 0x000000FF));
  EEPROM.write(startByte+1, (byte)((value>>8) & 0x000000FF));
  EEPROM.write(startByte, (byte)(value & 0x000000FF));
}




/******************************************************
 *   Initialization and ISR Functions
 */
boolean CheckSwitchStack(byte switchNum) {
  for (byte stackIndex=SwitchStackFirst; stackIndex!=SwitchStackLast; stackIndex++) {
    if (stackIndex>=SWITCH_STACK_SIZE) stackIndex = 0; 
    if (SwitchStack[stackIndex]==switchNum) return true;
  }
  return false;
}


volatile unsigned long LampPass = 0;
volatile byte LampStrobe = 0;
volatile byte DisplayStrobe = 0;
volatile byte InterruptPass = 0;
boolean NeedToTurnOffTriggeredSolenoids = true;
#if (RPU_OS_NUM_DIGITS==6)
byte BlankingBit[16] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x01, 0x02, 0x01, 0x02, 0x04, 0x08, 0x010, 0x20, 0x01, 0x02};
#elif (RPU_OS_NUM_DIGITS==7) 
byte BlankingBit[16] = {0x01, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x02, 0x01, 0x02, 0x04, 0x08, 0x010, 0x20, 0x40};
#endif
volatile byte UpDownPassCounter = 0;

// INTERRUPT HANDLER
ISR(TIMER1_COMPA_vect) {    //This is the interrupt request (running at 965.3 Hz)

  byte displayControlPortB = RPU_DataRead(PIA_DISPLAY_CONTROL_B);
  if (displayControlPortB & 0x80) {
    UpDownSwitch = true;
    UpDownPassCounter = 0;
    // Clear the interrupt
    RPU_DataRead(PIA_DISPLAY_PORT_B);
  } else {
    UpDownPassCounter += 1;
    if (UpDownPassCounter==50) {
      UpDownSwitch = false;
      UpDownPassCounter = 0;
    }
  }

#if (RPU_MPU_ARCHITECTURE==15)
  // Create display data
  unsigned int digit1 = 0x0000;
  byte digit2 = 0x00;
  byte blankingBit = BlankingBit[DisplayStrobe];
  if (DisplayStrobe==0) {
    if (DisplayBIPDigitEnable&blankingBit) digit1 = DisplayBIPDigits[0];
    if (DisplayCreditDigitEnable&blankingBit) digit2 = DisplayCreditDigits[0];
  } else if (DisplayStrobe<8) {    
    if (DisplayDigitEnable[0]&blankingBit) digit1 = FourteenSegmentASCII[DisplayText[0][DisplayStrobe-1]];
    if (DisplayDigitEnable[2]&blankingBit) digit2 = DisplayDigits[2][DisplayStrobe-1];
  } else if (DisplayStrobe==8) {
    if (DisplayBIPDigitEnable&blankingBit) digit1 = DisplayBIPDigits[1];
    if (DisplayCreditDigitEnable&blankingBit) digit2 = DisplayCreditDigits[1];
  } else {
    if (DisplayDigitEnable[1]&blankingBit) digit1 = FourteenSegmentASCII[DisplayText[1][DisplayStrobe-9]];
    if (DisplayDigitEnable[3]&blankingBit) digit2 = DisplayDigits[3][DisplayStrobe-9];
  }
  // Show current display digit
  RPU_DataWrite(PIA_DISPLAY_PORT_A, BoardLEDs|DisplayStrobe);
  RPU_DataWrite(PIA_ALPHA_DISPLAY_PORT_A, (digit1>>7) & 0x7F);
  RPU_DataWrite(PIA_ALPHA_DISPLAY_PORT_B, digit1 & 0x7F);
  RPU_DataWrite(PIA_DISPLAY_PORT_B, digit2 & 0x7F);  
#elif (RPU_MPU_ARCHITECTURE==13)
  // Create display data
  byte digit1 = 0x0F, digit2 = 0x0F;
  byte blankingBit = BlankingBit[DisplayStrobe];
  if (DisplayStrobe==0) {
    if (DisplayBIPDigitEnable&blankingBit) digit1 = DisplayBIPDigits[0];
    if (DisplayCreditDigitEnable&blankingBit) digit2 = DisplayCreditDigits[0];
  } else if (DisplayStrobe<8) {
    if (DisplayDigitEnable[0]&blankingBit) digit1 = DisplayDigits[0][DisplayStrobe-1];
    if (DisplayDigitEnable[2]&blankingBit) digit2 = DisplayDigits[2][DisplayStrobe-1];
  } else if (DisplayStrobe==8) {
    if (DisplayBIPDigitEnable&blankingBit) digit1 = DisplayBIPDigits[1];
    if (DisplayCreditDigitEnable&blankingBit) digit2 = DisplayCreditDigits[1];
  } else {
    if (DisplayDigitEnable[1]&blankingBit) digit1 = DisplayDigits[1][DisplayStrobe-9];
    if (DisplayDigitEnable[3]&blankingBit) digit2 = DisplayDigits[3][DisplayStrobe-9];
  }
  // Show current display digit
  RPU_DataWrite(PIA_DISPLAY_PORT_A, BoardLEDs|DisplayStrobe);
  RPU_DataWrite(PIA_DISPLAY_PORT_B, digit1*16 | (digit2&0x0F));
#else
  // Create display data
  byte digit1 = 0x0F, digit2 = 0x0F;
  byte blankingBit = BlankingBit[DisplayStrobe];
  if (DisplayStrobe<6) {
    if (DisplayDigitEnable[0]&blankingBit) digit1 = DisplayDigits[0][DisplayStrobe];
    if (DisplayDigitEnable[2]&blankingBit) digit2 = DisplayDigits[2][DisplayStrobe];
  } else if (DisplayStrobe<8) {
    if (DisplayBIPDigitEnable&blankingBit) digit1 = DisplayBIPDigits[DisplayStrobe-6];
  } else if (DisplayStrobe<14) {
    if (DisplayDigitEnable[1]&blankingBit) digit1 = DisplayDigits[1][DisplayStrobe-8];
    if (DisplayDigitEnable[3]&blankingBit) digit2 = DisplayDigits[3][DisplayStrobe-8];
  } else {
    if (DisplayCreditDigitEnable&blankingBit) digit1 = DisplayCreditDigits[DisplayStrobe-14];
  }  
  // Show current display digit
//  if (RPU_DataRead(PIA_DISPLAY_CONTROL_B) & 0x80) SawInterruptOnDisplayPortB1 = true;
  RPU_DataWrite(PIA_DISPLAY_PORT_A, BoardLEDs|DisplayStrobe);
  RPU_DataWrite(PIA_DISPLAY_PORT_B, digit1*16 | (digit2&0x0F));
#endif

  DisplayStrobe += 1; 
  if (DisplayStrobe>=16) DisplayStrobe = 0;

  if (InterruptPass==0) {
  
    // Show lamps
    byte curLampByte = LampStates[LampStrobe];
    if (LampPass%DimDivisor1) curLampByte |= LampDim1[LampStrobe];
    if (LampPass%DimDivisor2) curLampByte |= LampDim2[LampStrobe];
    RPU_DataWrite(PIA_LAMPS_PORT_B, 0x01<<(LampStrobe));
    RPU_DataWrite(PIA_LAMPS_PORT_A, curLampByte);
    
    LampStrobe += 1;
    if ((LampStrobe)>=RPU_NUM_LAMP_BANKS) {
      LampStrobe = 0;
      LampPass += 1;
    }
    
    // Check coin door switches
    byte displayControlPortA = RPU_DataRead(PIA_DISPLAY_CONTROL_A);
    if (displayControlPortA & 0x80) {
      // If the diagnostic switch isn't on the stack already, put it there
      if (!CheckSwitchStack(SW_SELF_TEST_SWITCH)) PushToSwitchStack(SW_SELF_TEST_SWITCH);
      // Clear the interrupt
      RPU_DataRead(PIA_DISPLAY_PORT_A);
    }

    // Check switches
    byte switchColStrobe = 1;
    for (byte switchCol=0; switchCol<8; switchCol++) {
      // Cycle the debouncing variables
      SwitchesMinus2[switchCol] = SwitchesMinus1[switchCol];
      SwitchesMinus1[switchCol] = SwitchesNow[switchCol];
      // Turn on the strobe
      RPU_DataWrite(PIA_SWITCH_PORT_B, switchColStrobe);
      // Hold it up for 30 us
      delayMicroseconds(12);
      // Read switch input
      SwitchesNow[switchCol] = RPU_DataRead(PIA_SWITCH_PORT_A);
      switchColStrobe *= 2;
    }
    RPU_DataWrite(PIA_SWITCH_PORT_B, 0);
    
    // If there are any closures, add them to the switch stack
    for (byte switchCol=0; switchCol<NUM_SWITCH_BYTES; switchCol++) {
      byte validClosures = (SwitchesNow[switchCol] & SwitchesMinus1[switchCol]) & ~SwitchesMinus2[switchCol];
      // If there is a valid switch closure (off, on, on)
      if (validClosures) {
        // Loop on bits of switch byte
        for (byte bitCount=0; bitCount<8; bitCount++) {
          // If this switch bit is closed
          if (validClosures&0x01) {
            byte validSwitchNum = switchCol*8 + bitCount;
            PushToSwitchStack(validSwitchNum);
          }
          validClosures = validClosures>>1;
        }        
      }
    }
  
  } else {
    // See if any solenoids need to be switched
    byte solenoidOn = PullFirstFromSolenoidStack();
    byte portA = ContinuousSolenoidBits&0xFF;
    byte portB = ContinuousSolenoidBits/256;
    if (solenoidOn!=SOLENOID_STACK_EMPTY) {
      if (solenoidOn<16) {
        unsigned short newSolenoidBytes = (1<<solenoidOn);
        portA |= (newSolenoidBytes&0xFF);
        portB |= (newSolenoidBytes/256);
        if (NeedToTurnOffTriggeredSolenoids) {
          RPU_DataWrite(PIA_LAMPS_CONTROL_B, 0x3C);
          RPU_DataWrite(PIA_LAMPS_CONTROL_A, 0x3C);
          RPU_DataWrite(PIA_SWITCH_CONTROL_B, 0x3C);
          RPU_DataWrite(PIA_SWITCH_CONTROL_A, 0x3C);
          RPU_DataWrite(PIA_SOLENOID_CONTROL_A, 0x3C);
          RPU_DataWrite(PIA_DISPLAY_CONTROL_B, 0x3D);
          NeedToTurnOffTriggeredSolenoids = false;
        }
      } else {
        if (solenoidOn==16) RPU_DataWrite(PIA_LAMPS_CONTROL_B, 0x34);
        if (solenoidOn==17) RPU_DataWrite(PIA_LAMPS_CONTROL_A, 0x34);
        if (solenoidOn==18) RPU_DataWrite(PIA_SWITCH_CONTROL_B, 0x34);
        if (solenoidOn==19) RPU_DataWrite(PIA_SWITCH_CONTROL_A, 0x34);
        if (solenoidOn==20) RPU_DataWrite(PIA_SOLENOID_CONTROL_A, 0x34);
        if (solenoidOn==21) RPU_DataWrite(PIA_DISPLAY_CONTROL_B, 0x35);
        NeedToTurnOffTriggeredSolenoids = true;
      }
    } else if (NeedToTurnOffTriggeredSolenoids) {
      NeedToTurnOffTriggeredSolenoids = false;
      RPU_DataWrite(PIA_LAMPS_CONTROL_B, 0x3C);
      RPU_DataWrite(PIA_LAMPS_CONTROL_A, 0x3C);
      RPU_DataWrite(PIA_SWITCH_CONTROL_B, 0x3C);
      RPU_DataWrite(PIA_SWITCH_CONTROL_A, 0x3C);
      RPU_DataWrite(PIA_SOLENOID_CONTROL_A, 0x3C);
      RPU_DataWrite(PIA_DISPLAY_CONTROL_B, 0x3D);
    }

  
#if defined(RPU_OS_USE_WTYPE_1_SOUND)
    // See if any sounds need to be added
    // (these are handled through solenoid lines)
    unsigned short soundOn = PullFirstFromSoundStack();
    if (soundOn!=SOUND_STACK_EMPTY) {
      portA |= (soundOn&0xFF);
      portB |= (soundOn/256);
    }
#elif defined(RPU_OS_USE_WTYPE_2_SOUND)
    unsigned short soundOn = PullFirstFromSoundStack();
    if (soundOn!=SOUND_STACK_EMPTY) {
      RPU_DataWrite(PIA_SOUND_COMMA_PORT_A, (~soundOn) & 0x7F);      
    } else {
      RPU_DataWrite(PIA_SOUND_COMMA_PORT_A, 0x7F);
    }
#endif    

    RPU_DataWrite(PIA_SOLENOID_PORT_A, portA);
#if (RPU_MPU_ARCHITECTURE==15)
    Sys11LastLowerSol = portA; // Remember this, in case it's queried
    RPU_DataWrite(PIA_SOLENOID_11_PORT_B, portB);
#else 
    RPU_DataWrite(PIA_SOLENOID_PORT_B, portB);
#endif    
  }

//  RPU_DataWrite(PIA_SOLENOID_11_PORT_B, InterruptPass);
  InterruptPass ^= 1;

}



void RPU_SetupInterrupt() {
  cli();
  //set timer1 interrupt at 1Hz
  TCCR1A = 0;// set entire TCCR1A register to 0
  TCCR1B = 0;// same for TCCR1B
  TCNT1  = 0;//initialize counter value to 0
  // set compare match register for selected increment
//  OCR1A = 16574;
  OCR1A = INTERRUPT_OCR1A_COUNTER;
  // turn on CTC mode
  TCCR1B |= (1 << WGM12);
  // Set CS10 and CS12 bits for 1024 prescaler
  TCCR1B |= (0 << CS12) | (0 << CS11) | (1 << CS10);  
  // enable timer compare interrupt
  TIMSK1 |= (1 << OCIE1A);
  sei();
}


boolean CheckCreditResetSwitchArch10(byte creditResetButton) {
  byte strobeLine = 0x01 << (creditResetButton/8);
  byte returnLine = 0x01 << (creditResetButton%8);

  RPU_DataWrite(PIA_SWITCH_CONTROL_A, 0x38);
  RPU_DataWrite(PIA_SWITCH_PORT_A, 0x00);
  RPU_DataWrite(PIA_SWITCH_CONTROL_A, 0x3C);

  RPU_DataWrite(PIA_SWITCH_CONTROL_B, 0x38);
  RPU_DataWrite(PIA_SWITCH_PORT_B, 0xFF);
  RPU_DataWrite(PIA_SWITCH_CONTROL_B, 0x3C);
  RPU_DataWrite(PIA_SWITCH_PORT_B, 0x00);

  RPU_DataWrite(PIA_SWITCH_PORT_B, strobeLine);
  // Hold it up for 30 us
  delayMicroseconds(12);

  // Read switch input
  byte switchValues = RPU_DataRead(PIA_SWITCH_PORT_A);
  RPU_DataWrite(PIA_SWITCH_PORT_B, 0);

  if (switchValues & returnLine) return true;
  return false;
}    

/*****************************************************
 *  Initialization for Architecture 10 or greater
 */

unsigned long RPU_InitializeMPUArch10(unsigned long initOptions, byte creditResetSwitch) {
  unsigned long retResult = RPU_RET_NO_ERRORS;

  RPU_DataWrite(PIA_SOLENOID_CONTROL_B, 0x30);
  
  delay(1000);
  boolean switchStateClosed = false;
  boolean creditResetButtonHit = false;

  if ( creditResetSwitch!=0xFF && (initOptions & (RPU_CMD_BOOT_ORIGINAL_IF_CREDIT_RESET | RPU_CMD_BOOT_NEW_IF_CREDIT_RESET))) {
    // We have to check the credit/reset button to honor the init request
    creditResetButtonHit = CheckCreditResetSwitchArch10(creditResetSwitch);
    if (creditResetButtonHit) {
      retResult |= RPU_RET_CREDIT_RESET_BUTTON_HIT;
    }
  }

  boolean bootToOriginal = false;
  if (  (initOptions & RPU_CMD_BOOT_ORIGINAL) || 
        (switchStateClosed && (initOptions&RPU_CMD_BOOT_ORIGINAL_IF_SWITCH_CLOSED)) ||
        (creditResetButtonHit && (initOptions&RPU_CMD_BOOT_ORIGINAL_IF_CREDIT_RESET)) ) {
    bootToOriginal = true;
  }
  if (  (initOptions & RPU_CMD_BOOT_NEW) || 
        (switchStateClosed && (initOptions&RPU_CMD_BOOT_NEW_IF_SWITCH_CLOSED)) ||
        (creditResetButtonHit && (initOptions&RPU_CMD_BOOT_NEW_IF_CREDIT_RESET)) ) {
    bootToOriginal = false;
  }

  if (bootToOriginal) {
    if (initOptions&RPU_CMD_INIT_AND_RETURN_EVEN_IF_ORIGINAL_CHOSEN) {
      retResult |= RPU_RET_ORIGINAL_CODE_REQUESTED;
      return retResult;
    } else {
      while (1);
    }
  }
  
  RPU_ClearVariables();
  RPU_InitializePIAs();
  if (initOptions&RPU_CMD_PERFORM_MPU_TEST) retResult |= RPU_TestPIAs();
  RPU_SetupInterrupt();

  return retResult;
}



void RPU_Update(unsigned long currentTime) {
  RPU_ApplyFlashToLamps(currentTime);
  RPU_UpdateTimedSolenoidStack(currentTime);
#if (RPU_MPU_ARCHITECTURE>=10) && (defined(RPU_OS_USE_WTYPE_1_SOUND) || defined(RPU_OS_USE_WTYPE_2_SOUND))
  RPU_UpdateTimedSoundStack(currentTime);
#endif
}


// This function should eventually support auto-detect and initialize the appropriate
// ISRs for the detected architecture.
unsigned long RPU_InitializeMPU(unsigned long initOptions, byte creditResetSwitch) {

  unsigned long retVal = 0;

#if (RPU_MPU_ARCHITECTURE<10)
  retVal = RPU_InitializeMPUArch1(initOptions, creditResetSwitch);
#else
  retVal = RPU_InitializeMPUArch10(initOptions, creditResetSwitch);
#endif  

  return retVal;
}