Inconsistent LED colors

[NegativCut]

Hi, I have six exixe-12 boards sharing the same bus (clock) and I am writing the same LED color codes to each but I get different colors on three of them.
Three of them are correct, no.1, 5 and 6 on the bus.
2,3 & 4 show different colors.
The components have been tested individually and work just fine and consistently.
Everything else is working okay (digits displaying and animation working).
Could this be a timing issue? I have added a delay of 50ms after writing the LED values to each in the hope that would fix.
Do I need to init each exixe?

My code.

`#include "exixe.h"
#include "RTClib.h" // RealTimeClock Library for DS3231

RTC_DS3231 rtc;

// Define parameters for nixies
int cs1 = 10;
int cs2 = 9;
int cs3 = 8;
int cs4 = 7;
int cs5 = 6;
int cs6 = 5;
int brightness = 55;
int overdrive = 0;

// Nixie tube objects
exixe my_tube1 = exixe(cs1);
exixe my_tube2 = exixe(cs2);
exixe my_tube3 = exixe(cs3);
exixe my_tube4 = exixe(cs4);
exixe my_tube5 = exixe(cs5);
exixe my_tube6 = exixe(cs6);

// RGB LED values
int red = 50;
int green = 20;
int blue = 50;

// Rotary encoder pins
#define REA_PIN 2 // D2
#define REB_PIN 3 // D3
#define RESW_PIN A0 // Switch on A0

unsigned long previousMillis = 0;
const long interval = 55000; // interval to change to date display
unsigned long lastFrameTime = 0;
const int frameInterval = EXIXE_ANIMATION_FRAME_DURATION_MS; // 33ms per frame
unsigned long lastLedRefresh = 0;
const int ledRefreshInterval = 1000; // Refresh LEDs every 1s

// Track digits and mode
int prev_digits[6] = {-1, -1, -1, -1, -1, -1};
int target_digits[6] = {0, 0, 0, 0, 0, 0};
bool isDateMode = false;

// Set mode variables
enum SetMode { NORMAL, SET_HOURS, SET_MINUTES, SET_SECONDS, SET_DAY, SET_MONTH, SET_YEAR };
SetMode currentMode = NORMAL;
int setValues[6] = {0, 0, 0, 1, 1, 0}; // Hour, min, sec, day, month, year (last 2 digits)
unsigned long switchPressTime = 0;
bool switchPressed = false;
unsigned long lastBlinkTime = 0;
bool blinkState = true; // Start with tubes on

volatile int encoderPos = 0;

void setup() {
Serial.begin(9600);

if (!rtc.begin()) {
Serial.println("Couldn't find RTC");
while (1);
}

DateTime now = rtc.now();
Serial.print("Current RTC time before check: ");
printTime(now);

const uint32_t MIN_VALID_TIME = 1704067200; // 2024-01-01
if (now.unixtime() < MIN_VALID_TIME) {
Serial.println("RTC time is invalid or too old, setting to compile time...");
rtc.adjust(DateTime(F(DATE), F(TIME)));
Serial.println("RTC initialized to compile time!");
now = rtc.now();
Serial.print("New RTC time: ");
printTime(now);
} else {
Serial.println("RTC time is valid, no adjustment needed.");
}

pinMode(RESW_PIN, INPUT_PULLUP);
pinMode(REA_PIN, INPUT_PULLUP);
pinMode(REB_PIN, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(REA_PIN), encoderISR, CHANGE);

Serial.print("Final RTC time at setup end: ");
printTime(rtc.now());

my_tube1.spi_init();
my_tube1.clear(); delay(10);
my_tube2.clear(); delay(10);
my_tube3.clear(); delay(10);
my_tube4.clear(); delay(10);
my_tube5.clear(); delay(10);
my_tube6.clear(); delay(10);

my_tube1.set_led(red, blue, green); delay(50);
my_tube2.set_led(red, blue, green); delay(50);
my_tube3.set_led(red, blue, green); delay(50);
my_tube4.set_led(red, blue, green); delay(50);
my_tube5.set_led(red, blue, green); delay(50);
my_tube6.set_led(red, blue, green); delay(50);
}

void loop() {
DateTime now = rtc.now();
unsigned long currentMillis = millis();

// Handle switch press
bool currentSwitchState = digitalRead(RESW_PIN) == LOW;
if (currentSwitchState && !switchPressed) {
switchPressTime = currentMillis;
switchPressed = true;
} else if (!currentSwitchState && switchPressed) {
unsigned long pressDuration = currentMillis - switchPressTime;
switchPressed = false;
if (pressDuration < 500) {
if (currentMode == NORMAL) {
currentMode = SET_HOURS;
loadCurrentTime(now);
} else if (currentMode == SET_YEAR) {
saveAndExit();
} else {
currentMode = (SetMode)(currentMode + 1);
}
} else if (pressDuration > 1000) {
saveAndExit();
}
}

// Normal mode: update time/date
if (currentMode == NORMAL) {
if (!isDateMode) {
int hrs = now.hour();
int mins = now.minute();
int secs = now.second();
target_digits[0] = hrs / 10;
target_digits[1] = hrs % 10;
target_digits[2] = mins / 10;
target_digits[3] = mins % 10;
target_digits[4] = secs / 10;
target_digits[5] = secs % 10;
}

if (currentMillis - previousMillis >= interval && !isDateMode) {
  previousMillis = currentMillis;
  isDateMode = true;
  int yrs = now.year() % 100;
  int mth = now.month();
  int dys = now.day();
  target_digits[0] = dys / 10;
  target_digits[1] = dys % 10;
  target_digits[2] = mth / 10;
  target_digits[3] = mth % 10;
  target_digits[4] = yrs / 10;
  target_digits[5] = yrs % 10;
} else if (isDateMode && currentMillis - previousMillis >= 5000) {
  isDateMode = false;
}

if (currentMillis - lastLedRefresh >= ledRefreshInterval) {
  lastLedRefresh = currentMillis;
  my_tube1.set_led(red, blue, green);
  my_tube2.set_led(red, blue, green);
  my_tube3.set_led(red, blue, green);
  my_tube4.set_led(red, blue, green);
  my_tube5.set_led(red, blue, green);
  my_tube6.set_led(red, blue, green);
}

} else {
target_digits[0] = setValues[0] / 10;
target_digits[1] = setValues[0] % 10;
target_digits[2] = setValues[1] / 10;
target_digits[3] = setValues[1] % 10;
target_digits[4] = setValues[2] / 10;
target_digits[5] = setValues[2] % 10;
if (currentMode >= SET_DAY) {
target_digits[0] = setValues[3] / 10;
target_digits[1] = setValues[3] % 10;
target_digits[2] = setValues[4] / 10;
target_digits[3] = setValues[4] % 10;
target_digits[4] = setValues[5] / 10;
target_digits[5] = setValues[5] % 10;
}
adjustSetValue();
}

if (currentMillis - lastFrameTime >= frameInterval) {
lastFrameTime = currentMillis;
updateTubes(currentMillis);
}

if (currentMode == NORMAL) {
Serial.print(now.hour(), DEC);
Serial.print(':');
Serial.print(now.minute(), DEC);
Serial.print(':');
Serial.println(now.second(), DEC);
} else {
Serial.print("Setting: ");
Serial.println(currentMode);
}
}

void encoderISR() {
if (digitalRead(REA_PIN) == digitalRead(REB_PIN)) {
encoderPos--;
} else {
encoderPos++;
}
}

void adjustSetValue() {
static int lastPos = 0;
int delta = encoderPos - lastPos;
if (delta != 0) {
switch (currentMode) {
case SET_HOURS:
setValues[0] = (setValues[0] + delta + 24) % 24;
break;
case SET_MINUTES:
setValues[1] = (setValues[1] + delta + 60) % 60;
break;
case SET_SECONDS:
setValues[2] = (setValues[2] + delta + 60) % 60;
break;
case SET_DAY:
setValues[3] = constrain((setValues[3] + delta), 1, 31);
break;
case SET_MONTH:
setValues[4] = constrain((setValues[4] + delta), 1, 12);
break;
case SET_YEAR:
setValues[5] = (setValues[5] + delta + 100) % 100;
break;
default:
break;
}
lastPos = encoderPos;
}
}

void loadCurrentTime(DateTime now) {
setValues[0] = now.hour();
setValues[1] = now.minute();
setValues[2] = now.second();
setValues[3] = now.day();
setValues[4] = now.month();
setValues[5] = now.year() % 100;
}

void saveAndExit() {
DateTime newTime(2000 + setValues[5], setValues[4], setValues[3],
setValues[0], setValues[1], setValues[2]);
rtc.adjust(newTime);
currentMode = NORMAL;
Serial.println("Time saved!");
printTime(newTime);
}

void updateTubes(unsigned long currentMillis) {
exixe* tubes[6] = {&my_tube1, &my_tube2, &my_tube3, &my_tube4, &my_tube5, &my_tube6};

// Blink logic
if (currentMode != NORMAL && currentMillis - lastBlinkTime >= 500) {
lastBlinkTime = currentMillis;
blinkState = !blinkState;
Serial.print("Blink state: "); // Debug
Serial.println(blinkState);
}

for (int i = 0; i < 6; i++) {
bool shouldBlink = false;
if (currentMode == SET_HOURS && i < 2) shouldBlink = true;
else if (currentMode == SET_MINUTES && i >= 2 && i < 4) shouldBlink = true;
else if (currentMode == SET_SECONDS && i >= 4) shouldBlink = true;
else if (currentMode == SET_DAY && i < 2) shouldBlink = true;
else if (currentMode == SET_MONTH && i >= 2 && i < 4) shouldBlink = true;
else if (currentMode == SET_YEAR && i >= 4) shouldBlink = true;

if (prev_digits[i] != target_digits[i]) {
  tubes[i]->crossfade_init(target_digits[i], 15, brightness, overdrive);
  prev_digits[i] = target_digits[i];
}

if (currentMode != NORMAL && shouldBlink) {
  if (blinkState) {
    tubes[i]->show_digit(target_digits[i], brightness, overdrive); // Show digit
  } else {
    tubes[i]->clear(); // Off
  }
} else {
  tubes[i]->crossfade_run(); // Normal operation or non-blinking tubes
}

}
}

void printTime(DateTime dt) {
Serial.print(dt.year());
Serial.print('/');
Serial.print(dt.month());
Serial.print('/');
Serial.print(dt.day());
Serial.print(" ");
Serial.print(dt.hour());
Serial.print(':');
Serial.print(dt.minute());
Serial.print(':');
Serial.println(dt.second());
}`

