Monthly Archives: November 2025

GPS-enabled Dash Cam Power Switch

12 November 2025 Update:

My USB-to-Serial adapter arrived today, and I was able to connect it to my GPS switching board, bypassing the actual GPS. Then I was able to use the NMEA simulator to transmit NMEA messages to the Sparkfun Pro Micro and test the Dash Cam power switch algorithm.

This combination worked great! I started the action, NMEA sentences started flowing to the Pro Micro which output decoded speed values to the debug window. I could run the speed up and down and watch the program toggle power to the load (39-Ohm power resistor) in response to the speed changes. The only things left to do are to build an enclosure and change the time and speed threshold parameters. Here’s the ‘final’ code:

/*
    Name:       GT_U7_GPS.ino
    Created:	11/8/2025 9:51:34 PM
    Author:     FRANK_XPS_9530\Frank
*/

#define MIN_SPEED_THRESHOLD_MPH 5
#define MAX_TOO_SLOW_TIME_THRESHOLD_MIN 1 //for debug - change to 20 later
#define POWER_SWITCH_PIN 10

//#include <TinyGPS++.h>
#include <TinyGPSPlus.h>
#include <SoftwareSerial.h>
#include <ElapsedMillis.h>
elapsedSeconds SecSinceTooSlow;

// Define the pins for RX and TX
static const int RXPin = 8, TXPin = 9;
static const uint32_t GPSBaud = 9600;

// Create a TinyGPS++ object
TinyGPSPlus gps;

// Create a SoftwareSerial object
SoftwareSerial ss(RXPin, TXPin);

void setup() 
{
  Serial.begin(115200);
  ss.begin(GPSBaud);
  Serial.println(F("GPS Start"));
  SecSinceTooSlow = 0;
  pinMode(POWER_SWITCH_PIN, OUTPUT);
}

void loop() {
  // Read data from the GPS module
  while (ss.available() > 0) 
  {
    if (gps.encode(ss.read())) 
    {
      displayInfo();

      //update power switch state
      if (!UpdatePowerCondition())
      {
        Serial.println("UpdatePowerCondition() returned FALSE - Powering OFF");
        digitalWrite(POWER_SWITCH_PIN, LOW);

      }
      else
      {
        Serial.println("UpdatePowerCondition() returned TRUE - Powering ON");
        digitalWrite(POWER_SWITCH_PIN, HIGH);
      }

    }
  }
  // Check if no GPS data is received
  if (millis() > 5000 && gps.charsProcessed() < 10) 
  {
    Serial.println(F("No GPS detected: check wiring."));
    while (true);
  }
}
void displayInfo() 
{
  //Serial.print(F("Location: "));
  //if (gps.location.isValid()) {
  //  Serial.print(gps.location.lat(), 6);
  //  Serial.print(F(","));
  //  Serial.print(gps.location.lng(), 6);
  //}
  //else 
  //{
  //  Serial.print(F("INVALID"));
  //}

  //11/10/25 gfp dropped 'Location', added 'Speed'
  Serial.print(F("Speed: "));
  if(gps.speed.isValid())
  {
    Serial.print(gps.speed.mph(), 3);
  }
  else
  {
    Serial.print(F("INVALID"));
  }

  Serial.print(F(" Date/Time: "));
  if (gps.date.isValid()) 
  {
    Serial.print(gps.date.month());
    Serial.print(F("/"));
    Serial.print(gps.date.day());
    Serial.print(F("/"));
    Serial.print(gps.date.year());
  }
  else 
  {
    Serial.print(F("INVALID"));
  }
  Serial.print(F(" "));
  //if (gps.time.isValid()) 
  //{
  //  if (gps.time.hour() < 10) Serial.print(F("0"));
  //  Serial.print(gps.time.hour());
  //  Serial.print(F(":"));
  //  if (gps.time.minute() < 10) Serial.print(F("0"));
  //  Serial.print(gps.time.minute());
  //  Serial.print(F(":"));
  //  if (gps.time.second() < 10) Serial.print(F("0"));
  //  Serial.print(gps.time.second());
  //  Serial.print(F("."));
  //  if (gps.time.centisecond() < 10) Serial.print(F("0"));
  //  Serial.print(gps.time.centisecond());
  //}
  //else {
  //  Serial.print(F("INVALID"));
  //}
  PrintTime();
  Serial.println();
}

bool UpdatePowerCondition()
{
  //Purpose: Determine if output power should be enabled or disabled
  //Inputs: SecSinceTooSlow = UnsignedLong indicating sec since speed fell below threshold
  //Outputs: False if speed < UpdatePowerCondition() AND elapsed time under speed threshold is > MAX_TIME_THRESHOLD_MIN
  //         Otherwise True.
  //Procedure:
  //  Step1: Get speed from GPS. If > threshold, reset SecSinceTooSlow to zero and return TRUE.
  //  Step2: If speed < threshold AND SecSinceTooSlow > threshold, return FALSE

  bool result = false; //default is to kill the power

//Step1: Get speed from GPS. If > threshold, reset SecSinceTooSlow to zero and return TRUE.
  if (gps.speed.mph() >= (double)MIN_SPEED_THRESHOLD_MPH)
  {
    Serial.print("Power ON at: ");
    PrintTime();
    Serial.println();

    Serial.print("Speed greater than threshold; Resetting SecSinceTooSlow from "); Serial.println(SecSinceTooSlow);
    SecSinceTooSlow = 0; //reset elapsed time
    
    result = true;
  }

//Step2: If speed < threshold AND SecSinceTooSlow > threshold, return FALSE
  if (gps.speed.mph() < (double)MIN_SPEED_THRESHOLD_MPH)
  {
    Serial.print("Speed below threshold at "); PrintTime(); Serial.print(" with SecSinceTooSlow = "); Serial.println(SecSinceTooSlow);

    if (SecSinceTooSlow >= (unsigned long)(60 * MAX_TOO_SLOW_TIME_THRESHOLD_MIN))
    {
      result = false;
    }
    else
    {
      result = true;
    }
  }
  
  return result;
}

