msgeq7 and many controllers, is there an easier way to do this?

I have always wanted a light show that would react to specific frequency ranges, and started out building 5x5 multiplexed grids and triggering them with an audio signal to A0, tuning with a resistor and always a 10uf cap to ground, they work fine.
I found the msgeq7 recently and finally started to play around with the available sketches, which were fine but what I really wanted was a way to use the 7 outputs to trigger many different light boxes that I already have, one per output. The issue was PWM, when I just needed a single pulse to start the animation, allowing the secondary controller to run it. It Works! very well.
I’m using a Mega 2560 rev3 for the Main output controller and is sends out to four (so far)Arduino Nano rev3, here’s my code for the Primary controller the Mega, modified from Baldengineers sketch IIRC,

#define msg7RESET 11
#define msg7Strobe 12
#define msg7DCout 0
const int LEDpins[7] = {3,4,5,6,7,8,9};    // there are 5 LEDs and 7 freq bands. So, repeat LEDs
 
#define pushButton 2
 
void setup() {
  // initialize the digital pin as an output.
  // Pin 13 has an LED connected on most Arduino boards:
  for (int x=0; x<7; x++) {
      pinMode(LEDpins[x], OUTPUT);
  }
  pinMode(msg7RESET, OUTPUT);
  pinMode(msg7Strobe, OUTPUT);
 
  pinMode(pushButton, INPUT);       // never actually used in this example.
  digitalWrite(pushButton, HIGH);  // Enable internal pull-up
}
 
void loop() {
    digitalWrite(msg7RESET, HIGH);          // reset the MSGEQ7's counter
    delay(5);
    digitalWrite(msg7RESET, LOW);
 
    for (int x = 0; x < 7; x++){
        digitalWrite(msg7Strobe, LOW);      // output each DC value for each freq band
        delayMicroseconds(35); // to allow the output to settle
        int spectrumRead = analogRead(msg7DCout);
 
        int PWMvalue = map(spectrumRead, 0, 1024, 0, 255);  // scale analogRead's value to Write's 255 max
        if (PWMvalue < 50)
            PWMvalue = PWMvalue / 35;        // bit of a noise filter, so the LEDs turn off at low levels
        else(PWMvalue = 255);
 
        analogWrite(LEDpins[x], PWMvalue);
        digitalWrite(msg7Strobe, HIGH);
    }
}

And here’s my modified code for the Secondary grid controllers nanorev3 I got from Lincomatic via Instructables ( I KNOW Grumpy Mike, don’t use Instructables, I get it :))

/*
 * Show animations on a DIMxDIM led matrix
 *
 * Uses Timer1 library to
 * constantly run an interrupt routine
 * at a specified frequency. This
 * refreshes the display without the
 * main loop having to do anything.
 *
 * created by Sam Lin lincomatic@hotmail.com 2/2011
 *
 */
#include <TimerOne.h>

//#define TESTMODE // continuously sequence thru the LED's 
//#define BLINKY // blink LED on pin 13

#define SENSOR_PIN A0 // analog input pin for music
#ifdef BLINKY
#define LED_PIN 13 // digital output pin for LED
#endif // BLINKY

// trigger next frame when music amplitude > threshold
// increase threshold to decrease sensitivity
// decrease threshold to increase sensitivity
int threshold = 0;
// debouncing - filter out consecutive triggers that are too close
// together to slow down the animation.  decrease this value
// to make it more sensitive to shorter beat intervals
int minBeatInterval = 128;

// musicSync =1= sync to music
//           =0= use timer
int musicSync = 1;

// time between frames in ms when musicSync == 0
int frameDelay = 350;


int threshCrossed = 0;

#define DIM 5 // x/y dimension - 5x5 matrix
#define DIM1 (DIM-1)

typedef byte Frame[DIM];

#include "frames.h"

byte row = 0;
byte *curFrame;
int curFrameIdx;

// col[xx] of leds - anodes
// these are the arduino pins assigned to each column
int cols[DIM] = {12,11,10,9,8};

// row[xx] of leds - cathodes
// these are the arduino pins assigned to each row
int rows[DIM] = {7,6,5,4,3};

Frame blankFrame =
{B00000,
 B00000,
 B00000,
 B00000,
 B00000};

// blank the screen
void clearLeds() {
  // blank screen
  curFrame = blankFrame;
}