[Srafington]

If you rewire them (IE swap CS1 and CS2), do the same boards show incorrect colours, or do the positions of the colour errors remain the same?

[NegativCut]

It's a PCB, not easy to replicate swapping control lines. If i test the exixe-12s individually, they are good. The digits displayed are accurate.

[Srafington]

I had to go back to one of my old projects, and one of your suspicions might be correct. In my 4 digit clock, I had to use the spi_init method on all four exixie objects, and I have no delays between each

#include <exixe.h>

#include <RTClib.h>
#include <RTC_DS3231.h>
#include <Wire.h>

#include <Adafruit_ATParser.h>
#include <Adafruit_BLE.h>
#include <Adafruit_BLEBattery.h>
#include <Adafruit_BLEEddystone.h>
#include <Adafruit_BLEGatt.h>
#include <Adafruit_BLEMIDI.h>
#include <Adafruit_BluefruitLE_SPI.h>
//#include <Adafruit_BluefruitLE_UART.h>
#include <Adafruit_NeoPixel.h>


//Global Vars


#define LED_COUNT 2

#define LED_PIN 6
#define CS_PIN1 10
#define CS_PIN2 11
#define CS_PIN3 12
#define CS_PIN4 13

#define SQW_FREQ DS3231_SQW_FREQ_1024

