hi all

Ive built a little project from the thingverse page and i would like to know how to swap the digital read out for a bigger dot matrix unit. Ive tried just swapping them but it doesn't work, which must mean there is something in the code i need to add or change but i don't even know where to begin. I'll add as much info as i can

cheers
lucas

wiring diagram

dot matrix info
https://www.jaycar.co.nz/medias/sys_master/images/images/9796362076190/XC3746-manualMain.pdf

the code for the above program

// Include EEPROM memory library
#include <EEPROM.h>

// Include Alphanumeric LED Backpack Library
#include <Wire.h>
#include "Adafruit_LEDBackpack.h"
#include "Adafruit_GFX.h"
Adafruit_AlphaNum4 alpha4 = Adafruit_AlphaNum4();

int indicatorPin = 13;
int btnPin = A3;
int potPin = A6;
int btnState; // Used to tell the system what state the button is currently in (after debounce work)
int btnLastState = LOW; // The last confirmed state the button was in
int currentPotRead; // To store pot position

// base alpha chars
int b1 = 45;
int b2 = 45;
int b3 = 45;
int b4 = 45;

int lastb1 = 45;
int lastb2 = 45;
int lastb3 = 45;
int lastb4 = 45;

// character sets for gears
int gearCharSetOne[7];
int gearCharSetTwo[7];

// get shift positions from memory
int memShiftPos[7]; // Gear array
int memAddress = 0; // Base memory address for reading and writing values
int memMaxAddress = 24; // Maximum memory address

// variables for gear loop
int gearLoopIndex = 0;
int gearLoopMaxIndex = 6;
int gearLoopCurrentSmallestIndex = 0;
int gearLastSmallestIndex = -1;
int gearLoopCurrentDifferenceCheck;

// programming controls
int allowProg = HIGH; // Allow programming
int curHold = 0; // Current count of the cycles while being held
int oppMode = 0; // Program state - changes when differnt parts of the programing sequence are entered
int progModeRefresh = LOW; // Used to determine if the particular program state has JUST been entered (kind of used for menu "debounce")

unsigned long btnLastDebounce = 0; // time in millis - millis count of last debounce measure
unsigned long btnDebounceDelay = 50; // time in millis - amount of delay for checking for debounce

unsigned long progDetect = 0; // time in millis - millis count
unsigned long progDelay = 2000; // time in millis - amount of delay

unsigned long dashBlinkDelay = 300; // time in millis - millis count
unsigned long dashBlinkLast = 0; // time in millis - amount of delay
int dashBlink = 0; // Used to detect dashes blinking on display for program mode

//This function will write a 4 byte (32bit) long to the eeprom at
//the specified address to address + 3.
void EEPROMWritelong(int address, long value){
      //Decomposition from a long to 4 bytes by using bitshift.
      //One = Most significant -> Four = Least significant byte
      byte four = (value & 0xFF);
      byte three = ((value >> 8) & 0xFF);
      byte two = ((value >> 16) & 0xFF);
      byte one = ((value >> 24) & 0xFF);

      //Write the 4 bytes into the eeprom memory.
      EEPROM.write(address, four);
      EEPROM.write(address + 1, three);
      EEPROM.write(address + 2, two);
      EEPROM.write(address + 3, one);
      }
      
long EEPROMReadlong(long address){
      //Read the 4 bytes from the eeprom memory.
      long four = EEPROM.read(address);
      long three = EEPROM.read(address + 1);
      long two = EEPROM.read(address + 2);
      long one = EEPROM.read(address + 3);

      //Return the recomposed long by using bitshift.
      return ((four << 0) & 0xFF) + ((three << 8) & 0xFFFF) + ((two << 16) & 0xFFFFFF) + ((one << 24) & 0xFFFFFFFF);
      }