void PrintTime()
{
  if (gps.time.isValid())
  {
    if (gps.time.hour() < 10) Serial.print(F("0"));
    Serial.print(gps.time.hour());
    Serial.print(F(":"));
    if (gps.time.minute() < 10) Serial.print(F("0"));
    Serial.print(gps.time.minute());
    Serial.print(F(":"));
    if (gps.time.second() < 10) Serial.print(F("0"));
    Serial.print(gps.time.second());
    Serial.print(F("."));
    if (gps.time.centisecond() < 10) Serial.print(F("0"));
    Serial.print(gps.time.centisecond());
  }
  else 
  {
    Serial.print(F("INVALID"));
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

Name: GT_U7_GPS.ino

Created: 11/8/2025 9:51:34 PM

Author: FRANK_XPS_9530\Frank

#define MIN_SPEED_THRESHOLD_MPH 5

#define MAX_TOO_SLOW_TIME_THRESHOLD_MIN 1 //for debug - change to 20 later

#define POWER_SWITCH_PIN 10

//#include <TinyGPS++.h>

#include <TinyGPSPlus.h>

#include <SoftwareSerial.h>

#include <ElapsedMillis.h>

elapsedSeconds SecSinceTooSlow;

// Define the pins for RX and TX

static const int RXPin = 8, TXPin = 9;

static const uint32_t GPSBaud = 9600;

// Create a TinyGPS++ object

TinyGPSPlus gps;

// Create a SoftwareSerial object

SoftwareSerial ss(RXPin, TXPin);

void setup()

{

Serial.begin(115200);

ss.begin(GPSBaud);

Serial.println(F("GPS Start"));

SecSinceTooSlow = 0;

pinMode(POWER_SWITCH_PIN, OUTPUT);

}

void loop() {

// Read data from the GPS module

while (ss.available() > 0)

{

if (gps.encode(ss.read()))

{

displayInfo();

//update power switch state

if (!UpdatePowerCondition())

{

Serial.println("UpdatePowerCondition() returned FALSE - Powering OFF");

digitalWrite(POWER_SWITCH_PIN, LOW);

}

else

{

Serial.println("UpdatePowerCondition() returned TRUE - Powering ON");

digitalWrite(POWER_SWITCH_PIN, HIGH);

}

// Check if no GPS data is received

if (millis() > 5000 && gps.charsProcessed() < 10)

{

Serial.println(F("No GPS detected: check wiring."));

while (true);

}

void displayInfo()

{

//Serial.print(F("Location: "));

//if (gps.location.isValid()) {

// Serial.print(gps.location.lat(), 6);

// Serial.print(F(","));

// Serial.print(gps.location.lng(), 6);

//}

//else

//{

// Serial.print(F("INVALID"));

//}

//11/10/25 gfp dropped 'Location', added 'Speed'

Serial.print(F("Speed: "));

if(gps.speed.isValid())

{

Serial.print(gps.speed.mph(), 3);

}

else

{

Serial.print(F("INVALID"));

}

Serial.print(F(" Date/Time: "));

if (gps.date.isValid())

{

Serial.print(gps.date.month());

Serial.print(F("/"));

Serial.print(gps.date.day());

Serial.print(F("/"));

Serial.print(gps.date.year());

}

else

{

Serial.print(F("INVALID"));

}

Serial.print(F(" "));

//if (gps.time.isValid())

//{

// if (gps.time.hour() < 10) Serial.print(F("0"));

// Serial.print(gps.time.hour());

// Serial.print(F(":"));

// if (gps.time.minute() < 10) Serial.print(F("0"));

// Serial.print(gps.time.minute());

// Serial.print(F(":"));

// if (gps.time.second() < 10) Serial.print(F("0"));

// Serial.print(gps.time.second());

// Serial.print(F("."));

// if (gps.time.centisecond() < 10) Serial.print(F("0"));

// Serial.print(gps.time.centisecond());

//}

//else {

// Serial.print(F("INVALID"));

//}

PrintTime();

Serial.println();

}

bool UpdatePowerCondition()

{

//Purpose: Determine if output power should be enabled or disabled

//Inputs: SecSinceTooSlow = UnsignedLong indicating sec since speed fell below threshold

//Outputs: False if speed < UpdatePowerCondition() AND elapsed time under speed threshold is > MAX_TIME_THRESHOLD_MIN

// Otherwise True.

//Procedure:

// Step1: Get speed from GPS. If > threshold, reset SecSinceTooSlow to zero and return TRUE.

// Step2: If speed < threshold AND SecSinceTooSlow > threshold, return FALSE

bool result = false; //default is to kill the power

//Step1: Get speed from GPS. If > threshold, reset SecSinceTooSlow to zero and return TRUE.

if (gps.speed.mph() >= (double)MIN_SPEED_THRESHOLD_MPH)

{

Serial.print("Power ON at: ");

PrintTime();

Serial.println();

Serial.print("Speed greater than threshold; Resetting SecSinceTooSlow from "); Serial.println(SecSinceTooSlow);

SecSinceTooSlow = 0; //reset elapsed time

result = true;

}

//Step2: If speed < threshold AND SecSinceTooSlow > threshold, return FALSE

if (gps.speed.mph() < (double)MIN_SPEED_THRESHOLD_MPH)

{

Serial.print("Speed below threshold at "); PrintTime(); Serial.print(" with SecSinceTooSlow = "); Serial.println(SecSinceTooSlow);

if (SecSinceTooSlow >= (unsigned long)(60 * MAX_TOO_SLOW_TIME_THRESHOLD_MIN))

{

result = false;

}

else

{

result = true;

}

return result;

}

void PrintTime()

{

if (gps.time.isValid())

{

if (gps.time.hour() < 10) Serial.print(F("0"));

Serial.print(gps.time.hour());

Serial.print(F(":"));

if (gps.time.minute() < 10) Serial.print(F("0"));

Serial.print(gps.time.minute());

Serial.print(F(":"));

if (gps.time.second() < 10) Serial.print(F("0"));

Serial.print(gps.time.second());

Serial.print(F("."));

if (gps.time.centisecond() < 10) Serial.print(F("0"));

Serial.print(gps.time.centisecond());

}

else

{

Serial.print(F("INVALID"));

}

26 November 2025 Update:

Thinking about how to test my GPS-enabled power switch project, I decided to add a cheap LCD display so I could monitor GPS output and power switch status in real time. So, I reached into my parts box and what came out was a pair of ‘Cheap Yellow Display’ modules had been laying around for some time now. As I started working with the display, I realized it wasn’t just a display; the ESP32-2432S028R development board that runs the touch-sensitive display incorporates a ESP32-WROOM-32 module as its main microcontroller. This module features a dual-core Xtensa LX6 processor running at up to 240 MHz, 520 KB SRAM, 448 KB ROM, integrated Wi-Fi (802.11 b/g/n) and Bluetooth (v4.2 BR/EDR and BLE), and 4 MB flash memory. In addition, the board has a standard micro-USB port for power and programming, a USB-C port for power, three 4-pin micro-JST 1.25mm pitch connectors for UART and GPIO, and a 2-pin micro-JST connector for a speaker. Looking at the specs, I realized I could conceivably eliminate the Sparkfun Pro Micro module entirely, and have just the display/CYD connected to the GPS via CN1 (4-pin GPIO/power/GND) and a single GPIO output (plus GND) to run the power switch.

A not-so-insignificant hitch in the getalong for this project was the type of connector required to interface to the sockets on the CYD. It turns out these are ‘micro JST 1.25mm’ connectors, and it took me three tries with Amazon to get the right ones. These are the correct ones.

I was able to easily connect the GPS input to CN1 and use the NMEA simulator to test the code, ported over from the Pro Micro project. However, I hit a roadblock when I went looking for a GPIO port to use as a switch signal to the power switch board; it turns out the display occupies most of the GPIO lines, and the two ports needed for GPS Txd & Rxd took the only remaining output-capable lines (IO35 is available, but it is input-only). Some more research with the help of Grok led me to this project site that describes how to free up ports via hardware mods. There I found directions for freeing up IO21, the port that normally controls display backlight brightness by PWM-ing the backlight LED. This involved removing a surface-mount transistor and re-orienting a TINY! surface-mount 3.9 Ω current-limiting resistor, as shown in the screenshot below:

As you might guess, this took some doing, as these parts are TINY!

But after a couple of false starts, I got it done:

The photo below shows the CYD module with GPS data displayed, and with my newly-liberated IO21 line connected to the power switch board (the illuminated red LED shows that the power switch is ON)

So now we are pretty close to being done; all that is left is to mount the display/controller into its box, mount both the display & power switch boxes onto their custom-printed carrier, and test the whole thing in my truck. The ‘final’ (to the extent that anything I do is actually final) code is shown below:

/*
    Name:       GrokGTU7_GPStoCYD.ino
    Created:	11/24/2025 4:25:32 PM
    Author:     FRANK_XPS_9530\Frank
*/


#include <HardwareSerial.h>
#include <TinyGPSplus.h>
#include <TFT_eSPI.h>  // Or include <lvgl.h> if using LVGL
#include <ElapsedMillis.h>


#define GPS_RX_PIN 27  // CYD GPIO27 as RX (from GT-U7 TX)
#define GPS_TX_PIN 22  // CYD GPIO22 as TX (to GT-U7 RX)
#define DASHCAM_POWER_SWITCH_PIN 21 //See https://github.com/hexeguitar/ESP32_TFT_PIO?tab=readme-ov-file#adding-psram
#define POWER_SWITCH_TRIGGER_PIN 35 //directly manipulate POWER_SWITCH_PIN state for debug
#define GPS_BAUD 9600

#define MAX_SEC_WITHOUT_GPS_DATA 600 //10 min
#define MIN_SPEED_THRESHOLD_MPH 10 //10 mph
#define MAX_TOO_SLOW_TIME_THRESHOLD_SEC 300 //5 min
#define MIN_NUM_SATELLITES_THRESHOLD 4 //4 satellites

//onboard RGB LED
#define PIN_LED_R 4   // Red - use for power OFF
#define PIN_LED_G 16  // Green - use for power ON
#define PIN_LED_B 17  // Blue  - unused


HardwareSerial gpsSerial(2);  // Use UART2
TinyGPSPlus gps;
TFT_eSPI tft = TFT_eSPI();  // For basic display

const int labelX = 10;      // X position for labels
const int valueX = 160;     // X position for values (after label and "=")
const int startY = 10;      // Starting Y for first line
const int lineHeight = 20;  // Spacing between lines (text size 2 needs ~16-20px)
const int valueWidth = 150; // Width of value area to clear (estimate based on max chars)
const int valueHeight = lineHeight;

elapsedMillis MsecSinceTooSlow;
elapsedMillis MsecSinceLastGPSData;

int SecSinceTooSlow = 0;
int SecSinceGPSData = 0;
bool SwitchState = false; //power switch defaults to OFF

void setup() 
{
  Serial.begin(115200);  // For debugging
  gpsSerial.begin(GPS_BAUD, SERIAL_8N1, GPS_RX_PIN, GPS_TX_PIN);
  pinMode(DASHCAM_POWER_SWITCH_PIN, OUTPUT);
  pinMode(POWER_SWITCH_TRIGGER_PIN, INPUT_PULLDOWN);
  pinMode(PIN_LED_R, OUTPUT);
  pinMode(PIN_LED_G, OUTPUT);
  pinMode(PIN_LED_B, OUTPUT);

  tft.init();
  tft.setRotation(3);  // Landscape
  tft.invertDisplay(1);  // Fix color inversion
  tft.fillScreen(TFT_BLACK);
  tft.setTextColor(TFT_WHITE);
  tft.setTextSize(2);

  // Draw static labels and "=" once
  tft.setCursor(labelX, startY);
  tft.print("Time = ");
  tft.setCursor(labelX, startY +lineHeight);
  tft.print("Sats = ");
  tft.setCursor(labelX, startY + 2 * lineHeight);
  tft.print("Speed = ");
  tft.setCursor(labelX, startY + 3 * lineHeight);
  tft.print("SSTL = ");
  tft.setCursor(labelX, startY + 4 * lineHeight);
  tft.print("SGPSD = ");
  tft.setCursor(labelX, startY + 5 * lineHeight);
  tft.print("Avail = ");
  tft.setCursor(labelX, startY + 6 * lineHeight);
  tft.print("Power = ");

  // Initial values (optional; could be blanks or "N/A")
  updateValues(0, 0, 0, 0, 0.0, 0, 0, 0, 0);

//DEBUG!!
  //digitalWrite(DASHCAM_POWER_SWITCH_PIN, LOW);
  //Serial.printf("POWER_SWITCH_PIN State = %d", digitalRead(DASHCAM_POWER_SWITCH_PIN));
//DEBUG!!
  EnableDashCamPower(false);
}

void loop() 
{
  setLEDColor(LOW, HIGH, HIGH);  // Red ON no GPS data available
  //Serial.printf("In outer loop - LED should be RED\n");

  while (gpsSerial.available() > 0) 
  {
    if (gps.encode(gpsSerial.read())) 
    {
      if (gps.location.isValid()) 
      {
        //Serial.printf("In 'valid' branch - LED should be GREEN\n");
        setLEDColor(HIGH, LOW, HIGH);  // Green ON - valie GPS data available

        updateValues(gps.time.hour(), gps.time.minute(), gps.time.second(),
          gps.satellites.value(), gps.speed.mph(), SecSinceTooSlow, SecSinceGPSData,
          Serial1.available(), SwitchState);

        delay(1000);
      }
      else 
      {
        setLEDColor(HIGH, HIGH, LOW);  //BLUE - GPS data available, but no lock
        //Serial.printf("In 'else' branch - LED should be BLUE\n");
      }
    }

    UpdatePowerSwitchState();
  }

  delay(1000);  // Update every second
}

void updateValues(int hour, int min, int sec, int sats, float speed, int SecSinceTooSlow,
                  int SecSinceValidGPSData, int AvailChars, int SwitchState  ) 
{
  tft.setTextColor(TFT_WHITE, TFT_BLACK);

  // Update Time
  tft.fillRect(valueX, startY, valueWidth, valueHeight, TFT_BLACK);  // Clear value area
  tft.setCursor(valueX, startY);
  tft.printf("%d:%d:%d", hour, min, sec);

  // Update Satellites
  tft.fillRect(valueX, startY + lineHeight, valueWidth, valueHeight, TFT_BLACK);  // Clear value area
  tft.setCursor(valueX, startY + lineHeight);
  tft.printf("%d", sats);

  // Update Speed
  tft.fillRect(valueX, startY + 2*lineHeight, valueWidth, valueHeight, TFT_BLACK);
  tft.setCursor(valueX, startY + 2* lineHeight);
  tft.printf("%.1f mph", speed);

  // Update SSTL (Since Speed Too Low)
  tft.fillRect(valueX, startY + 3 * lineHeight, valueWidth, valueHeight, TFT_BLACK);  // Clear value area
  tft.setCursor(valueX, startY + 3 * lineHeight);
  tft.printf("%d Sec", (int)(MsecSinceTooSlow/1000));

  // Update SSGPSD (Seconds Since GPS Data)
  tft.fillRect(valueX, startY + 4 * lineHeight, valueWidth, valueHeight, TFT_BLACK);  // Clear value area
  tft.setCursor(valueX, startY + 4 * lineHeight);
  tft.printf("%d Sec", (int)(MsecSinceLastGPSData / 1000));

  // Update Characters Remaining
  tft.fillRect(valueX, startY + 5 * lineHeight, valueWidth, valueHeight, TFT_BLACK);
  tft.setCursor(valueX, startY + 5 * lineHeight);
  tft.printf("%d char", Serial1.available());

  // Update Power Switch State
  tft.fillRect(valueX, startY + 6 * lineHeight, valueWidth, valueHeight, TFT_BLACK);
  tft.setCursor(valueX, startY + 6 * lineHeight);

  int trigger_state = digitalRead(POWER_SWITCH_TRIGGER_PIN);
  String statestr = digitalRead(DASHCAM_POWER_SWITCH_PIN) == HIGH ? "ON" : "OFF";
  tft.printf("%s", statestr);
}

void UpdatePowerSwitchState()
{
  //Serial.printf("In UpdatePowerSwitchState()\n");
  //Purpose: Update power switch state 
  //Inputs: 
  // MsecSinceTooSlow = Unsigned Long indicating Msec since speed fell below threshold
  // MsecSinceLastData = Unsigned Long indicating Msec since last GPS data 
  // gps object methods/properties
  //Outputs:
  // Power OFF if GPS data has been missing for more than MAX_SEC_WITHOUT_GPS_DATA
  // Power OFF if [speed < MIN_SPEED_THRESHOLD_MPH OR numsats <=0] AND elapsed time under speed threshold is > MAX_TIME_THRESHOLD_MIN
  //         Otherwise Power ON.
  //Procedure:
  //  Step1: If speed from GPS > threshold, reset MsecSinceTooSlow to zero and Set power to ON
  //  Step2: If (speed < threshold OR numsats < threshold) AND MsecSinceTooSlow > Set power to OFF

//DEBUG:
  //Serial.printf(UpdateTelemStr, gps.time.hour(), gps.time.minute(), gps.time.second(),
  //  gps.speed.knots(), gps.satellites.value(), (unsigned long)MsecSinceTooSlow, (unsigned long)MsecSinceLastGPSData,
  //  Serial1.available(), digitalRead(DASHCAM_POWER_SWITCH_PIN) == HIGH ? "ON" : "OFF");
  //  Serial.printf("In UpdatePowerSwitchState().  Speed = %2.1f, Sats = %d\n", gps.speed.mph(), gps.satellites.value());
//DEBUG:

  if (((int)MsecSinceLastGPSData /1000) > MAX_SEC_WITHOUT_GPS_DATA && digitalRead(DASHCAM_POWER_SWITCH_PIN) == HIGH)
  {
//DEBUG:
    Serial.printf("Powering OFF at %02d:%02d:%02d\n", gps.time.hour(), gps.time.minute(), gps.time.second());
//DEBUG:

    EnableDashCamPower(false);//turn dashcam power OFF
    return;
  }

  if ((gps.speed.mph() < (double)MIN_SPEED_THRESHOLD_MPH || (gps.satellites.value() < MIN_NUM_SATELLITES_THRESHOLD))
    && ((int)MsecSinceTooSlow / 1000) > MAX_TOO_SLOW_TIME_THRESHOLD_SEC && digitalRead(DASHCAM_POWER_SWITCH_PIN) == HIGH)
  {
//DEBUG:
    Serial.printf("Powering OFF at %02d:%02d:%02d\n", gps.time.hour(), gps.time.minute(), gps.time.second());
//DEBUG:

    EnableDashCamPower(false);//turn dashcam power OFF
    return;
  }

  if (gps.speed.mph() >= (double)MIN_SPEED_THRESHOLD_MPH && gps.satellites.value() >= MIN_NUM_SATELLITES_THRESHOLD)
  {
    MsecSinceTooSlow = 0;
    MsecSinceLastGPSData = 0;

    //Serial.printf("DashCam Power Switch state = %d\n", digitalRead(DASHCAM_POWER_SWITCH_PIN));

    if (digitalRead(DASHCAM_POWER_SWITCH_PIN) == LOW)
    {
//DEBUG:
      Serial.printf("Powering ON at %02d:%02d:%02d\n", gps.time.hour(), gps.time.minute(), gps.time.second());
//DEBUG:

      EnableDashCamPower(true);//turn dashcam power ON
      return;
    }
  }
}

void EnableDashCamPower(bool enable)
{
  digitalWrite(DASHCAM_POWER_SWITCH_PIN, enable);
}

// Helper function to set RGB states
void setLEDColor(int redState, int greenState, int blueState) {
  digitalWrite(PIN_LED_R, redState);
  digitalWrite(PIN_LED_G, greenState);
  digitalWrite(PIN_LED_B, blueState);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

Name: GrokGTU7_GPStoCYD.ino

Created: 11/24/2025 4:25:32 PM

Author: FRANK_XPS_9530\Frank

#include <HardwareSerial.h>

#include <TinyGPSplus.h>

#include <TFT_eSPI.h> // Or include <lvgl.h> if using LVGL

#include <ElapsedMillis.h>

#define GPS_RX_PIN 27 // CYD GPIO27 as RX (from GT-U7 TX)

#define GPS_TX_PIN 22 // CYD GPIO22 as TX (to GT-U7 RX)

#define DASHCAM_POWER_SWITCH_PIN 21 //See https://github.com/hexeguitar/ESP32_TFT_PIO?tab=readme-ov-file#adding-psram

#define POWER_SWITCH_TRIGGER_PIN 35 //directly manipulate POWER_SWITCH_PIN state for debug

#define GPS_BAUD 9600

#define MAX_SEC_WITHOUT_GPS_DATA 600 //10 min

#define MIN_SPEED_THRESHOLD_MPH 10 //10 mph

#define MAX_TOO_SLOW_TIME_THRESHOLD_SEC 300 //5 min

#define MIN_NUM_SATELLITES_THRESHOLD 4 //4 satellites

//onboard RGB LED

#define PIN_LED_R 4 // Red - use for power OFF

#define PIN_LED_G 16 // Green - use for power ON

#define PIN_LED_B 17 // Blue - unused

HardwareSerial gpsSerial(2); // Use UART2

TinyGPSPlus gps;

TFT_eSPI tft = TFT_eSPI(); // For basic display

const int labelX = 10; // X position for labels

const int valueX = 160; // X position for values (after label and "=")

const int startY = 10; // Starting Y for first line

const int lineHeight = 20; // Spacing between lines (text size 2 needs ~16-20px)

const int valueWidth = 150; // Width of value area to clear (estimate based on max chars)

const int valueHeight = lineHeight;

elapsedMillis MsecSinceTooSlow;

elapsedMillis MsecSinceLastGPSData;

int SecSinceTooSlow = 0;

int SecSinceGPSData = 0;

bool SwitchState = false; //power switch defaults to OFF

void setup()

{

Serial.begin(115200); // For debugging

gpsSerial.begin(GPS_BAUD, SERIAL_8N1, GPS_RX_PIN, GPS_TX_PIN);

pinMode(DASHCAM_POWER_SWITCH_PIN, OUTPUT);

pinMode(POWER_SWITCH_TRIGGER_PIN, INPUT_PULLDOWN);

pinMode(PIN_LED_R, OUTPUT);

pinMode(PIN_LED_G, OUTPUT);

pinMode(PIN_LED_B, OUTPUT);

tft.init();

tft.setRotation(3); // Landscape

tft.invertDisplay(1); // Fix color inversion

tft.fillScreen(TFT_BLACK);

tft.setTextColor(TFT_WHITE);

tft.setTextSize(2);

// Draw static labels and "=" once

tft.setCursor(labelX, startY);

tft.print("Time = ");

tft.setCursor(labelX, startY +lineHeight);

tft.print("Sats = ");

tft.setCursor(labelX, startY + 2 * lineHeight);

tft.print("Speed = ");

tft.setCursor(labelX, startY + 3 * lineHeight);

tft.print("SSTL = ");

tft.setCursor(labelX, startY + 4 * lineHeight);

tft.print("SGPSD = ");

tft.setCursor(labelX, startY + 5 * lineHeight);

tft.print("Avail = ");

tft.setCursor(labelX, startY + 6 * lineHeight);

tft.print("Power = ");

// Initial values (optional; could be blanks or "N/A")

updateValues(0, 0, 0, 0, 0.0, 0, 0, 0, 0);

//DEBUG!!

//digitalWrite(DASHCAM_POWER_SWITCH_PIN, LOW);

//Serial.printf("POWER_SWITCH_PIN State = %d", digitalRead(DASHCAM_POWER_SWITCH_PIN));

//DEBUG!!

EnableDashCamPower(false);

}

void loop()

{

setLEDColor(LOW, HIGH, HIGH); // Red ON no GPS data available

//Serial.printf("In outer loop - LED should be RED\n");

while (gpsSerial.available() > 0)

{

if (gps.encode(gpsSerial.read()))

{

if (gps.location.isValid())

{

//Serial.printf("In 'valid' branch - LED should be GREEN\n");

setLEDColor(HIGH, LOW, HIGH); // Green ON - valie GPS data available

updateValues(gps.time.hour(), gps.time.minute(), gps.time.second(),

gps.satellites.value(), gps.speed.mph(), SecSinceTooSlow, SecSinceGPSData,

Serial1.available(), SwitchState);

delay(1000);

}

else

{

setLEDColor(HIGH, HIGH, LOW); //BLUE - GPS data available, but no lock

//Serial.printf("In 'else' branch - LED should be BLUE\n");

}

UpdatePowerSwitchState();

}

delay(1000); // Update every second

}

void updateValues(int hour, int min, int sec, int sats, float speed, int SecSinceTooSlow,

int SecSinceValidGPSData, int AvailChars, int SwitchState )

{

tft.setTextColor(TFT_WHITE, TFT_BLACK);

// Update Time

tft.fillRect(valueX, startY, valueWidth, valueHeight, TFT_BLACK); // Clear value area

tft.setCursor(valueX, startY);

tft.printf("%d:%d:%d", hour, min, sec);

// Update Satellites

tft.fillRect(valueX, startY + lineHeight, valueWidth, valueHeight, TFT_BLACK); // Clear value area

tft.setCursor(valueX, startY + lineHeight);

tft.printf("%d", sats);

// Update Speed

tft.fillRect(valueX, startY + 2*lineHeight, valueWidth, valueHeight, TFT_BLACK);

tft.setCursor(valueX, startY + 2* lineHeight);

tft.printf("%.1f mph", speed);

// Update SSTL (Since Speed Too Low)

tft.fillRect(valueX, startY + 3 * lineHeight, valueWidth, valueHeight, TFT_BLACK); // Clear value area

tft.setCursor(valueX, startY + 3 * lineHeight);

tft.printf("%d Sec", (int)(MsecSinceTooSlow/1000));

// Update SSGPSD (Seconds Since GPS Data)

tft.fillRect(valueX, startY + 4 * lineHeight, valueWidth, valueHeight, TFT_BLACK); // Clear value area

tft.setCursor(valueX, startY + 4 * lineHeight);

tft.printf("%d Sec", (int)(MsecSinceLastGPSData / 1000));

// Update Characters Remaining

tft.fillRect(valueX, startY + 5 * lineHeight, valueWidth, valueHeight, TFT_BLACK);

tft.setCursor(valueX, startY + 5 * lineHeight);

tft.printf("%d char", Serial1.available());

// Update Power Switch State

tft.fillRect(valueX, startY + 6 * lineHeight, valueWidth, valueHeight, TFT_BLACK);

tft.setCursor(valueX, startY + 6 * lineHeight);

int trigger_state = digitalRead(POWER_SWITCH_TRIGGER_PIN);

String statestr = digitalRead(DASHCAM_POWER_SWITCH_PIN) == HIGH ? "ON" : "OFF";

tft.printf("%s", statestr);

}

void UpdatePowerSwitchState()

{

//Serial.printf("In UpdatePowerSwitchState()\n");

//Purpose: Update power switch state

//Inputs:

// MsecSinceTooSlow = Unsigned Long indicating Msec since speed fell below threshold

// MsecSinceLastData = Unsigned Long indicating Msec since last GPS data

// gps object methods/properties

//Outputs:

// Power OFF if GPS data has been missing for more than MAX_SEC_WITHOUT_GPS_DATA

// Power OFF if [speed < MIN_SPEED_THRESHOLD_MPH OR numsats <=0] AND elapsed time under speed threshold is > MAX_TIME_THRESHOLD_MIN

// Otherwise Power ON.

//Procedure:

// Step1: If speed from GPS > threshold, reset MsecSinceTooSlow to zero and Set power to ON

// Step2: If (speed < threshold OR numsats < threshold) AND MsecSinceTooSlow > Set power to OFF

//DEBUG:

//Serial.printf(UpdateTelemStr, gps.time.hour(), gps.time.minute(), gps.time.second(),

// gps.speed.knots(), gps.satellites.value(), (unsigned long)MsecSinceTooSlow, (unsigned long)MsecSinceLastGPSData,

// Serial1.available(), digitalRead(DASHCAM_POWER_SWITCH_PIN) == HIGH ? "ON" : "OFF");

// Serial.printf("In UpdatePowerSwitchState(). Speed = %2.1f, Sats = %d\n", gps.speed.mph(), gps.satellites.value());

//DEBUG:

if (((int)MsecSinceLastGPSData /1000) > MAX_SEC_WITHOUT_GPS_DATA && digitalRead(DASHCAM_POWER_SWITCH_PIN) == HIGH)

{

//DEBUG:

Serial.printf("Powering OFF at %02d:%02d:%02d\n", gps.time.hour(), gps.time.minute(), gps.time.second());

//DEBUG:

EnableDashCamPower(false);//turn dashcam power OFF

return;

}

if ((gps.speed.mph() < (double)MIN_SPEED_THRESHOLD_MPH || (gps.satellites.value() < MIN_NUM_SATELLITES_THRESHOLD))

&& ((int)MsecSinceTooSlow / 1000) > MAX_TOO_SLOW_TIME_THRESHOLD_SEC && digitalRead(DASHCAM_POWER_SWITCH_PIN) == HIGH)

{

//DEBUG:

Serial.printf("Powering OFF at %02d:%02d:%02d\n", gps.time.hour(), gps.time.minute(), gps.time.second());

//DEBUG:

EnableDashCamPower(false);//turn dashcam power OFF

return;

}

if (gps.speed.mph() >= (double)MIN_SPEED_THRESHOLD_MPH && gps.satellites.value() >= MIN_NUM_SATELLITES_THRESHOLD)

{

MsecSinceTooSlow = 0;

MsecSinceLastGPSData = 0;

//Serial.printf("DashCam Power Switch state = %d\n", digitalRead(DASHCAM_POWER_SWITCH_PIN));

if (digitalRead(DASHCAM_POWER_SWITCH_PIN) == LOW)

{

//DEBUG:

Serial.printf("Powering ON at %02d:%02d:%02d\n", gps.time.hour(), gps.time.minute(), gps.time.second());

//DEBUG:

EnableDashCamPower(true);//turn dashcam power ON

return;

}

void EnableDashCamPower(bool enable)

{

digitalWrite(DASHCAM_POWER_SWITCH_PIN, enable);

}

// Helper function to set RGB states

void setLEDColor(int redState, int greenState, int blueState) {

digitalWrite(PIN_LED_R, redState);

digitalWrite(PIN_LED_G, greenState);

digitalWrite(PIN_LED_B, blueState);

}

Here is a short video of the CYD display and power switch during a driving test in my local development loop. At the start of the video, the GPS module has already detected 8 sats (hard to see), so as soon as the computed speed goes over 5mph, the power switch changes from OFF to ON (red LED on the power switch and ‘ON’ on the CYD.

Unfortunately it was at this point that I discovered that the BUZ76A MOSFET power switch had too high of an Rds (around 4Ω) to actually turn on the camera -bummer!

Some discussion with Grok netted me a low-Rds MOSFET – the AOD424G AOD424 TO252 with Rds in the milli-Ohms. This has a pretty low Vds(max) of around 20V, but this is fine for my needs as it will only be switching 5V. Here’s the new schematic:

01 December 2025 Update:

As things are coming together on the electronics side, I took some time to investigate mounting options in my truck. After fiddling around a bit, I came up with the following possibility:

This would actually work out great, as the PETG plastic boxes wouldn’t be directly exposed to sunlight, and, the display would still be very visible to the driver, and it wouldn’t block vision to my time and temperature display at the top of the radio stack. As a huge bonus, it turns out there is enough slack in the USB power cable to the dash camera that I could plug it directly into the switch box (green in the photo above, if I changed out one of the USB type-C chassis connectors for a USB2/3 type. $7 for 5 connectors from Amazon – delivery in less than a week – yay!

Of course this means I need to change the box design, but that won’t take long.

08 December 2025 Update:

I got my new USB2 connector, and redesigned the box & lid to accommodate it, creating a conundrum in the process.

When I started wiring everything in, I realized I had created a big problem. If I ever wanted to remove the proto-board from the enclosure, I would have to unsolder all the wires to the USB connectors first – UGH!! I thought I could solve this problem by adding connectors in the lines to the USB connectors, but I hated that idea as it just adds complexity (“a connector is a source of trouble between two other sources of trouble”), so I put the whole thing aside to await a better solution. This morning while exercising it came to me – redesign the enclosure so the parting line between box and lid is right at the top edge of the connector modules. Then the proto-board and connectors can be lifted right out after removing the two proto-board mounting screws – genius! Only one small ‘gotcha’ the USB-C connectors will have to be flipped 180𝆩 so the PCB slot is on top rather than on the bottom. Since USB-C connectors are orientation insensitive anyway, this shouldn’t be an issue. Here’s a screenshot of the ‘final’ (as final as anything gets in my world) enclosure, with the connector cutouts moved to the top so removing the lid will allow the PCB – with the connectors still attached – to be lifted out.

Here are some photos of the ‘finished’ product:

After installing it in my truck, I made a couple of test runs around my little development’s circle, and it seems to be working great. Here are some photos showing the installation in my truck:

Here is the ‘finished’ version of the firmware:

/*
    Name:       GrokGTU7_GPStoCYD.ino
    Created:	11/24/2025 4:25:32 PM
    Author:     FRANK_XPS_9530\Frank
*/


#include <HardwareSerial.h>
#include <TinyGPSplus.h>
#include <TFT_eSPI.h>  // Or include <lvgl.h> if using LVGL
#include <ElapsedMillis.h>


#define GPS_RX_PIN 27  // CYD GPIO27 as RX (from GT-U7 TX)
#define GPS_TX_PIN 22  // CYD GPIO22 as TX (to GT-U7 RX)
#define DASHCAM_POWER_SWITCH_PIN 21 //See https://github.com/hexeguitar/ESP32_TFT_PIO?tab=readme-ov-file#adding-psram
#define POWER_SWITCH_TRIGGER_PIN 35 //directly manipulate POWER_SWITCH_PIN state for debug
#define GPS_BAUD 9600

#define MAX_SEC_WITHOUT_GPS_DATA 600 //10 min
#define MIN_SPEED_THRESHOLD_MPH 10 //10 mph
#define MAX_TOO_SLOW_TIME_THRESHOLD_SEC 300 //5 min
#define MIN_NUM_SATELLITES_THRESHOLD 4 //4 satellites

//onboard RGB LED
#define PIN_LED_R 4   // Red - use for power OFF
#define PIN_LED_G 16  // Green - use for power ON
#define PIN_LED_B 17  // Blue  - unused


HardwareSerial gpsSerial(2);  // Use UART2
TinyGPSPlus gps;
TFT_eSPI tft = TFT_eSPI();  // For basic display

const int labelX = 10;      // X position for labels
const int valueX = 160;     // X position for values (after label and "=")
//const int startY = 10;      // Starting Y for first line
const int startY = 110;      // Starting Y for first line 12/10/25 moved down to avoid gearshift stalk
const int lineHeight = 20;  // Spacing between lines (text size 2 needs ~16-20px)
const int valueWidth = 150; // Width of value area to clear (estimate based on max chars)
const int valueHeight = lineHeight;

elapsedMillis MsecSinceTooSlow;
elapsedMillis MsecSinceLastGPSData;

int SecSinceTooSlow = 0;
int SecSinceGPSData = 0;
bool SwitchState = false; //power switch defaults to OFF

void setup() 
{
  Serial.begin(115200);  // For debugging
  gpsSerial.begin(GPS_BAUD, SERIAL_8N1, GPS_RX_PIN, GPS_TX_PIN);
  pinMode(DASHCAM_POWER_SWITCH_PIN, OUTPUT);
  pinMode(POWER_SWITCH_TRIGGER_PIN, INPUT_PULLDOWN);
  pinMode(PIN_LED_R, OUTPUT);
  pinMode(PIN_LED_G, OUTPUT);
  pinMode(PIN_LED_B, OUTPUT);

  tft.init();
  tft.setRotation(3);  // Landscape
  tft.invertDisplay(1);  // Fix color inversion
  tft.fillScreen(TFT_BLACK);
  tft.setTextColor(TFT_WHITE);
  tft.setTextSize(2);

  // Draw static labels and "=" once
  tft.setCursor(labelX, startY);
  tft.print("Time = ");
  tft.setCursor(labelX, startY +lineHeight);
  tft.print("Sats = ");
  tft.setCursor(labelX, startY + 2 * lineHeight);
  tft.print("Speed = ");
  tft.setCursor(labelX, startY + 3 * lineHeight);
  tft.print("SSTooSlow = ");
  tft.setCursor(labelX, startY + 4 * lineHeight);
  tft.print("SSGPSD = ");
  //tft.setCursor(labelX, startY + 5 * lineHeight);
  //tft.print("Avail = ");
  //tft.setCursor(labelX, startY + 6 * lineHeight);
  //tft.print("Power = ");
  tft.setCursor(labelX, startY + 5 * lineHeight);
  tft.print("Power = ");

  // Initial values (optional; could be blanks or "N/A")
  //updateValues(0, 0, 0, 0, 0.0, 0, 0, 0, 0);
  EnableDashCamPower(false); //12/10/25 moved above updateValues() to display setup() value
  updateValues(); //12/10/25 now all value extraction done internally

//DEBUG!!
  //digitalWrite(DASHCAM_POWER_SWITCH_PIN, LOW);
  //Serial.printf("POWER_SWITCH_PIN State = %d", digitalRead(DASHCAM_POWER_SWITCH_PIN));
//DEBUG!!
}

void loop() 
{
  setLEDColor(LOW, HIGH, HIGH);  // Red ON no GPS data available
  //Serial.printf("In outer loop - LED should be RED\n");

  while (gpsSerial.available() > 0) 
  {
    if (gps.encode(gpsSerial.read())) 
    {
      if (gps.location.isValid()) 
      {
        //Serial.printf("In 'valid' branch - LED should be GREEN\n");
        setLEDColor(HIGH, LOW, HIGH);  // Green ON - valie GPS data available

        //updateValues(gps.time.hour(), gps.time.minute(), gps.time.second(),
        //  gps.satellites.value(), gps.speed.mph(), SecSinceTooSlow, SecSinceGPSData,
        //  Serial1.available(), SwitchState);
        updateValues(); //12/10/25 now all value extraction done internally

        delay(1000);
      }
      else 
      {
        setLEDColor(HIGH, HIGH, LOW);  //BLUE - GPS data available, but no lock
        //Serial.printf("In 'else' branch - LED should be BLUE\n");
      }
    }

    UpdatePowerSwitchState();
  }

  delay(1000);  // Update every second
}

//void updateValues(int hour, int min, int sec, int sats, float speed, int SecSinceTooSlow,
//                  int SecSinceValidGPSData, int AvailChars, int SwitchState  ) 
//{
//  tft.setTextColor(TFT_WHITE, TFT_BLACK);
//
//  // Update Time
//  tft.fillRect(valueX, startY, valueWidth, valueHeight, TFT_BLACK);  // Clear value area
//  tft.setCursor(valueX, startY);
//  tft.printf("%d:%d:%d", hour, min, sec);
//
//  // Update Satellites
//  tft.fillRect(valueX, startY + lineHeight, valueWidth, valueHeight, TFT_BLACK);  // Clear value area
//  tft.setCursor(valueX, startY + lineHeight);
//  tft.printf("%d", sats);
//
//  // Update Speed
//  tft.fillRect(valueX, startY + 2*lineHeight, valueWidth, valueHeight, TFT_BLACK);
//  tft.setCursor(valueX, startY + 2* lineHeight);
//  tft.printf("%.1f mph", speed);
//
//  // Update SSTL (Since Speed Too Low)
//  tft.fillRect(valueX, startY + 3 * lineHeight, valueWidth, valueHeight, TFT_BLACK);  // Clear value area
//  tft.setCursor(valueX, startY + 3 * lineHeight);
//  tft.printf("%d Sec", (int)(MsecSinceTooSlow/1000));
//
//  // Update SSGPSD (Seconds Since GPS Data)
//  tft.fillRect(valueX, startY + 4 * lineHeight, valueWidth, valueHeight, TFT_BLACK);  // Clear value area
//  tft.setCursor(valueX, startY + 4 * lineHeight);
//  tft.printf("%d Sec", (int)(MsecSinceLastGPSData / 1000));
//
//  // Update Characters Remaining
//  //tft.fillRect(valueX, startY + 5 * lineHeight, valueWidth, valueHeight, TFT_BLACK);
//  //tft.setCursor(valueX, startY + 5 * lineHeight);
//  //tft.printf("%d char", Serial1.available());
//
//  // Update Power Switch State
//  //tft.fillRect(valueX, startY + 6 * lineHeight, valueWidth, valueHeight, TFT_BLACK);
//  //tft.setCursor(valueX, startY + 6 * lineHeight);
//  tft.fillRect(valueX, startY + 5 * lineHeight, valueWidth, valueHeight, TFT_BLACK);
//  tft.setCursor(valueX, startY + 5 * lineHeight);
//
//  //int trigger_state = digitalRead(POWER_SWITCH_TRIGGER_PIN);
//  String statestr = digitalRead(DASHCAM_POWER_SWITCH_PIN) == HIGH ? "ON" : "OFF";
//  tft.printf("%s", statestr);
//}

//12/10/25 now all value extraction done internally
void updateValues()
{
  tft.setTextColor(TFT_WHITE, TFT_BLACK);

  // Update Time
  tft.fillRect(valueX, startY, valueWidth, valueHeight, TFT_BLACK);  // Clear value area
  tft.setCursor(valueX, startY);
  tft.printf("%d:%d:%d", gps.time.hour(), gps.time.minute(), gps.time.second());

  // Update Satellites
  tft.fillRect(valueX, startY + lineHeight, valueWidth, valueHeight, TFT_BLACK);  // Clear value area
  tft.setCursor(valueX, startY + lineHeight);
  tft.printf("%d", gps.satellites.value());

  // Update Speed
  tft.fillRect(valueX, startY + 2 * lineHeight, valueWidth, valueHeight, TFT_BLACK);
  tft.setCursor(valueX, startY + 2 * lineHeight);
  tft.printf("%.1f mph", gps.speed.mph());

  // Update SSTL (Since Speed Too Low)
  tft.fillRect(valueX, startY + 3 * lineHeight, valueWidth, valueHeight, TFT_BLACK);  // Clear value area
  tft.setCursor(valueX, startY + 3 * lineHeight);
  tft.printf("%d Sec", (int)(MsecSinceTooSlow / 1000));

  // Update SSGPSD (Seconds Since GPS Data)
  tft.fillRect(valueX, startY + 4 * lineHeight, valueWidth, valueHeight, TFT_BLACK);  // Clear value area
  tft.setCursor(valueX, startY + 4 * lineHeight);
  tft.printf("%d Sec", (int)(MsecSinceLastGPSData / 1000));

  // Update Characters Remaining
  //tft.fillRect(valueX, startY + 5 * lineHeight, valueWidth, valueHeight, TFT_BLACK);
  //tft.setCursor(valueX, startY + 5 * lineHeight);
  //tft.printf("%d char", Serial1.available());

  // Update Power Switch State
  //tft.fillRect(valueX, startY + 6 * lineHeight, valueWidth, valueHeight, TFT_BLACK);
  //tft.setCursor(valueX, startY + 6 * lineHeight);
  tft.fillRect(valueX, startY + 5 * lineHeight, valueWidth, valueHeight, TFT_BLACK);
  tft.setCursor(valueX, startY + 5 * lineHeight);

  //int trigger_state = digitalRead(POWER_SWITCH_TRIGGER_PIN);
  String statestr = digitalRead(DASHCAM_POWER_SWITCH_PIN) == HIGH ? "ON" : "OFF";
  Serial.printf("In UpdateValues(), DASHCAM_POWER_SWITCH_PIN = %d, statestr = %s\n", 
    digitalRead(DASHCAM_POWER_SWITCH_PIN), statestr);
 tft.printf("%s", statestr);
}


void UpdatePowerSwitchState()
{
  //Serial.printf("In UpdatePowerSwitchState()\n");
  //Purpose: Update power switch state 
  //Inputs: 
  // MsecSinceTooSlow = Unsigned Long indicating Msec since speed fell below threshold
  // MsecSinceLastData = Unsigned Long indicating Msec since last GPS data 
  // gps object methods/properties
  //Outputs:
  // Power OFF if GPS data has been missing for more than MAX_SEC_WITHOUT_GPS_DATA
  // Power OFF if [speed < MIN_SPEED_THRESHOLD_MPH OR numsats <=0] AND elapsed time under speed threshold is > MAX_TOO_SLOW_TIME_THRESHOLD_SEC
  //         Otherwise Power ON.
  //Procedure:
  //  Step1: If speed from GPS > threshold, reset MsecSinceTooSlow to zero and Set power to ON
  //  Step2: If (speed < threshold OR numsats < threshold) AND MsecSinceTooSlow > Set power to OFF

//DEBUG:
  //Serial.printf(UpdateTelemStr, gps.time.hour(), gps.time.minute(), gps.time.second(),
  //  gps.speed.knots(), gps.satellites.value(), (unsigned long)MsecSinceTooSlow, (unsigned long)MsecSinceLastGPSData,
  //  Serial1.available(), digitalRead(DASHCAM_POWER_SWITCH_PIN) == HIGH ? "ON" : "OFF");
  //  Serial.printf("In UpdatePowerSwitchState().  Speed = %2.1f, Sats = %d\n", gps.speed.mph(), gps.satellites.value());
//DEBUG:

  if (((int)MsecSinceLastGPSData /1000) > MAX_SEC_WITHOUT_GPS_DATA && digitalRead(DASHCAM_POWER_SWITCH_PIN) == HIGH)
  {
//DEBUG:
    Serial.printf("Powering OFF at %02d:%02d:%02d\n", gps.time.hour(), gps.time.minute(), gps.time.second());
//DEBUG:

    EnableDashCamPower(false);//turn dashcam power OFF
    return;
  }

  if ((gps.speed.mph() < (double)MIN_SPEED_THRESHOLD_MPH || (gps.satellites.value() < MIN_NUM_SATELLITES_THRESHOLD))
    && ((int)MsecSinceTooSlow / 1000) > MAX_TOO_SLOW_TIME_THRESHOLD_SEC && digitalRead(DASHCAM_POWER_SWITCH_PIN) == HIGH)
  {
//DEBUG:
    Serial.printf("Powering OFF at %02d:%02d:%02d\n", gps.time.hour(), gps.time.minute(), gps.time.second());
//DEBUG:

    EnableDashCamPower(false);//turn dashcam power OFF
    return;
  }

  if (gps.speed.mph() >= (double)MIN_SPEED_THRESHOLD_MPH && gps.satellites.value() >= MIN_NUM_SATELLITES_THRESHOLD)
  {
    MsecSinceTooSlow = 0;
    MsecSinceLastGPSData = 0;

    //Serial.printf("DashCam Power Switch state = %d\n", digitalRead(DASHCAM_POWER_SWITCH_PIN));

    if (digitalRead(DASHCAM_POWER_SWITCH_PIN) == LOW)
    {
//DEBUG:
      Serial.printf("Powering ON at %02d:%02d:%02d\n", gps.time.hour(), gps.time.minute(), gps.time.second());
//DEBUG:

      EnableDashCamPower(true);//turn dashcam power ON
      return;
    }
  }
}

void EnableDashCamPower(bool enable)
{
  digitalWrite(DASHCAM_POWER_SWITCH_PIN, enable);
  Serial.printf("DASHCAM_POWER_SWITCH_PIN = %d\n", digitalRead(DASHCAM_POWER_SWITCH_PIN));
}

// Helper function to set RGB states
void setLEDColor(int redState, int greenState, int blueState) {
  digitalWrite(PIN_LED_R, redState);
  digitalWrite(PIN_LED_G, greenState);
  digitalWrite(PIN_LED_B, blueState);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

Name: GrokGTU7_GPStoCYD.ino

Created: 11/24/2025 4:25:32 PM

Author: FRANK_XPS_9530\Frank

#include <HardwareSerial.h>

#include <TinyGPSplus.h>

#include <TFT_eSPI.h> // Or include <lvgl.h> if using LVGL

#include <ElapsedMillis.h>

#define GPS_RX_PIN 27 // CYD GPIO27 as RX (from GT-U7 TX)

#define GPS_TX_PIN 22 // CYD GPIO22 as TX (to GT-U7 RX)

#define DASHCAM_POWER_SWITCH_PIN 21 //See https://github.com/hexeguitar/ESP32_TFT_PIO?tab=readme-ov-file#adding-psram

#define POWER_SWITCH_TRIGGER_PIN 35 //directly manipulate POWER_SWITCH_PIN state for debug

#define GPS_BAUD 9600

#define MAX_SEC_WITHOUT_GPS_DATA 600 //10 min

#define MIN_SPEED_THRESHOLD_MPH 10 //10 mph

#define MAX_TOO_SLOW_TIME_THRESHOLD_SEC 300 //5 min

#define MIN_NUM_SATELLITES_THRESHOLD 4 //4 satellites

//onboard RGB LED

#define PIN_LED_R 4 // Red - use for power OFF

#define PIN_LED_G 16 // Green - use for power ON

#define PIN_LED_B 17 // Blue - unused

HardwareSerial gpsSerial(2); // Use UART2

TinyGPSPlus gps;

TFT_eSPI tft = TFT_eSPI(); // For basic display

const int labelX = 10; // X position for labels

const int valueX = 160; // X position for values (after label and "=")

//const int startY = 10; // Starting Y for first line

const int startY = 110; // Starting Y for first line 12/10/25 moved down to avoid gearshift stalk

const int lineHeight = 20; // Spacing between lines (text size 2 needs ~16-20px)

const int valueWidth = 150; // Width of value area to clear (estimate based on max chars)

const int valueHeight = lineHeight;

elapsedMillis MsecSinceTooSlow;

elapsedMillis MsecSinceLastGPSData;

int SecSinceTooSlow = 0;

int SecSinceGPSData = 0;

bool SwitchState = false; //power switch defaults to OFF

void setup()

{

Serial.begin(115200); // For debugging

gpsSerial.begin(GPS_BAUD, SERIAL_8N1, GPS_RX_PIN, GPS_TX_PIN);

pinMode(DASHCAM_POWER_SWITCH_PIN, OUTPUT);

pinMode(POWER_SWITCH_TRIGGER_PIN, INPUT_PULLDOWN);

pinMode(PIN_LED_R, OUTPUT);

pinMode(PIN_LED_G, OUTPUT);

pinMode(PIN_LED_B, OUTPUT);

tft.init();

tft.setRotation(3); // Landscape

tft.invertDisplay(1); // Fix color inversion

tft.fillScreen(TFT_BLACK);

tft.setTextColor(TFT_WHITE);

tft.setTextSize(2);

// Draw static labels and "=" once

tft.setCursor(labelX, startY);

tft.print("Time = ");

tft.setCursor(labelX, startY +lineHeight);

tft.print("Sats = ");

tft.setCursor(labelX, startY + 2 * lineHeight);

tft.print("Speed = ");

tft.setCursor(labelX, startY + 3 * lineHeight);

tft.print("SSTooSlow = ");

tft.setCursor(labelX, startY + 4 * lineHeight);

tft.print("SSGPSD = ");

//tft.setCursor(labelX, startY + 5 * lineHeight);

//tft.print("Avail = ");

//tft.setCursor(labelX, startY + 6 * lineHeight);

//tft.print("Power = ");

tft.setCursor(labelX, startY + 5 * lineHeight);

tft.print("Power = ");

// Initial values (optional; could be blanks or "N/A")

//updateValues(0, 0, 0, 0, 0.0, 0, 0, 0, 0);

EnableDashCamPower(false); //12/10/25 moved above updateValues() to display setup() value

updateValues(); //12/10/25 now all value extraction done internally

//DEBUG!!

//digitalWrite(DASHCAM_POWER_SWITCH_PIN, LOW);

//Serial.printf("POWER_SWITCH_PIN State = %d", digitalRead(DASHCAM_POWER_SWITCH_PIN));

//DEBUG!!

}

void loop()

{

setLEDColor(LOW, HIGH, HIGH); // Red ON no GPS data available

//Serial.printf("In outer loop - LED should be RED\n");

while (gpsSerial.available() > 0)

{

if (gps.encode(gpsSerial.read()))

{

if (gps.location.isValid())

{

//Serial.printf("In 'valid' branch - LED should be GREEN\n");

setLEDColor(HIGH, LOW, HIGH); // Green ON - valie GPS data available

//updateValues(gps.time.hour(), gps.time.minute(), gps.time.second(),

// gps.satellites.value(), gps.speed.mph(), SecSinceTooSlow, SecSinceGPSData,

// Serial1.available(), SwitchState);

updateValues(); //12/10/25 now all value extraction done internally

delay(1000);

}

else

{

setLEDColor(HIGH, HIGH, LOW); //BLUE - GPS data available, but no lock

//Serial.printf("In 'else' branch - LED should be BLUE\n");

}

UpdatePowerSwitchState();

}

delay(1000); // Update every second

}

//void updateValues(int hour, int min, int sec, int sats, float speed, int SecSinceTooSlow,

// int SecSinceValidGPSData, int AvailChars, int SwitchState )

//{

// tft.setTextColor(TFT_WHITE, TFT_BLACK);

// // Update Time

// tft.fillRect(valueX, startY, valueWidth, valueHeight, TFT_BLACK); // Clear value area

// tft.setCursor(valueX, startY);

// tft.printf("%d:%d:%d", hour, min, sec);

// // Update Satellites

// tft.fillRect(valueX, startY + lineHeight, valueWidth, valueHeight, TFT_BLACK); // Clear value area

// tft.setCursor(valueX, startY + lineHeight);

// tft.printf("%d", sats);

// // Update Speed

// tft.fillRect(valueX, startY + 2*lineHeight, valueWidth, valueHeight, TFT_BLACK);

// tft.setCursor(valueX, startY + 2* lineHeight);

// tft.printf("%.1f mph", speed);

// // Update SSTL (Since Speed Too Low)

// tft.fillRect(valueX, startY + 3 * lineHeight, valueWidth, valueHeight, TFT_BLACK); // Clear value area

// tft.setCursor(valueX, startY + 3 * lineHeight);

// tft.printf("%d Sec", (int)(MsecSinceTooSlow/1000));

// // Update SSGPSD (Seconds Since GPS Data)

// tft.fillRect(valueX, startY + 4 * lineHeight, valueWidth, valueHeight, TFT_BLACK); // Clear value area

// tft.setCursor(valueX, startY + 4 * lineHeight);

// tft.printf("%d Sec", (int)(MsecSinceLastGPSData / 1000));

// // Update Characters Remaining

// //tft.fillRect(valueX, startY + 5 * lineHeight, valueWidth, valueHeight, TFT_BLACK);

// //tft.setCursor(valueX, startY + 5 * lineHeight);

// //tft.printf("%d char", Serial1.available());

// // Update Power Switch State

// //tft.fillRect(valueX, startY + 6 * lineHeight, valueWidth, valueHeight, TFT_BLACK);

// //tft.setCursor(valueX, startY + 6 * lineHeight);

// tft.fillRect(valueX, startY + 5 * lineHeight, valueWidth, valueHeight, TFT_BLACK);

// tft.setCursor(valueX, startY + 5 * lineHeight);

// //int trigger_state = digitalRead(POWER_SWITCH_TRIGGER_PIN);

// String statestr = digitalRead(DASHCAM_POWER_SWITCH_PIN) == HIGH ? "ON" : "OFF";

// tft.printf("%s", statestr);

//}

//12/10/25 now all value extraction done internally

void updateValues()

{

tft.setTextColor(TFT_WHITE, TFT_BLACK);

// Update Time

tft.fillRect(valueX, startY, valueWidth, valueHeight, TFT_BLACK); // Clear value area

tft.setCursor(valueX, startY);

tft.printf("%d:%d:%d", gps.time.hour(), gps.time.minute(), gps.time.second());

// Update Satellites

tft.fillRect(valueX, startY + lineHeight, valueWidth, valueHeight, TFT_BLACK); // Clear value area

tft.setCursor(valueX, startY + lineHeight);

tft.printf("%d", gps.satellites.value());

// Update Speed

tft.fillRect(valueX, startY + 2 * lineHeight, valueWidth, valueHeight, TFT_BLACK);

tft.setCursor(valueX, startY + 2 * lineHeight);

tft.printf("%.1f mph", gps.speed.mph());

// Update SSTL (Since Speed Too Low)

tft.fillRect(valueX, startY + 3 * lineHeight, valueWidth, valueHeight, TFT_BLACK); // Clear value area

tft.setCursor(valueX, startY + 3 * lineHeight);

tft.printf("%d Sec", (int)(MsecSinceTooSlow / 1000));

// Update SSGPSD (Seconds Since GPS Data)

tft.fillRect(valueX, startY + 4 * lineHeight, valueWidth, valueHeight, TFT_BLACK); // Clear value area

tft.setCursor(valueX, startY + 4 * lineHeight);

tft.printf("%d Sec", (int)(MsecSinceLastGPSData / 1000));

// Update Characters Remaining

//tft.fillRect(valueX, startY + 5 * lineHeight, valueWidth, valueHeight, TFT_BLACK);

//tft.setCursor(valueX, startY + 5 * lineHeight);

//tft.printf("%d char", Serial1.available());

// Update Power Switch State

//tft.fillRect(valueX, startY + 6 * lineHeight, valueWidth, valueHeight, TFT_BLACK);

//tft.setCursor(valueX, startY + 6 * lineHeight);

tft.fillRect(valueX, startY + 5 * lineHeight, valueWidth, valueHeight, TFT_BLACK);

tft.setCursor(valueX, startY + 5 * lineHeight);

//int trigger_state = digitalRead(POWER_SWITCH_TRIGGER_PIN);

String statestr = digitalRead(DASHCAM_POWER_SWITCH_PIN) == HIGH ? "ON" : "OFF";

Serial.printf("In UpdateValues(), DASHCAM_POWER_SWITCH_PIN = %d, statestr = %s\n",

digitalRead(DASHCAM_POWER_SWITCH_PIN), statestr);

tft.printf("%s", statestr);

}

void UpdatePowerSwitchState()

{

//Serial.printf("In UpdatePowerSwitchState()\n");

//Purpose: Update power switch state

//Inputs:

// MsecSinceTooSlow = Unsigned Long indicating Msec since speed fell below threshold

// MsecSinceLastData = Unsigned Long indicating Msec since last GPS data

// gps object methods/properties

//Outputs:

// Power OFF if GPS data has been missing for more than MAX_SEC_WITHOUT_GPS_DATA

// Power OFF if [speed < MIN_SPEED_THRESHOLD_MPH OR numsats <=0] AND elapsed time under speed threshold is > MAX_TOO_SLOW_TIME_THRESHOLD_SEC

// Otherwise Power ON.

//Procedure:

// Step1: If speed from GPS > threshold, reset MsecSinceTooSlow to zero and Set power to ON

// Step2: If (speed < threshold OR numsats < threshold) AND MsecSinceTooSlow > Set power to OFF

//DEBUG:

//Serial.printf(UpdateTelemStr, gps.time.hour(), gps.time.minute(), gps.time.second(),

// gps.speed.knots(), gps.satellites.value(), (unsigned long)MsecSinceTooSlow, (unsigned long)MsecSinceLastGPSData,

// Serial1.available(), digitalRead(DASHCAM_POWER_SWITCH_PIN) == HIGH ? "ON" : "OFF");

// Serial.printf("In UpdatePowerSwitchState(). Speed = %2.1f, Sats = %d\n", gps.speed.mph(), gps.satellites.value());

//DEBUG:

if (((int)MsecSinceLastGPSData /1000) > MAX_SEC_WITHOUT_GPS_DATA && digitalRead(DASHCAM_POWER_SWITCH_PIN) == HIGH)

{

//DEBUG:

Serial.printf("Powering OFF at %02d:%02d:%02d\n", gps.time.hour(), gps.time.minute(), gps.time.second());

//DEBUG:

EnableDashCamPower(false);//turn dashcam power OFF

return;

}

if ((gps.speed.mph() < (double)MIN_SPEED_THRESHOLD_MPH || (gps.satellites.value() < MIN_NUM_SATELLITES_THRESHOLD))

&& ((int)MsecSinceTooSlow / 1000) > MAX_TOO_SLOW_TIME_THRESHOLD_SEC && digitalRead(DASHCAM_POWER_SWITCH_PIN) == HIGH)

{

//DEBUG:

Serial.printf("Powering OFF at %02d:%02d:%02d\n", gps.time.hour(), gps.time.minute(), gps.time.second());

//DEBUG:

EnableDashCamPower(false);//turn dashcam power OFF

return;

}

if (gps.speed.mph() >= (double)MIN_SPEED_THRESHOLD_MPH && gps.satellites.value() >= MIN_NUM_SATELLITES_THRESHOLD)

{

MsecSinceTooSlow = 0;

MsecSinceLastGPSData = 0;

//Serial.printf("DashCam Power Switch state = %d\n", digitalRead(DASHCAM_POWER_SWITCH_PIN));

if (digitalRead(DASHCAM_POWER_SWITCH_PIN) == LOW)

{

//DEBUG:

Serial.printf("Powering ON at %02d:%02d:%02d\n", gps.time.hour(), gps.time.minute(), gps.time.second());

//DEBUG:

EnableDashCamPower(true);//turn dashcam power ON

return;

}

void EnableDashCamPower(bool enable)

{

digitalWrite(DASHCAM_POWER_SWITCH_PIN, enable);

Serial.printf("DASHCAM_POWER_SWITCH_PIN = %d\n", digitalRead(DASHCAM_POWER_SWITCH_PIN));

}

// Helper function to set RGB states

void setLEDColor(int redState, int greenState, int blueState) {

digitalWrite(PIN_LED_R, redState);

digitalWrite(PIN_LED_G, greenState);

digitalWrite(PIN_LED_B, blueState);

}

15 December 2025 Update:

Now that things seem to be working, I’m trying to clean up the installation a bit. Here are some photos showing some of the current temporary installation details:

Overall installation layout, from power source to GPS antenna

I also took the opportunity to measure the current load with the display and switch box electronics powered, but with the dashcam OFF. This is important, as this load determines how long the battery will last in this configuration. I used my handy-dandy USB2 ‘Charger Doctor’ pass-through device that alternately displays output voltage and current. As shown in the following photo, the ‘OFF’ current draw is about 0.19A.

Showing current draw in the ‘dashcam OFF’ configuration. The meter shows 0.19A (190 mA).

The 12V car battery in this truck is a ‘DieHard’ AGM Technology battery as shown below:

So I asked Grok how long this battery would last with the dashcam OFF, but the display (and it’s imbedded MCU) still powered up with a 0.2A draw, and this is what I got back:

251215 Grok Re DieHard Battery Download

So almost a month – that sounds about right, and it means I wouldn’t have had a dead battery at 2 am when my wife and I got home from last summer after a week at the 2025 Senior Games in Des Moines, Iowa!

Just as a sidenote, I have a ‘premium’ subscription to X not because I think X posts are worthwhile, but because Grok *IS* worthwhile. As a long-time electrical engineer, I was familiar with the property of lead-acid batteries that extended the discharge time under very small loads compared to the normal A-Hr rating, but I had never heard of the ‘Peukert effect’, which allows for a much better estimate of discharge times for low loads. This took Grok about 30 seconds – what a *great* engineering assistant!

And, speaking of Grok, I also asked him (it?) for the name and purpose of the ‘cubbyhole’ I’m using as the mounting cavity for the dashcam switch project. Turns out this was probably originally intended for an ashtray, and then repurposed as the mounting cavity for a trailer brake module. And, he also came up with dimensions, which should allow me to design a cradle that will fit snugly in the hole and keep the dashcam electronics from sliding around. We’ll see!

17 December 2025 Update:

A couple of interesting things happened in the last two days. The first thing is I have been cursing at the maker of the SuperONE cigar-lighter automobile power adapter for providing a USB-C retractable cable that doesn’t deliver +5V to power my dashcam switch module.

Because of this, I gave the product a ‘1’ review and described my methodology in determining that the retractable USB-C cable just wasn’t providing +5V. This got the company’s attention, and they offered to send me a new one, free of charge. I said, ‘OK’ but if the new one doesn’t work either, then my review will be edited to say that. Well, the new one arrived, and the same thing happened – no +5V to my project box. However, this time I was smart enough to try plugging the cable into my BT headset, and voila – it started charging the headset! Hmm… After some back and forth with Grok I learned that a ‘Power Delivery’ (PD) device doesn’t deliver power to a connection until it is asked to do so. The BT headset did, my cheap USB-C chassis receptacle didn’t – oops! So, I wound up editing my review from a 1 to a 5 and explained why; I suspect that will make the SuperONE folks a lot happier ;). Also, I ordered a different USB-C receptacle – one that has the smarts to request power from the USB-C cable.

The second thing that happened is I’m trying to figure out how to mount my dashcam power switch project into the ashtray/trailer brake ‘cubbyhole’ (see the photos above). And because I have not only one – but two 3D printers it naturally involves 3D printed parts. I designed and printed a shape that fits nicely into the cavity, and then I’ll need to figure out exactly how the combined assembly can be fastened into the cavity in a way that can be removed easily, if necessary, but also won’t just fall out at the slightest provocation.

1;8 December 2025:

After getting the enclosure issues resolved, I turned my attention to the GPS module, which is kind of hanging around on the shelf above the central audio panel. I’d like to build a small enclosure just to hide it away, leaving only the small GPS antenna itself and the even smaller RF cable leading down to the GPS module visible.

22 December 2025 Update:

I received and installed the new PD-enabled USB-C module, and it went in OK, with the usual curse-words and adaptations:

I printed up a small right-angle adaptor to mate the holes on the USB-C module with the holes on the box, but I had to mount the module on the inside wall – I decided not to make a new box just for this issue. So now The PD-enabled retractable cable on the cigar-lighter adaptor delivers 5V to the module and life is good!

Here’s the ‘final’ installation (nothing is every really ‘final’ in the Paynter world)

23 January 2026 Update:

I’ve been using the DashCam power switch for about a month now, and it seems to be working great. A couple of weeks ago I modifed the ‘Too Slow’ and ‘No Data’ readouts to change the unit from ‘sec’ to ‘min’ and ‘hours’ as appropriate; trying to figure out what ‘83520 sec’ meant was too hard for my brain, so I changed the code so this number would read ‘23.2 hours’

I also noticed that when I drive into my earth-sheltered garage, I get some strange status display readings. The number of sats will go to zero, but the clock time will often stay running (and stay accurate). Also, since the clock is active, the speed value will actually start to climb (divide by-almost-zero?) and so the speed criteria for keeping the power ON will be met. I think the way to handle this is to have a separate block in the logic for sats < min_satellites to force everything but the ‘Too Slow’ and ‘No Data’ timers to show “n/a”

26 January 2026 Update:

The dashcam switch is working well, but I’m not happy with the physical installation. I thought I had a great idea by putting it into the space originally designed for an ashtray, but it turns out not to be such a hot idea. The gear selector lever blocks out a significant amount of the display in ‘D’, and looking down at the display (and peering around the gear shifter lever) isn’t great. So, I decided to ‘re-imagine’ the entire installation.

The original installation features separate boxes for the display and the switch, which wastes a LOT of space. Starting from a clean sheet, I laid out the the switch circuitry and GPS module on a plug board, as shown in the following photo.

Required hardware for complete GPS-to-CYD implementation.

As shown above, the power input (USB-C), power output (USB2), switch (AOD424 MOSFET) and GT-U7 GPS modules easily fit into the footprint of the CYD display. I should be able to put everything into one box with the footprint of the CYD and sufficient depth to accommodate the switch & GPS hardware

However, the display area where I want to install the new version of the dash cam features a deeply recessed display area, and a complex profile. So, I needed to somehow model the profile so the box design would work. As the following photos show I used a combination of ‘cut & try’ for the first rough estimate, and then a contour gauge to get an estimate of the rest of the profile.

Then I used my 3D printer magic to print out successive profile estimates until I got reasonably close to the actual profile. This then can be used for the actual box design. The following photo shows the progression from left to right.

After getting the profile reasonably close, I printed a prototype box by extruding out the profile a few tens of millimeters, and got this result:

After a few more iterations I printed a full-size box:

Here’s a photo showing the old and new installations:

The above photo shows the old and new installations. The new installation will actually move to the left a bit as shown below, as it will incorporate the GPS module internally.

This will still hide the truck’s clock display, but since the new unit will also display time, that’s not a loss of functionality.

The next step was to disassemble the old installation to reuse the parts:

As can be seen from the above photo, there is quite a bit of wasted space in the power switch box, and I also figured out that one of the two USB-C chassis-mount connectors can also be removed, as the power connection from the power-switch circuit to the display will be routed internally – no need for a separate USB-C cable. I breadboarded the power switch circuit again, this time with compactness in mind, and wound up with this:

and then transferred the parts to a small piece of DIY circuit board. Then the whole thing fits nicely into the new enclosure, as shown in the following photos:

After more than a few hours of frustration due to the lack of a reliable GPS signal in the house, I think I finally got everything running properly, and tested it on my subdivision loop:

Here’s the updated schematic, with a missing ground wire added and with signal/control GPIO numbers added:

Stay tuned,

Frank

Adding a Second Toolhead to my Voron 2.4, Part II

08 November 2025 Update:

I now have tool changing working, and I was actually able to make a two-color print, as shown in the following short video and a photo of the 10mm two-color calibration cube.

Smooth toolchanges – who would have thought I would ever get this far!

My very first dual-color print on my Voron 2.4/MissChanger 3D Printer

Lots of work still to do. The above print isn’t very high quality, and the zero offset isn’t dialed in yet. In addition I noticed the toolhead logo/nozzle colors were off; the nozzle LEDs were a dark red during print instead of white – which made seeing print details very difficult. Either the STATUS_PRINTING nozzle color isn’t white like I thought, or PRINT_START isn’t changing to STATUS_PRINTING when needed.

I manually checked, and STATUS_PRINTING nozzle LEDs are full white – so that’s not the problem. Looking at PRINT_START I don’t see where the STATUS_xxx macros are used except at the end when STATUS_READY is called.

Side Note: When I started checking where (if anywhere) the stealthburner LED colors were being set at the beginning of a print, I found that they weren’t being set at all, which explains why I wasn’t seeing anything. Also in this process, I discovered that Vin’s MissChanger files contain their own, much more complex PRINT_START macro (among others). This macro is found in ‘misschanger_macros/print_time_default.cfg’, which is included at the very start of Vin’s example ‘printer.cfg’ file. I had blindly copied these include lines into my ‘printer.cfg’ file without ever realizing what was in them, as they didn’t seem to affect much. In particular I never realized there was another PRINT_START macro due to the way that Klipper parses includes – subsequent copies of any section or macro override any previous ones, so my PRINT_START macro always survived the process. I’m not going to worry about this right now – I’ll get to it when I get to it.

I went into PRINT_START and placed some STATUS_XXX macro calls and some STATUS_MSG debug prints, and will re-do the test print. I also took photos of each defined STATUS_XXX color sets so I can match what I’m seeing with a STATUS_XX call in PRINT_START. See below for the photos:

10 November 2025 Update:

Well, I’m not much smarter than I was yesterday regarding two-color prints, but I think I may have made some progress today. I couldn’t (and still can’t) figure out Vin’s instructions for setting up toolhead Z offsets for tools other than T0. Finally I remembered that Vin’s instructions had me add the following to printer.cfg in the SAVE_CONFIG section:

#*# [tool_probe T1]
#*# z_offset = -1.750000
#*#
#*# [extruder1]
#*#

#*# [tool_probe T1]

#*# z_offset = -1.750000

#*#

#*# [extruder1]

#*#

This led me to believe that I could probably just mount T1, tell Klipper to send the toolhead to Z-=0, and use the paper test to set the offset. As far as I can tell, this trick actually worked! So, now I am wondering what all the hooforah is for the Lube_Ball calibration tools and associated config files? Here’s a photo of my two-color calibration block, with no fine tuning done for either toolhead.

Two color print (T1 green, T0 white) with both z-offsets set manually, and no fine-tuning

In the above photo, it looks like the T1 z-offset of -1.750 is just a little too much, as the brim lines aren’t squeezed enough to connect to each other. I reduced the offset to -1.700 and ran the print again.

Reduced T1 z-offset from -1.750 to -1.700. Much nicer ‘squeeze on brim lines.

As the above photo shows, this offset produced a much nicer ‘squeeze’ on the brim lines. Now it remains to be seen if this method will hold up over time.

I decided to try Voxel3D_Nederland’s XYZ tuning print, shown here. It will be interesting to see if it confirms the z-offsets I have so far.

When I tried to print this job, I got an error message that said the extruder was too cool. Then I noticed that the T1 extruder temp was where it should be (240C), but the gcode was trying to print with T0 – oops. I hope this is actually a problem with the slicer, as my test prints with the two-color 10mm cal cube have worked correctly.

11 November 2025 Update:

I ran into yet another odd problem with the offsets. After getting the T1 z-offset nailed down I tried another print, and this on failed miserably, with the extruder starting out way too high. I ‘fine-tuned’ it back down again, but it took almost all (and then some) of the original -1.700mm offset back out again – which can’t be right. I re-ran PROBE_CALIBRATE on T1 and got close to the original -1.700mm, and when I tried the print again, it worked fine. However, when I tried to print the same job a second time without any changes, the same thing (extruder tip way too high) happened again. After thinking about this for a while, I began to think that the culprit was the ‘trigger_to_bottom = -1.896’ entry in the ‘[tools_calibrate]’ section of misschanger_settings.cfg. Maybe somehow this was being added to the T1 z-offset?

So, I set the ‘trigger_to_bottom’ value to zero and tried again, and saw that the 10mm two-color print was now consistently perfect. I am now in the process of making several prints in a row to verify that the z-offset is now consistently correct.

Not quite. I got a couple of prints where the extruder started out about 0.05mm too low. Not quite sure that’s all that bad, so I’m going to keep the offset at -1.700 for a few more prints.

I added 0.05mm to the z-offset to arrive at -1.750mm and restarted the firmware, and this time the extruder tip was too high by about 0.900mm – I have no idea why. The ‘trigger_to_bottom_z’ value in misschanger_settings.cfg is still zero. I restarted again and tried another print. This time the extruder tip was too high by about 0.6mm (could be the same as the 0.9 from before). Tried another print without accepting the 0.6 offset recommendation and without restarting. Same thing – extruder tip too high

Chose ‘apply offset’ Klipper restarted, and z_offset in [tool_probe T1 changed from -1.75 to -1.10mm. Did another print. Job went OK. Trying another print without changing anything. Good print.

Did a full Klipper reboot, selected test job without any other changes. This time the extruder tip was WAY too high; almost -2.0mm. At this point the printer.cfg tool_probe T1 offset is -1.10, so to get the extruder down another 1.9mm would put the extruder into positive territory – wow!.

Did a Home-All, then sent extruder to z=0; Had to RAISE the extruder by 0.60mm in order to get the proper ‘paper’ thickness. Did another PROBE_CALIBRATE; the result was _0.477. Accepted the result, and the T1 offset changed from -1.100 to … -1.100 – NO CHANGE! Did a save & restart from MainSail, and checked printer.cfg again. T1 offset is still -1.100 – unchanged. Did a HOME ALL, then checked extruder zero; had to raise the tip 0.5mm for a good ‘paper drag’.

Did another print without changing anything (T1 z_offset still at -1.1). Had to ‘fine-tune’ up 0.5mm, so this time I accepted the change. This time the T1 z_offset did not change with the restart – had to manually revise it – to -1.6000.

Did a ‘save & restart, HOME ALL, and sent extruder to z=0. This time I had to LOWER the extruder tip by 0.5mm for good paper drag. So I adjusted T1 z_offset by 0.5mm UP (minus), but this caused me to have to LOWER it by 0.5 after a HOME ALL.

Alright – there is certainly something rotten in Denmark. I changed to T0, sent the extruder to 150,200,0 and the paper check was fine – within 0.1mm. I did this because of this sentence in Vin’s instructions; “test the z-offset with the paper test. – If it is good then you set up the trigger_to_bottom_z value correctly. However, I had long since manually set the ‘trigger_to_bottom_z’ value to 0, so I really don’t undersdand how this works.

Next, I switched from T0 to T1, ran HOME ALL & QGL. Then tested offset by driving extruder to zero. This time it was pretty much spot-on – within 0.1mm. Tried another test print; good print.

Do ten test prints:

Print 1: OK.
Print 2: OK; a skosh low (brim was hard to scrape off, but not impossible)
Print 3: OK;
Print 4: Failed – extruder started out too high
Print 5: Failed – extruder started out too high
Print 6: Failed – extruder started out too high

I inspected the T1 mount on the carrier, and it seemed pretty tight. Also the screw-in extruder tip seemed secure, so those are probably not the culprit. At this point I noticed that starting when starting a print job, the printer skipped both the HOME ALL & QGL steps (not in PRINT_START?). Maybe that is what is causing the wandering z_offset?

Print 1: After HOME ALL & QGL. looks good – almost perfect first layer.
Print 2: After HOME ALL & QGL. looks good – almost perfect first layer.
Print 3: After HOME ALL & QGL. Good print, but extruder a little high.
Print 4: After HOME ALL & QGL. Poor print. Extruder started out too high
Print 5 After HA & QGL. Poor print. Extruder started out too high
Print 6 After HA & QGL. Poor print. Extruder started out too high
Print 7 After HA & QGL. Excellent print – almost perfect first layer

At this point, it looks like I can consistently get two-color prints that have a functional (if not pretty) first layer with T1, without requiring any ‘fine-tune’ adjustments (although smaller ‘fine tune’ adjustments might be advisable). And this is with the ‘trigger_to_bottom_z’ parameter in the ‘tools_calibrate’ section of misschanger_settings.cfg set to zero.

literally dozens of test prints of my 20x20x10mm high dual-color test print. Note that many successful prints were terminated early, as I was mostly interested in first layer quality.

12 November 2025 Update:

At this point, I think I can successfully do two-color/material prints, with maybe the need for some minor ‘fine-tuning’. However, it is clear that the PRINT_START macro needs to make certain that the HOME_ALL and QGL operations are performed before each print actually starts. Looking at the PRINT_START macro, I see:

[gcode_macro PRINT_START]
description: Multi-tool start (heat active extruder + bed/chamber)
gcode:
    STATUS_MSG MSG="PRINT_START: T{TOOL} Bed={BED} Temp={TOOL_TEMP} Size={params.FIRST_LAYER_PRINT_SIZE|default(0.2)}" TYPE=echo
    {% set TOOL = params.TOOL|default(0)|int %}
    {% set EXTRUDER = 'extruder' + (TOOL|string if TOOL > 0 else '') %}  # 'extruder' or 'extruder1'
    {% set BED = params.BED_TEMP|default(60)|int %}
    {% set TOOL_TEMP = params.TOOL_TEMP|default(200)|int %}
    {% set T1_TEMP = params.T1_TEMP|default(TOOL_TEMP)|int %}  # Use T1_TEMP if passed

    # Force home/level if uninitialized
    {% if printer.toolhead.homed_axes != 'xyz' %}
        STATUS_MSG MSG="Printer uninitialized - Homing + Leveling..." TYPE=echo
        G28  # Home all
        QUAD_GANTRY_LEVEL  # Level
    {% endif %}

    SELECT_TOOL T={TOOL}  # Switch to T1 if TOOL=1

    #STATUS_MSG MSG="PRINT_START: T{TOOL} Bed={BED} Temp={TOOL_TEMP} Size={params.FIRST_LAYER_PRINT_SIZE|default(0.2)}" TYPE=echo
    STATUS_MSG MSG="STATUS_MESHING"
    STATUS_MESHING #Toolhead LEDs
    BED_MESH_CLEAR
    BED_MESH_CALIBRATE  # Mesh after level

    # Heat Bed
    STATUS_HEATING  #Toolhead LEDs
    SET_HEATER_TEMPERATURE HEATER=heater_bed TARGET={BED}
    TEMPERATURE_WAIT SENSOR=heater_bed MINIMUM={BED-2} MAXIMUM={BED+2}

    # Heat Active Extruder
    SET_HEATER_TEMPERATURE HEATER={EXTRUDER} TARGET={TOOL_TEMP}
    TEMPERATURE_WAIT SENSOR={EXTRUDER} MINIMUM={TOOL_TEMP-2} MAXIMUM={TOOL_TEMP+2}

    G90  # Absolute

    STATUS_PRINTING  # LEDs ready!

[gcode_macro PRINT_START]

description: Multi-tool start (heat active extruder + bed/chamber)

gcode:

STATUS_MSG MSG="PRINT_START: T{TOOL} Bed={BED} Temp={TOOL_TEMP} Size={params.FIRST_LAYER_PRINT_SIZE|default(0.2)}" TYPE=echo

{% set TOOL = params.TOOL|default(0)|int %}

{% set EXTRUDER = 'extruder' + (TOOL|string if TOOL > 0 else '') %} # 'extruder' or 'extruder1'

{% set BED = params.BED_TEMP|default(60)|int %}

{% set TOOL_TEMP = params.TOOL_TEMP|default(200)|int %}

{% set T1_TEMP = params.T1_TEMP|default(TOOL_TEMP)|int %} # Use T1_TEMP if passed

# Force home/level if uninitialized

{% if printer.toolhead.homed_axes != 'xyz' %}

STATUS_MSG MSG="Printer uninitialized - Homing + Leveling..." TYPE=echo

G28 # Home all

QUAD_GANTRY_LEVEL # Level

{% endif %}

SELECT_TOOL T={TOOL} # Switch to T1 if TOOL=1

#STATUS_MSG MSG="PRINT_START: T{TOOL} Bed={BED} Temp={TOOL_TEMP} Size={params.FIRST_LAYER_PRINT_SIZE|default(0.2)}" TYPE=echo

STATUS_MSG MSG="STATUS_MESHING"

STATUS_MESHING #Toolhead LEDs

BED_MESH_CLEAR

BED_MESH_CALIBRATE # Mesh after level

# Heat Bed

STATUS_HEATING #Toolhead LEDs

SET_HEATER_TEMPERATURE HEATER=heater_bed TARGET={BED}

TEMPERATURE_WAIT SENSOR=heater_bed MINIMUM={BED-2} MAXIMUM={BED+2}

# Heat Active Extruder

SET_HEATER_TEMPERATURE HEATER={EXTRUDER} TARGET={TOOL_TEMP}

TEMPERATURE_WAIT SENSOR={EXTRUDER} MINIMUM={TOOL_TEMP-2} MAXIMUM={TOOL_TEMP+2}

G90 # Absolute

STATUS_PRINTING # LEDs ready!

So, at least in theory the PRINT_START macro does the HOME_ALL (G28) and QGL if it hasn’t already been done. However, I’m not certain it *ever* does this. I looked to see if there were any status messages emitted, but couldn’t find anything. In fact, there don’t appear to be *any* status messages in the Klippy log. I asked Grok about this, and apparently the only way to get user outputs to the Klippy.log is to put in RESPOND lines. So I put a RESPOND MSG=”In PRINT_START” in the PRINT_START macro. Also, I commented out the ‘if’ statement guarding the HOME_ALL (G28) and QGL commands in PRINT_START to see if that would actually happen, and started a new test print. Console output confirmed that the G28 & QGL commands were actually performed, so we’ll see. Yep, the print started OK (with the extruder tip maybe just a bit too far from the bed, but still very nice!).

The RESPOND message did not appear in Klippy.log – bummer.

I think I’m going to declare victory at this point, and start working on the status LED problem. The problem is that the STATUS_XX commands seem to be going to T0 instead of T1. From the console log I see:

Voron24_30

Send code...
12:58 PM
Done printing file
12:55 PM
Klipper state: Ready
12:55 PM
// T0: _set_sb_leds_by_name. led = t0_sb_leds
12:55 PM
Klipper state: Ready
12:55 PM
// T0: _set_sb_leds_by_name. led = t0_sb_leds
12:55 PM
Klipper state: Ready
12:55 PM
// T0: Status Ready. led = t0_sb_leds
12:55 PM
Selected tool 0 (tool T0)
12:55 PM
Found active tool probe: tool_probe T0
12:55 PM
Activating extruder extruder
12:55 PM
All probes triggered
12:55 PM
Toolhead T0 Select Macro
12:52 PM
Klipper state: Ready
12:52 PM
// T1: _set_sb_leds_by_name. led = t1_sb_leds
12:52 PM
Klipper state: Ready
12:52 PM
// T1: _set_sb_leds_by_name. led = t1_sb_leds
12:52 PM
Klipper state: Ready
12:52 PM
// T1: Status Ready. led = t1_sb_leds
12:52 PM
Tool tool T1 already selected
12:52 PM
Klipper state: Ready
12:52 PM
// T1: _set_sb_leds_by_name. led = t0_sb_leds
12:52 PM
Klipper state: Ready
12:52 PM
// T1: _set_sb_leds_by_name. led = t0_sb_leds
12:50 PM
Klipper state: Ready
12:50 PM
// T1: _set_sb_leds_by_name. led = t0_sb_leds
12:50 PM
Klipper state: Ready
12:50 PM
// T1: _set_sb_leds_by_name. led = t0_sb_leds
12:50 PM
...
12:48 PM
TOOL_BED_MESH_CALIBRATE...
12:48 PM
Klipper state: Ready
12:48 PM
// T1: _set_sb_leds_by_name. led = t0_sb_leds
12:48 PM
Klipper state: Ready
12:48 PM
// T1: _set_sb_leds_by_name. led = t0_sb_leds
12:48 PM
Klipper state: Ready
12:48 PM
// T1: STATUS_MESHING
12:48 PM
Tool tool T1 already selected

Voron24_30

Send code...

12:58 PM

Done printing file

12:55 PM

Klipper state: Ready

12:55 PM

// T0: _set_sb_leds_by_name. led = t0_sb_leds

12:55 PM

Klipper state: Ready

12:55 PM

// T0: _set_sb_leds_by_name. led = t0_sb_leds

12:55 PM

Klipper state: Ready

12:55 PM

// T0: Status Ready. led = t0_sb_leds

12:55 PM

Selected tool 0 (tool T0)

12:55 PM

Found active tool probe: tool_probe T0

12:55 PM

Activating extruder extruder

12:55 PM

All probes triggered

12:55 PM

Toolhead T0 Select Macro

12:52 PM

Klipper state: Ready

12:52 PM

// T1: _set_sb_leds_by_name. led = t1_sb_leds

12:52 PM

Klipper state: Ready

12:52 PM

// T1: _set_sb_leds_by_name. led = t1_sb_leds

12:52 PM

Klipper state: Ready

12:52 PM

// T1: Status Ready. led = t1_sb_leds

12:52 PM

Tool tool T1 already selected

12:52 PM

Klipper state: Ready

12:52 PM

// T1: _set_sb_leds_by_name. led = t0_sb_leds

12:52 PM

Klipper state: Ready

12:52 PM

// T1: _set_sb_leds_by_name. led = t0_sb_leds

12:50 PM

Klipper state: Ready

12:50 PM

// T1: _set_sb_leds_by_name. led = t0_sb_leds

12:50 PM

Klipper state: Ready

12:50 PM

// T1: _set_sb_leds_by_name. led = t0_sb_leds

12:50 PM

...

12:48 PM

TOOL_BED_MESH_CALIBRATE...

12:48 PM

Klipper state: Ready

12:48 PM

// T1: _set_sb_leds_by_name. led = t0_sb_leds

12:48 PM

Klipper state: Ready

12:48 PM

// T1: _set_sb_leds_by_name. led = t0_sb_leds

12:48 PM

Klipper state: Ready

12:48 PM

// T1: STATUS_MESHING

12:48 PM

Tool tool T1 already selected

From the above output, I can see that the ‘STATUS_MESHING’ command was executed at 12:48, but the subsequent call to _set_sb_leds_by_name was called with ‘led = t0_sb_leds’ instead of ‘t1_sb_leds’, but I didn’t see any actual status change messages other than the one ‘STATUS_MESHING’ output. I think I need to edit ALL the STATUS_XX messages to include a STATUS_MSG MSG=”[current status call]” so I can track progress.

Saved all relevant config files (and printer.cfg backups) to ‘config-20251112-131701.zip’, and then deleted all the backup files.

Opened 251103_shared_stealthburner_leds.cfg and edited all ‘gcode_macro status_xxx’ macros to include a STATUS_MSG MSG = “status_xxx” line. Then I restarted Klipper, cleared the console and started another test print.

I noted that the printer started out with T0 initialized and it did the initial HOME_ALL & QGL with T0. Then changed tools and did STATUS_MESHING (with led = t0_sb_leds). Then a full mesh calibration, then // T1: status_heating (led = t0_sb_leds). I noted that the T0 leds did, in fact, change to the ‘STATUS_HEATING’ color set.

I got some Grok help in debugging this situation, and now the LED action seems to be following the correct toolhead. The affected files were 251103_shared_stealthburner_leds.cfg and 251103_paynter_toolchanger.cfg.

I saved the entire configuration set in ‘config-20251112-143625.zip’ in the MissChanger/Config Files folder.

Not so fast! There were a few more bugs to work out, but with Grok’s help we seem to have exterminated them – at least so far. I again saved the configuration set in MissChanger/Config Files/config-20251112-173325.zip

At this point I can print a two-color model reasonably consistently, with toolhead LED colors changing through ‘status_cal_z’, ‘status_meshing’, ‘status_heating’, then ‘status_printing’ and finally to ‘status_ready’ after the print concludes – yay! Here is a photo of a two-color print I just did from a design I created some time ago with my old Flashforge Pro IDEX printer (before I threw it in the trash!)

Final exam: Two color print of a desk nameplate for my wife

30 November 2025 Update:

Well, it has certainly been an interesting adventure so far, but I think I may have actually gotten to the point where I can do dual-material prints with my Voron printer. The last set of hurdles to surmount were a series of infinite hangs during tool changes, caused by poorly formed macros that were way too picky about extruder temperatures. The macros wanted to wait until the extruder temperature was just right, and sometimes the extruder in question just didn’t want to be that exact. This caused long waits (on the order of 30 seconds) before picking up the next tool, and eventually the printer wouldn’t pick up the next tool at all. I got a lot of help from Grok running this down, and I am now a real fan of this AI. Its superpower is a combination of an in-depth understanding of Klipper (by reading the manual at about 10000x human speed, with perfect recall) combined with the ability to grind through huge mind-numbing klippy.log files and then use that information to pinpoint the place(s) in my macros where things weren’t working correctly. For instance, here is one of several macros that regulate the process of changing from one toolhead to another:

#--------------------------------------------------------------------
[gcode_macro _TOOL_DROPOFF]
gcode:
    ## Variables
    {% set tn     = params.TN|string %}
    {% set tool   = printer['tool ' + tn] %}
    {% set x      = tool.params_park_x|float %}
    {% set y      = tool.params_park_y|float %}
    {% set z      = tool.params_park_z|float %}
    {% set safe_y = tool.params_safe_y|float %}
    {% set fast   = tool.params_fast_speed|float %}
    {% set path   = tool['params_' ~ tool.params_type ~ '_path'] %}
    {% set max_z  = printer.configfile.config["stepper_z"]["position_max"]|float %}
    {% set min_z  = tool.params_min_z|float %}
    {% set z_hop  = tool.params_z_hop|default(1.0)|float %}
    {% set cur_y  = printer.toolhead.position[1]|float %}
    {% set cur_z  = printer.toolhead.position[2]|float %}
    G90
    ## Safety move
    {% if cur_y < safe_y %}
        _CLIENT_LINEAR_MOVE Y={safe_y} F={fast} ABSOLUTE=1
    {% endif %}
    ## Move to the dock
    {% if cur_z < min_z %}
        _CLIENT_LINEAR_MOVE X={x} Y={safe_y} Z={min_z+z_hop} F={fast} ABSOLUTE=1
    {% else %}
        _CLIENT_LINEAR_MOVE X={x} Y={safe_y} Z={[cur_z+z_hop, max_z]|min} F={fast} ABSOLUTE=1
    {% endif %}
    _CLIENT_LINEAR_MOVE Y={y + path[0]['y']|float} F={fast} ABSOLUTE=1     # Move to the first point in the path, in the y axis
    M400                                      # Clear cache
    ## Run the path
    {% for pos in path %}
        {% if pos['d']|int == 1 %}
            _CLIENT_LINEAR_MOVE X={x + pos['x']|float} Y={y + pos['y']|float} F={tool.params_path_speed|float * (pos.get('f', 1.0)|float)}  ABSOLUTE=1
        {% endif %}
    {% endfor %}
    M400                                      # Clear cache

#--------------------------------------------------------------------

[gcode_macro _TOOL_DROPOFF]

gcode:

## Variables

{% set tn = params.TN|string %}

{% set tool = printer['tool ' + tn] %}

{% set x = tool.params_park_x|float %}

{% set y = tool.params_park_y|float %}

{% set z = tool.params_park_z|float %}

{% set safe_y = tool.params_safe_y|float %}

{% set fast = tool.params_fast_speed|float %}

{% set path = tool['params_' ~ tool.params_type ~ '_path'] %}

{% set max_z = printer.configfile.config["stepper_z"]["position_max"]|float %}

{% set min_z = tool.params_min_z|float %}

{% set z_hop = tool.params_z_hop|default(1.0)|float %}

{% set cur_y = printer.toolhead.position[1]|float %}

{% set cur_z = printer.toolhead.position[2]|float %}

G90

## Safety move

{% if cur_y < safe_y %}

_CLIENT_LINEAR_MOVE Y={safe_y} F={fast} ABSOLUTE=1

{% endif %}

## Move to the dock

{% if cur_z < min_z %}

_CLIENT_LINEAR_MOVE X={x} Y={safe_y} Z={min_z+z_hop} F={fast} ABSOLUTE=1

{% else %}

_CLIENT_LINEAR_MOVE X={x} Y={safe_y} Z={[cur_z+z_hop, max_z]|min} F={fast} ABSOLUTE=1

{% endif %}

_CLIENT_LINEAR_MOVE Y={y + path[0]['y']|float} F={fast} ABSOLUTE=1 # Move to the first point in the path, in the y axis

M400 # Clear cache

## Run the path

{% for pos in path %}

{% if pos['d']|int == 1 %}

_CLIENT_LINEAR_MOVE X={x + pos['x']|float} Y={y + pos['y']|float} F={tool.params_path_speed|float * (pos.get('f', 1.0)|float)} ABSOLUTE=1

{% endif %}

{% endfor %}

M400 # Clear cache

This is very tough stuff to get my head around due to all the variable referencing, but basically it controls the carriage movement that drops off the current tool into its docking station before the printer moves on to picking up the next one. The Grok realized that part of the problem may have been that the extruder temps weren’t being set at their ‘standby’ temps when they were dropped off, which allowed the extruder to cool all the way down to ambient, which then caused a long delay on pickup as the printer waited for the extruder temp to come back up (and as I said before, sometimes the wait became infinite). In any case, Grok wrote out a completely valid bit of Klipper code to add to the end of this macro to make sure the dropped-off extruder temp was set to ‘standby’ properly, as follows:

    #11/30/25 gfp: added per Grok to eliminate pause for temperature on next pickup
    {% set tn = params.TN|string %}
    {% set tool = printer['tool ' + tn] %}
    {% set macro = "gcode_macro T" ~ tool.tool_number %}
    {% if printer[macro].standby_temp > 0 %}
        M104 T{tool.tool_number} S{printer[macro].standby_temp|int}  ; Set standby temp for parked tool
    {% endif %}

#11/30/25 gfp: added per Grok to eliminate pause for temperature on next pickup

{% set tn = params.TN|string %}

{% set tool = printer['tool ' + tn] %}

{% set macro = "gcode_macro T" ~ tool.tool_number %}

{% if printer[macro].standby_temp > 0 %}

M104 T{tool.tool_number} S{printer[macro].standby_temp|int} ; Set standby temp for parked tool

{% endif %}

Then it went on to look at the companion ‘TOOL PICKUP’ macro and identified the real culprit, which was the use of the ‘M109’ gcode command, which sets the extruder temperature, and then waits for the extruder temperature to fall within a very narrow range. This can take 30 seconds or more – and sometimes the ‘more’ is ‘infinity. Grok’s solution was to use the M104 command, which also sets the temperature, but doesn’t wait – it is non-blocking. Then he followed this with a TEMPERATURE_WAIT command that does block – but only until the extruder temp rises to within 5C of the setpoint. Here’s the applicable part of this macro, with the original M109-based code commented out and the Grok code substituted.

#--------------------------------------------------------------------
[gcode_macro _TOOL_PICKUP]
gcode:
    M400
    ## Variables
    {% set tn             = params.TN|string %}
    {% set tool           = printer['tool ' + tn] %}
    {% set macroparameter = "gcode_macro T" ~ tool.tool_number|string %}
    {% set x              = tool.params_park_x|float %}
    {% set y              = tool.params_park_y|float %}
    {% set z              = tool.params_park_z|float %}
    {% set safe_y         = tool.params_safe_y|float %}
    {% set close_y        = tool.params_close_y|float %}
    {% set cur_z          = printer.toolhead.position[2]|float %}
    {% set z_hop          = tool.params_z_hop|default(1.0)|float %}
    {% set fast           = tool.params_fast_speed|float %}
    {% set path           = tool['params_' ~ tool.params_type ~ '_path'] %}
    M400
    {% if printer.tool_probe_endstop.active_tool_number|int == -1 %}
        ## Fast to the last point
        G90
        _CLIENT_LINEAR_MOVE Y={close_y} F={fast} ABSOLUTE=1
        _CLIENT_LINEAR_MOVE X={x + path[-1]['x']|float} F={fast} ABSOLUTE=1
        _CLIENT_LINEAR_MOVE Y={y + path[-1]['y']|float} F={fast} ABSOLUTE=1

        #11/30/25 Grok working on toolchange hangup
        ## Wait for temp before actually picking up the tool, while the nozzle is resting on it's pad.
#        {% if tool.extruder %}
#            {% if printer[macroparameter].print_temp > 0 and printer["gcode_macro _print_time"].printing|int == 1 %}
#                M109 T{tool.tool_number} S{printer[macroparameter].print_temp|int}
#            {% else %}
#                M109 T{tool.tool_number} S{printer[tool.extruder].target|int}
#            {% endif %}
#        {% endif %}

        ## 11/30/25 Grok With this modified version:
        {% if tool.extruder %}
            {% if printer[macroparameter].print_temp > 0 and printer["gcode_macro _print_time"].printing|int == 1 %}
                # Set target temperature without waiting for exact match
                M104 T{tool.tool_number} S{printer[macroparameter].print_temp|int}
                # Wait only until temperature reaches within a reasonable range of the target
                TEMPERATURE_WAIT SENSOR={tool.extruder} MINIMUM={printer[macroparameter].print_temp|int - 5}
            {% else %}
                M104 T{tool.tool_number} S{printer[tool.extruder].target|int}
                TEMPERATURE_WAIT SENSOR={tool.extruder} MINIMUM={printer[tool.extruder].target|int - 5}
            {% endif %}
        {% endif %}

#--------------------------------------------------------------------

[gcode_macro _TOOL_PICKUP]

gcode:

M400

## Variables

{% set tn = params.TN|string %}

{% set tool = printer['tool ' + tn] %}

{% set macroparameter = "gcode_macro T" ~ tool.tool_number|string %}

{% set x = tool.params_park_x|float %}

{% set y = tool.params_park_y|float %}

{% set z = tool.params_park_z|float %}

{% set safe_y = tool.params_safe_y|float %}

{% set close_y = tool.params_close_y|float %}

{% set cur_z = printer.toolhead.position[2]|float %}

{% set z_hop = tool.params_z_hop|default(1.0)|float %}

{% set fast = tool.params_fast_speed|float %}

{% set path = tool['params_' ~ tool.params_type ~ '_path'] %}

M400

{% if printer.tool_probe_endstop.active_tool_number|int == -1 %}

## Fast to the last point

G90

_CLIENT_LINEAR_MOVE Y={close_y} F={fast} ABSOLUTE=1

_CLIENT_LINEAR_MOVE X={x + path[-1]['x']|float} F={fast} ABSOLUTE=1

_CLIENT_LINEAR_MOVE Y={y + path[-1]['y']|float} F={fast} ABSOLUTE=1

#11/30/25 Grok working on toolchange hangup

## Wait for temp before actually picking up the tool, while the nozzle is resting on it's pad.

# {% if tool.extruder %}

# {% if printer[macroparameter].print_temp > 0 and printer["gcode_macro _print_time"].printing|int == 1 %}

# M109 T{tool.tool_number} S{printer[macroparameter].print_temp|int}

# {% else %}

# M109 T{tool.tool_number} S{printer[tool.extruder].target|int}

# {% endif %}

## 11/30/25 Grok With this modified version:

{% if tool.extruder %}

{% if printer[macroparameter].print_temp > 0 and printer["gcode_macro _print_time"].printing|int == 1 %}

# Set target temperature without waiting for exact match

M104 T{tool.tool_number} S{printer[macroparameter].print_temp|int}

# Wait only until temperature reaches within a reasonable range of the target

TEMPERATURE_WAIT SENSOR={tool.extruder} MINIMUM={printer[macroparameter].print_temp|int - 5}

{% else %}

M104 T{tool.tool_number} S{printer[tool.extruder].target|int}

TEMPERATURE_WAIT SENSOR={tool.extruder} MINIMUM={printer[tool.extruder].target|int - 5}

{% endif %}

These modifications worked extremely well. My test print went from an average of about 30-45sec between the time one tool finished printing to the time the next tool started printing (and as I noted before, it almost always died entirely at some point in the print) to an average of about 15sec inter-tool delay, with complete reliability – YAY!

Here’s a couple of photos of my test print. It is a box with cutouts for chassis-mounted USB-C female sockets; the body was printed in green PETG, and the supports were printed in black PLA.

Of course, my ultimate goal is still to be able to do prints that require water-soluble support material, but the above project at least demonstrated that the two-toolhead MissChanger mod – or at least my version of it, can handle dual-material prints.

03 December 2025 Update:

Made my first water-soluble support print today – yay! I printed the bottom part of one of my caplet dispensers, as shown in the screenshot below:

And here is the result:

07 December 2025 Update:

After running into yet more problems with getting a good ‘squish’ on T1 (and spending WAY too much time working with Grok to no real result), today I went back to Vin’s instructions and went through the entire thing again, carefully.

In preparation for this I changed out the PVA soluble filament for PETG to eliminate any issues associated with the rather flexible and sometimes cantankerous PVA. Then, starting with 4.3. Calibrate offsets .

The first step is PROBE_CALIBRATE. This is the normal ‘paper test’ z-offset calibration, a step I have become very familiar with.

4.3.2. Calibration probe setup: This describes the process of setting up the LUBE_BALLS calibration probe, which I had already done. The description is a bit confusing because Vin also talks about another type of physical offset probe called a ‘Nudge Probe’, so I had to keep working around that issue. Another confusing factor is the need to keep removing and replacing the calibration probe. It can’t be on the bed when doing a QGL, and a QGL is required before doing most steps – ugh!

The steps for validating the calibration probe and calibrating T0, which is then used as the reference for all other toolheads:

Go to printer.cfg and record the z-offset for [tool_probe T0], which should be at (or near) the bottom of the file
Mount tool-head T0 and make sure it’s nozzle is clean
!!! MAKE SURE THE CALIBRATION PROBE IS NOT MOUNTED !!!
Run G28 and QUAD_GANTRY_LEVEL
Mount the calibration probe to the bed.
Run CALIBRATE_TRIGGER_BOTTOM. If it is a fresh calibration probe, it is worth redoing this step until the suggested value is consistent at +/- 0.005mm.
Copy the proposed offset on the console to the trigger_to_bottom_z: in [tools_calibrate].
Save and restart
Run CALIBRATE_OFFSETS TOOL=0 – But, DON’T RESTART
Check if proposed z-offset to be +-0.01mm of the recorded z_offset in step 1.
Run CALIBRATE_OFFSETS TOOL=0 2-3 more times to make sure the measured value is consistent.

The above procedure made a lot more sense today than it did in the past. Maybe I had to struggle for a while and then come back to this from a fresh perspective, kinda like letting go of that NYT Sunday Crossword at midnight, getting some sleep, and coming back to it the next day.

4.3.3. Other tool-head(s):

This is where I got lost before, as I just didn’t understand the strategy being pursued. The idea is to make sure the LUBE_BALLS calibration assembly (probe) is working by using it to calibrate the offsets for T0, and then use the T0 results as the reference for all other toolheads. The magic that makes this work is a macro called CALIBRATE_OFFSETS, which starts by running T0 against the LUBE_BALLS cal probe, and then automatically running each subsequent toolhead T1 through TN against the same probe, thereby establishing the X, Y & Z offsets of all the other toolheads relative to T0. These offsets are then stored in the gcode_x/y/z_offset variables in the [tool T(n)] section in the SAVE_CONFIG area of printer.cfg. If CALIBRATE_OFFSETS is called with a ‘TOOL=N’ argument, then only T0 and TN are calibrated. If CALIBRATE_OFFSETS TOOL=0 is used, only T0 is calibrated as is done in step 9 above.

After doing all this, I wound up with the following offsets for T1:

#*# [tool T1]
#*# gcode_x_offset: -0.101562
#*# gcode_y_offset: -0.195312
#*# gcode_z_offset: -0.120000

#*# [tool T1]

#*# gcode_x_offset: -0.101562

#*# gcode_y_offset: -0.195312

#*# gcode_z_offset: -0.120000

Amazingly enough, this setup resulted in a ‘perfect’ (or at least ‘damned good’) first layer, using my first-layer adjustment test print, shown below:

After this was successful, I replaced the PETG on T1 with my brand-new roll of SainSmart PVA, and tried my partial pill dispenser test print (shown above) again. This time the first PVA layer was as good as I have ever seen for a PVA layer, and the entire print continued without fail (The PVA supports inside the open cavity of the slide part did get loose about halfway through the print, but that wasn’t due to any calibration problem – just PVA not sticking completely to PVA. See the following gallery of print photos:

So at this point I believe I have essentially completed the journey to add a second toolhead to my Voron 2.4/300 3D printer – what a ride!