#define BLUEFRUIT_SPI_CS               8
#define BLUEFRUIT_SPI_IRQ              7
#define BLUEFRUIT_SPI_RST              6   
#define BLE_READPACKET_TIMEOUT         500

// function prototypes over in packetparser.cpp
uint8_t readPacket(Adafruit_BLE *ble, uint16_t timeout);
float parsefloat(uint8_t *buffer);
void printHex(const uint8_t * data, const uint32_t numBytes);

// the packet buffer
extern uint8_t packetbuffer[];

exixe hours1 = exixe(CS_PIN1);
exixe hours2 = exixe(CS_PIN2);

exixe minutes1 = exixe(CS_PIN3);
exixe minutes2 = exixe(CS_PIN4);

bool milTime;
bool blinker;

uint8_t readPacket(Adafruit_BLE *ble, uint16_t timeout);
float parsefloat(uint8_t *buffer);

uint32_t blinkerColour;

Adafruit_BluefruitLE_SPI ble(BLUEFRUIT_SPI_CS, BLUEFRUIT_SPI_IRQ, BLUEFRUIT_SPI_RST);
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_RGB + NEO_KHZ800);

RTC_DS3231 RTC;

void setup()
{
  Wire.begin();
  RTC.begin();
  DateTime now = RTC.now();
  DateTime compiled = DateTime(__DATE__, __TIME__);
  if (now.unixtime() < compiled.unixtime()) {
    //Serial.println("RTC is older than compile time!  Updating");
    RTC.adjust(DateTime(__DATE__, __TIME__));
  }
  RTC.enable32kHz(true);
  RTC.SQWEnable(true);
  RTC.BBSQWEnable(true);
  RTC.SQWFrequency(SQW_FREQ);

  hours1.spi_init();
  hours1.clear();
  hours2.spi_init();
  hours2.clear();
  minutes1.spi_init();
  minutes1.clear();
  minutes2.spi_init();
  minutes2.clear();
  
  setLedColour(255, 140, 0);

  milTime = false;
  blinker = true;

  ble.begin();
  ble.setMode(BLUEFRUIT_MODE_DATA);
}