// select a frame to display
// idx = 0 -> FRAMDECNT-1
void setFrame(int idx) {
  noInterrupts();
  curFrame = Frames[idx];
  interrupts();
}

// Interrupt routine
// each time display() is called, it turns off the previous row
// and turns on the next row
byte bitMask = B00000011;
void display() {
  digitalWrite(rows[row], HIGH);  // Turn whole previous row off

  if (bitMask == B00010000) {
    bitMask = B00000011;  // light the right 2 columns (pins 9,8)
    // increment row and wrap if necessary
    if (++row == DIM) {
      row = 0;
    }
  }
  else if (bitMask == B00000011) {
    bitMask = B00001100;  // light the middle 2 columns (pins 11,10)
  }
  else { // bitMaskIdx == B00001100
    bitMask = B00010000;  // light the leftmost column (pin 12)
  }
  
  // direct port manipulation.
  // PORTB is a pseudo variable for digital pins 8 to 13 The two high bits (6 & 7) map to the crystal pins and are not usable
  // the bottom 5 bits are our columns.  We don't want to change the other bits,
  // so we first mask the bits we ignore, and then set the bits we want to light
  PORTB &= B11100000;
  PORTB |= curFrame[row] & bitMask;
  
  digitalWrite(rows[row], LOW); // Turn whole row on at once (for equal lighting times)
}


void setup() {
  int i;

#if defined(BLINKY)
  pinMode(LED_PIN, OUTPUT);  // setup LED pin for output
#endif // BLINKY
  
  // sets the pins as output
  for (i = 0; i < DIM; i++) {
    pinMode(cols[i], OUTPUT);
    pinMode(rows[i], OUTPUT);
  }

  // set up cols and rows (set display to dark)
  for (i = 0; i < DIM; i++) {
    digitalWrite(cols[i], LOW);
  }

  for (i = 0; i < DIM; i++) {
    digitalWrite(rows[i], HIGH);
  }


  clearLeds();
  
#ifdef TESTMODE  
  while (1) {
  for (i=0;i < DIM;i++) {
    digitalWrite(rows[i],LOW);
    for (int j=0;j < DIM;j++) {
      digitalWrite(cols[j],HIGH);
      delay(250);
      digitalWrite(cols[j],LOW);
    }
    digitalWrite(rows[i],HIGH);
  }
  }
#else // !TESTMODE
  // interrupt interval in uSec
  // this determines how long to keep each row turned on
  // so if we have 5 rows, we redraw the whole screen
  // once every 5 rows * 3 cycles per row * 1000 usec = .015 sec -> 66.67Hz
  // if you perceive flickering you can decrease to 500 for a 133.33Hz rate
  Timer1.initialize(500);
  
  Timer1.attachInterrupt(display); // ISR

  curFrameIdx = -1;
#endif // TESTMODE
                                                 
}

int cnt = 32768;
void loop() {
  if (musicSync) {
    // read the value from the sensor:
    int sensorValue = analogRead(SENSOR_PIN);
    cnt++;
    
    if (sensorValue > threshold) {
      if (!threshCrossed && (cnt > minBeatInterval) ) {
 threshCrossed = 1;
 cnt = 0;
 
 // increment the frame index and wrap if necessary
 if (++curFrameIdx == FRAMECNT) {
  curFrameIdx = 0;
 }
 
 // select frame for display
 setFrame(curFrameIdx);
      }
#if defined(BLINKY)
    digitalWrite(LED_PIN,HIGH);
#endif // BLINKY
    }
    else { // below threshold
#if defined(BLINKY)
      digitalWrite(LED_PIN,LOW); // turn off LED
#endif // BLINKY
      if (threshCrossed) {
 threshCrossed = 0;
      }
    }
  }
  else { // !musicSync
    // increment the frame index and wrap if necessary
    if (++curFrameIdx == FRAMECNT) {
      curFrameIdx = 0;
    }
    
    // select frame for display
    setFrame(curFrameIdx);
    
    delay(frameDelay); // wait time between frames in ms
  }
}

The Question is, is there a simpler way to do this? I actually have a lot of flexibility with this rig, but I know there’s a better way, without soldering new light rigs, I already have many works in progress besides this one, here’s a Fritz image, crappy layout I know, Thanks for listening,
Bob

Well, it appears that even if I post by the guidelines and ask nicely, I get blown off, oh well, off to a forum with more OOB style thinkers. This Forum is not user friendly,but the problem is the Users not the interface, So I shall lurk here no more,Cheers Bob