// the setup routine runs once when you press reset:
void setup() {
  // initialize the digital pin as an output.
  Serial.begin(9600);
  pinMode(indicatorPin, OUTPUT);
  pinMode(btnPin, INPUT);
  Serial.write("INIT");
  Serial.println();
  
  // ## PARK
  gearCharSetOne[0] = 80;
  gearCharSetTwo[0] = 75;
  
  // ## REV
  gearCharSetOne[1] = 82;
  gearCharSetTwo[1] = 86;
  
  // ## NEU
  gearCharSetOne[2] = 78;
  gearCharSetTwo[2] = 76;
  
  // ## OD
  gearCharSetOne[3] = 79;
  gearCharSetTwo[3] = 68;
  
  // ## DR
  gearCharSetOne[4] = 68;
  gearCharSetTwo[4] = 82;
  
  // ## L2
  gearCharSetOne[5] = 50;
  gearCharSetTwo[5] = 110;
  
  // ## L1
  gearCharSetOne[6] = 49;
  gearCharSetTwo[6] = 115;
  
  // Read values from memory
  memShiftPos[0] = EEPROMReadlong(0);
  memShiftPos[1] = EEPROMReadlong(4);
  memShiftPos[2] = EEPROMReadlong(8);
  memShiftPos[3] = EEPROMReadlong(12);
  memShiftPos[4] = EEPROMReadlong(16);
  memShiftPos[5] = EEPROMReadlong(20);
  memShiftPos[6] = EEPROMReadlong(24);

  alpha4.begin(0x70);  // pass in the address
  
  alpha4.writeDigitAscii(0, 45);
  alpha4.writeDigitAscii(1, 71);
  alpha4.writeDigitAscii(2, 77);
  alpha4.writeDigitAscii(3, 45);
  alpha4.writeDisplay();
  delay(150);
  
  alpha4.writeDigitAscii(0, 92);
  alpha4.writeDigitAscii(1, 71);
  alpha4.writeDigitAscii(2, 77);
  alpha4.writeDigitAscii(3, 47);
  alpha4.writeDisplay();
  delay(150);
  
  alpha4.writeDigitAscii(0, 124);
  alpha4.writeDigitAscii(1, 71);
  alpha4.writeDigitAscii(2, 77);
  alpha4.writeDigitAscii(3, 124);
  alpha4.writeDisplay();
  delay(150);
  
  alpha4.writeDigitAscii(0, 47);
  alpha4.writeDigitAscii(1, 71);
  alpha4.writeDigitAscii(2, 77);
  alpha4.writeDigitAscii(3, 92);
  alpha4.writeDisplay();
  delay(150);
  
  alpha4.writeDigitAscii(0, 45);
  alpha4.writeDigitAscii(1, 71);
  alpha4.writeDigitAscii(2, 77);
  alpha4.writeDigitAscii(3, 45);
  alpha4.writeDisplay();
  delay(150);
  
  alpha4.writeDigitAscii(0, 92);
  alpha4.writeDigitAscii(1, 71);
  alpha4.writeDigitAscii(2, 77);
  alpha4.writeDigitAscii(3, 47);
  alpha4.writeDisplay();
  delay(150);
  
  alpha4.writeDigitAscii(0, 124);
  alpha4.writeDigitAscii(1, 71);
  alpha4.writeDigitAscii(2, 77);
  alpha4.writeDigitAscii(3, 124);
  alpha4.writeDisplay();
  delay(150);
  
  alpha4.writeDigitAscii(0, 47);
  alpha4.writeDigitAscii(1, 71);
  alpha4.writeDigitAscii(2, 77);
  alpha4.writeDigitAscii(3, 92);
  alpha4.writeDisplay();
  delay(150);
  
  alpha4.writeDigitAscii(0, 45);
  alpha4.writeDigitAscii(1, 71);
  alpha4.writeDigitAscii(2, 77);
  alpha4.writeDigitAscii(3, 45);
  alpha4.writeDisplay();
  delay(150);

  alpha4.writeDigitAscii(0, b1);
  alpha4.writeDigitAscii(1, b2);
  alpha4.writeDigitAscii(2, b3);
  alpha4.writeDigitAscii(3, b4);
  alpha4.writeDisplay();

}