void loop()
{

  setDisplay();
  if (blinker)
  {
    strip.fill(blinkerColour, 0, 2);
  }
  else
  {
    strip.clear();
  }
  strip.show();
  blinker = !blinker;
  delay(500);
}

void setDisplay()
{
  uint8_t hours;
  uint8_t minutes;
  DateTime now = RTC.now();
  hours = now.hour();
  minutes = now.minute();
  if (!milTime && hours > 12)
  {
    hours -= 12;
    hours1.set_dots(127, 127);
  } else {
    hours1.set_dots(0,0);
  }
  hours1.show_digit(hours / 10, 127, 0);
  hours2.show_digit(hours % 10, 127, 1);

  minutes1.show_digit(minutes / 10, 127, 0);
  minutes2.show_digit(minutes % 10, 127, 0);
  pollBluetooth();
}

void setLedColour(uint8_t r, uint8_t g, uint8_t b)
{
  blinkerColour = strip.Color(r, g, b);
  strip.setBrightness(10);
  hours1.set_led(r, g, b);
  hours2.set_led(r, g, b);
  minutes1.set_led(r, g, b);
  minutes2.set_led(r, g, b);
}

void adjustTime(uint8_t hour1, uint8_t hour2, uint8_t minute1, uint8_t minute2)
{
  DateTime now = RTC.now();
  uint8_t hours = now.hour();
  uint8_t minutes = now.minute();

  hours += hour1 * 10 + hour2;
  minutes += minute1 * 10 + minute2;
  
  if (hours > 23)
  {
    hours -= 24;
  }
  if (hours == 0) {
    hours = 12;
  }
  if (minutes > 59)
  {
    minutes -= 60;
  }

  DateTime newDt(now.year(), now.month(), now.day(), hours, minutes, 0);
  RTC.adjust(newDt);
  setDisplay();
}

void pollBluetooth()
{
  uint8_t len = readPacket(&ble, BLE_READPACKET_TIMEOUT);
  if (len == 0)
    return;

  // Color
  if (packetbuffer[1] == 'C')
  {
    uint8_t red = packetbuffer[2];
    uint8_t green = packetbuffer[3];
    uint8_t blue = packetbuffer[4];
    setLedColour(red, green, blue);
  }
    
  // button
  if (packetbuffer[3] == '0' && packetbuffer[1] == 'B')
  {
    uint8_t buttnum = packetbuffer[2] - '0';
    switch (buttnum)
    {
    case 1:
      adjustTime(1, 0, 0, 0);
      break;
    case 2:
      adjustTime(0, 1, 0, 0);
      break;
    case 3:
      adjustTime(0, 0, 1, 0);
      break;
    case 4:
      adjustTime(0, 0, 0, 1);
      break;
    default: milTime = !milTime;
    }
  }
}

[NegativCut]

Interesting, I'll give it a try for sure, thanks.

[NegativCut]

Yea, that didn't do anything.
I'm gonna desolder the IN-12s from a couple exixe-12s and inspect them closely just to satisfy my curiosity.
One working, one not.
My clock PCB is clean and the SPI bus seems error free (logic analyser).
They seem to work individually.
Bizarre but worth a look I reckon.