4off 8x8 dual colour matrix problem

I have been experimenting with expansion of the Bro Hogan circuit and the LedControl library.
I built 4 identical circuits and tested each individually as working correctly.
I then connected the four in a square and commonly connected the Vcc, Gnd, Clk and Load then daisy chained the Din and Dout, the last going into space. The code for LedControl was set to 8 devices (which introduced flicker)
At first glance all appeared to be OK but I had used symmetrical data.
I decided to leave all connected but set the number of devices to 2 (for one grid) and removed all references to the switching etc. of the other three)
A test to light a single led on the first display showed it on all 4 grids. To me this indicated that the addressing of a grid was allowing the data to be sent down the daisy chain regardless of how many devices or the address.
The attached interrupt is an external timer that interrupts and sends the data every one second.

I am baffled twice, once for the data addressing but second because the remaining 6 devices are still ‘apparently’ being switched into/out of shutdown!!!
Can anyone suggest a reason or where my fault is please.

/* RG Matrix Example   v.2 8/1/08  BroHogan
 * Demos 2 color 8x8 matrix driven by 2 MAX7821's
 */

#include "LedControl.h"                 // to drive the matrix
//#include "Binary.h"
#define ISR_FREQ 190     //190=650Hz    // Sets the speed of the ISR - LOWER IS FASTER
                  
// prescaler is /128 -  125,000/ISR_FREQ+1 (i.e 249=500Hz, 190=650Hz)

 
#define RED 0
#define GREEN 1
#define REDa 0                           // The address of the MAX7221 for the red leds                           // The address of the MAX7221 for the red leds
#define GREENa 1                         // The address of the MAX7221 for the green leds
#define REDb 2                           
#define GREENb 3                         
#define REDc 4                           // The address of the MAX7221 for the red leds
#define GREENc 5
#define REDd 6                           // The address of the MAX7221 for the red leds
#define GREENd 7                         // The address of the MAX7221 for the green leds

int maxInShutdown=RED;                // tells which MAX7221 is currently off
unsigned long ISRTime;                   // DEBUG to test how long in ISR

LedControl lc=LedControl(12,11,10,2); // pins 12=DataIn, 11=CLK, 10=LOAD + 4 MAX7221s
//LedControl lcb=LedControl(13,11,10,2);


volatile int count=0;

void setup() {
  lc.setIntensity(REDa,12);
//  lc.setIntensity(REDb,12);
//  lc.setIntensity(REDc,12);
//  lc.setIntensity(REDd,12);
  lc.setIntensity(GREENa,15);            // 0 = dim, 15 = full brightness 15
//  lc.setIntensity(GREENb,15);
//  lc.setIntensity(GREENc,15);
//  lc.setIntensity(GREENd,15);
  setISRtimer();                        // setup the timer
  startISR();                           // start the timer to toggle shutdown
  pinMode(2, INPUT); 
  attachInterrupt(0, onTick, RISING);
  //Test to use only green
    lc.shutdown(REDa,true);
//    lc.shutdown(REDb,true);
//    lc.shutdown(REDc,true);
//    lc.shutdown(REDd,true);
    lc.shutdown(GREENa,false);
//    lc.shutdown(GREENb,false);
//    lc.shutdown(GREENc,false);
//    lc.shutdown(GREENd,false);
//  Serial.begin(9600);
}
void loop() {}


/////////////Below here should not need changing, could break it////////////
////////////////////////////////////////////////////////////////////////////
/////////////////////////////ISR Timer Functions ///////////////////////////
ISR(TIMER2_COMPA_vect) {  //This ISR toggles shutdown between the 2MAX7221's
// digitalWrite(2, maxInShutdown == RED ? HIGH : LOW);
  if(maxInShutdown==RED){
    lc.shutdown(GREENa,true);  // The order here is critical - Shutdown first!
//    lc.shutdown(GREENb,true);  // The order here is critical - Shutdown first!
//    lc.shutdown(GREENc,true);  // The order here is critical - Shutdown first!
//    lc.shutdown(GREENd,true);  // The order here is critical - Shutdown first!
    lc.shutdown(REDa,false);   // . . . Then restart the other.
//    lc.shutdown(REDb,false);   // . . . Then restart the other.
//    lc.shutdown(REDc,false);   // . . . Then restart the other.
//    lc.shutdown(REDd,false);   // . . . Then restart the other.
    maxInShutdown=GREEN;
//    Serial.println("Green off");
 }
  else {
    lc.shutdown(REDa,true);
//    lc.shutdown(REDb,true);
//    lc.shutdown(REDc,true);
//    lc.shutdown(REDd,true);
    lc.shutdown(GREENa,false);
//    lc.shutdown(GREENb,false);
//    lc.shutdown(GREENc,false);
//    lc.shutdown(GREENd,false);
    maxInShutdown=RED;
//    Serial.println("Red off");
  }
}  
 
void onTick()
{
  SetLed(GREENa,count&7,6,true);
  SetLed(GREENa,(count-1)&7,6,false);
//  Serial.println(count);
  count=count+1;
}
void setISRtimer(){  // setup ISR timer controling toggleing
  TCCR2A = 0x02;                        // WGM22=0 + WGM21=1 + WGM20=0 = Mode2 (CTC)
  TCCR2B = 0x05;                // CS22=1 + CS21=0 + CS20=1 = /128 prescaler (125kHz)
  TCNT2 = 0;                            // clear counter
  OCR2A = ISR_FREQ;                     // set TOP (divisor) - see #define
}
 
void startISR(){  // Starts the ISR
  TCNT2 = 0;                            // clear counter (needed here also)
  TIMSK2|=(1<<OCIE2A);                  // set interrupts=enabled (calls ISR(TIMER2_COMPA_vect)
}
 
void stopISR(){    // Stops the ISR
  TIMSK2&=~(1<<OCIE2A);                  // disable interrupts
}
 
/////////   Wrappers for LedControl functions . . . //////////

void SetLed(byte Color, byte Row,byte Col, byte State){
  stopISR();            // disable interrupts - stop toggling shutdown when updating
  lc.setLed(Color,Row,Col,State);
//    Serial.println((Row+0));
  startISR();           // enable interrupts again
}
 
void SetRow(byte Color, byte Row, byte State){
  stopISR();            // disable interrupts - stop toggling shutdown when updating
  lc.setRow(Color,Row,State);
  startISR();           // enable interrupts again
}
 
void SetColumn(byte Color, byte Col, byte State){
  stopISR();            // disable interrupts - stop toggling shutdown when updating
  lc.setColumn(Color,Col,State);
  startISR();           // enable interrupts again
}
 
void ClearMatrix(){
  stopISR();            // disable interrupts - stop toggling shutdown when updating
  lc.clearDisplay(REDa);
  lc.clearDisplay(GREENa);
//  lc.clearDisplay(REDb);
//  lc.clearDisplay(GREENb);
//  lc.clearDisplay(REDc);
//  lc.clearDisplay(GREENc);
//  lc.clearDisplay(REDd);
//  lc.clearDisplay(GREENd);
  startISR();           // enable interrupts again
}