//char displaybuffer[4] = {' ', ' ', ' ', ' '};

void loop() {
  
  if(millis() > 9300 && oppMode == 0){
    allowProg = LOW;
  }
  else {
    allowProg = HIGH;
  }
  
  if(oppMode == 0){ // Only do shift display when in the base opp mode (i.e. - no programming is taking place)
    dashBlink = 0;
    b1 = 45;
    b4 = 45;
    // SHIFT DETECT ########-------------------------------------------------------------------------------#-#-#-
    digitalWrite(indicatorPin, LOW);
    // Display gear selection #-#-#-#-#-#-#-#-#-#-#-#-
    gearLoopIndex = 0;
    while(gearLoopIndex <= gearLoopMaxIndex){
      // Get current position of pot
      currentPotRead = analogRead(potPin);
      // Compare that position to this index
      gearLoopCurrentDifferenceCheck = abs(memShiftPos[gearLoopIndex] - currentPotRead);
      
      // See if the difference between this index and the current position
      // is smaller than any past checked indexes
      // If it is smaller, store this index as the smallest
      if(gearLoopCurrentDifferenceCheck < (abs(memShiftPos[gearLoopCurrentSmallestIndex] - currentPotRead))){
        gearLoopCurrentSmallestIndex = gearLoopIndex;
      }
      // Incriment counter
      gearLoopIndex = gearLoopIndex + 1;
    }
    if(gearLoopCurrentSmallestIndex != gearLastSmallestIndex){
      // Update character variables
      b2 = gearCharSetOne[gearLoopCurrentSmallestIndex];
      b3 = gearCharSetTwo[gearLoopCurrentSmallestIndex];     
      gearLastSmallestIndex = gearLoopCurrentSmallestIndex;
    }
    delay(100);
  } // END shift detect
  
  // PROGRAMMING ########-------------------------------------------------------------------------------#-#-#-
  if(allowProg == HIGH) { // We are withing the allowable programming time. Allow programming.
    // Clean up in case we were in a prog
    
    // Read button with debounce ---------------------------------------------------
    int btnRead = digitalRead(btnPin);
    
    if (btnRead != btnLastState) {
      btnLastDebounce = millis();
      progDetect = millis();
      Serial.write("Button State Change: ");
      Serial.write(btnRead);
      Serial.println();
    }
    
    if ((millis() - btnLastDebounce) > btnDebounceDelay) {
      // debounce time has elapsed. Current read is valid.
      // if the button state has changed:
      if (btnRead != btnState) {
        btnState = btnRead;
        Serial.write("Button State Saved");
        Serial.println();
        // Determine Program State and update if needed
        if(oppMode != 0){
          oppMode = 2;
          progModeRefresh = HIGH;
        }
      }
    }
    btnLastState = btnRead; // Save ucrrent read as last state for next loop
    // END Read button with debounce ---------------------------------------------------
  
    if(oppMode == 0){
      // Listen for entry into programing mode #-#-#-#-#-#-#-#-#-#-#-#-
      if(btnState == HIGH){
        digitalWrite(indicatorPin, HIGH);
        if ((millis() - progDetect) > progDelay) {
          // Program mode entered
          oppMode = 1;
          Serial.write("Entering Program Mode: ");
          Serial.print("progDetect adj: ");
          Serial.print(millis() - progDetect);
          Serial.print(" | ");
          Serial.print("progDelay: ");
          Serial.print(progDelay);
          Serial.println();
        }
      }
    } // END program entry detect
    if(oppMode != 0) { // Program Mode
      dashBlink = 1; // tell dashes to blink
      if(oppMode == 1) {
        // Program mode intro
        Serial.write("Program Mode 1 - Enter Programing");
        Serial.println();
        Serial.write("Current values: ");
        Serial.println();
  
        Serial.print("Pos1 ");
        Serial.print(memShiftPos[0]);
        Serial.println();
        
        Serial.print("Pos2 ");
        Serial.print(memShiftPos[1]);
        Serial.println();
        
        Serial.print("Pos3 ");
        Serial.print(memShiftPos[2]);
        Serial.println();
        
        Serial.print("Pos4 ");
        Serial.print(memShiftPos[3]);
        Serial.println();
        
        Serial.print("Pos5 ");
        Serial.print(memShiftPos[4]);
        Serial.println();
        
        Serial.print("Pos6 ");
        Serial.print(memShiftPos[5]);
        Serial.println();
        
        Serial.print("Pos7 ");
        Serial.print(memShiftPos[6]);
        Serial.println();
        
        oppMode = 2;
        digitalWrite(indicatorPin, LOW);
        delay(100);
        digitalWrite(indicatorPin, HIGH);
        delay(100);
        digitalWrite(indicatorPin, LOW);
        delay(100);
        digitalWrite(indicatorPin, HIGH);
      } // END program opp mode 1
      else if(oppMode == 2){
        // Display gear we are trying to store
        b2 = gearCharSetOne[(memAddress/4)];
        b3 = gearCharSetTwo[(memAddress/4)];
        if(btnState == HIGH && progModeRefresh == HIGH && memAddress <= memMaxAddress){
          progModeRefresh = LOW;
          currentPotRead = analogRead(potPin);
          // Save current position
          Serial.write("Saving Current to memory block ");
          Serial.print(memAddress);
          Serial.print(" | ");
          Serial.print(currentPotRead);
          Serial.println();
          EEPROMWritelong(memAddress, currentPotRead);
          memAddress = memAddress + 4;
          digitalWrite(indicatorPin, LOW);
          delay(100);
          digitalWrite(indicatorPin, HIGH);
          delay(100);
          digitalWrite(indicatorPin, LOW);
          delay(100);
          digitalWrite(indicatorPin, HIGH);
        } // END program store data
        else if (memAddress > memMaxAddress) {
          digitalWrite(indicatorPin, LOW);
          delay(100);
          digitalWrite(indicatorPin, HIGH);
          delay(100);
          digitalWrite(indicatorPin, LOW);
          delay(100);
          memAddress = 0;
          // Reread values from memory so any new values are loaded
          memShiftPos[0] = EEPROMReadlong(0);
          memShiftPos[1] = EEPROMReadlong(4);
          memShiftPos[2] = EEPROMReadlong(8);
          memShiftPos[3] = EEPROMReadlong(12);
          memShiftPos[4] = EEPROMReadlong(16);
          memShiftPos[5] = EEPROMReadlong(20);
          memShiftPos[6] = EEPROMReadlong(24);
          
          b1 = 45;
          b2 = 45;
          b3 = 45;
          b4 = 45;
          
          // reset program detection variables
          oppMode = 0;
          progModeRefresh = LOW;
          progDetect = millis();
        } // END program exit
      } // END program opp mode 2
    }  // END program opp modes
  } // END programming possible
  
  // Main execution
  
  if(dashBlink == 1){
    if ((millis() - dashBlinkLast) > dashBlinkDelay) {
      // Delay has elapsed. Swap Dashes.
      if(b1 == 45){
        b1 = 32;
        b4 = 32;
      } else {
        b1 = 45;
        b4 = 45;
      }
      dashBlinkLast = millis();
    }
  }
  
  if(lastb1 != b1 || lastb2 != b2 || lastb3 != b3 || lastb4 != b4){
    // Update display
    alpha4.begin(0x70);  // pass in the address
    alpha4.writeDigitAscii(0, b1);
    alpha4.writeDigitAscii(1, b2);
    alpha4.writeDigitAscii(2, b3);
    alpha4.writeDigitAscii(3, b4);
    alpha4.writeDisplay();
  }
  
  lastb1 = b1;
  lastb2 = b2;
  lastb3 = b3;
  lastb4 = b4;
  
} // END main loop