g2.js

/*
 * g2.js
 *
 * This module defines the G2 driver, which is responsible for managing communication
 * between the host and a g2 motion conroller.  Other objects and functions are
 * defined here as well to support this capability.
 */
const { SerialPort } = require("serialport");
var fs = require("fs");
var events = require("events");
var async = require("async");
var util = require("util");
var Queue = require("./util").Queue;
var log = require("./log").logger("g2");
var process = require("process");
var stream = require("stream");
//const { last } = require("underscore");

// Values of the **stat** field that is returned from G2 status reports
var STAT_INIT = 0;
var STAT_READY = 1;
var STAT_ALARM = 2;
var STAT_STOP = 3;
var STAT_END = 4;
var STAT_RUNNING = 5;
var STAT_HOLDING = 6;
var STAT_PROBE = 7;
var STAT_CYCLING = 8;
var STAT_HOMING = 9;
var STAT_INTERLOCK = 11;
var STAT_SHUTDOWN = 12;
var STAT_PANIC = 13;

// Should take no longer than CMD_TIMEOUT to do a get or a set operation
var CMD_TIMEOUT = 100000;
var EXPECT_TIMEOUT = 300000;

// Reconnection constants
var RECONNECT_BASE_DELAY = 1000; // 1s initial retry delay
var RECONNECT_MAX_DELAY = 30000; // 30s max retry delay
var MAX_RECONNECT_TIME = 300000; // 5 minutes total before giving up
var RECONNECT_READY_TIMEOUT = 5000; // 5s to wait for SYSTEM READY on each attempt

// Status poll constants
var STATUS_POLL_INTERVAL = 5000; // 5s between status poll checks
var STATUS_POLL_TIMEOUT = 3000; // 3s to wait for status poll response
var STATUS_POLL_FEEDHOLD_TIMEOUT = 15000; // 15s timeout during feedhold — more tolerant

var _promiseCounter = 1;
var intendedClose = false;
var THRESH = 1;
var PRIMED_THRESHOLD = 10;
//var lastOverride = 1.0;

// var pat = /s*(G(28|38)\.\d|G2(0|1))/g; Not used yet

// Error codes defined by G2
// See https://github.com/synthetos/g2/blob/edge/TinyG2/tinyg2.h for the latest error codes and messages
try {
    var G2_ERRORS = JSON.parse(fs.readFileSync("./data/g2_errors.json", "utf8"));
} catch (e) {
    G2_ERRORS = {};
}

// A cycle context is created when you run a stream, and is a way to access driver events in the context of the current run
// It is a sort of token that you can recieve events from while the machining cycle is active,
// and that will resolve like a promise when the machining cycle is done.
function CycleContext(driver, st, promise) {
    this.done = false;
    this._firmed = false;
    this._driver = driver;
    this._stream = st;
    this._paused = false;
    this._promise = promise.then(
        function () {
            this.firm(); // Firm the tool
            this.finish();
        }.bind(this)
    );
    this.eventHandlers = {}; // eventname -> [listener]
    this.eventQueue = {}; // eventname -> {f : listener, data : data to pass to listener}
}

// A cycle context is "firmed" when it has turned over itself as a promise through the then() call, or when the
// run finishes, whichever comes first.
CycleContext.prototype.firm = function () {
    if (this.firmed) {
        return;
    }
    log.debug("Firming the cycle context.");
    try {
        for (var event in this.eventQueue) {
            var handlers = this.eventQueue[event];
            for (var i = 0; i < handlers.length; i++) {
                handlers[i].f(handlers[i].data);
            }
        }
        this.firmed = true;
    } catch (e) {
        delete this.eventQueue;
        throw e;
    }
    delete this.eventQueue;
};

// Bind the listener to the provided event name.
// Events bound in this way are queued, so if any have occurred between the beginning of the run and when
// the binding occurs, they will be triggered when the cycle is firmed
CycleContext.prototype.on = function (event, f) {
    log.debug("Binding to the " + event + " event in the cycle context: " + f);
    if (event in this.eventHandlers) {
        this.eventHandlers[event].push(f);
    } else {
        this.eventHandlers[event] = [f];
    }
    return this;
};

// Return a promise that resolves when the cycle is complete (Q Promises)
CycleContext.prototype.then = function (f) {
    this.firm();
    return this._promise.then(function () {
        return f();
    });
};

// Sort of a do-nothing, for now
CycleContext.prototype.finish = function () {
    log.debug("Finishing up the cycle context.");
};

// Emit the provided data to all the listeners to the subscribed event
CycleContext.prototype.emit = function (event, data) {
    var handlers = this.eventHandlers[event];

    if (handlers) {
        for (var i = 0; i < handlers.length; i++) {
            handlers[i](data);
        }
    }
};

// Pause the run by pausing the stream that is piping data into this context
CycleContext.prototype.pause = function () {
    this._paused = true;
    this._stream.pause();
};

// Resume the run by resuming the stream that is piping data into this context
CycleContext.prototype.resume = function () {
    this._paused = false;
    this._stream.resume();
};

// The G2 object represents the connection to the driver, which happens as serial over USB
function G2() {
    this._currentData = [];
    this._currentGCodeData = [];
    this.g2_status = { stat: null, posx: 0, posy: 0, posz: 0 };
    this.status = { stat: "idle", posx: 0, posy: 0, posz: 0 };
    this._seen_ready = false;
    this.gcode_queue = new Queue();
    this.command_queue = new Queue();

    this.pause_flag = false;
    this.connected = false;

    // OpenSBP Pause
    this.pause_hold = false;

    // Feedhold/flush
    this.quit_pending = false;
    this.stat = null;
    this.hold = null;
    this.manual_hold = false;

    this.resumePending = false;
    this.holdComplete = false; // Latches true when hold:10 is seen; cleared on resume send

    // Readers and callbacks
    this.expectations = [];
    this.readers = {};

    // Members related to streaming
    this.qtotal = 0;
    this.flooded = false;
    this.send_rate = 1;
    this.lines_sent = 0;
    this.primedThreshold = PRIMED_THRESHOLD;

    this.context = null;

    // Event emitter inheritance and behavior setup
    events.EventEmitter.call(this);
    this.setMaxListeners(50);
    this.lines_to_send = 4;
    this._ignored_responses = 0;
    this._primed = false;
    this._streamDone = false;

    this.lineBuffer = [];

    // Reconnection state
    this._reconnecting = false;
    this._reconnectTimer = null;
    // Counts failed attempts within the current reconnect() loop, reset at
    // each loop start. Used to drive the "first attempt failed" UX in machine.js.
    this._reconnectAttempts = 0;

    // Status poll state
    this._lastDataReceived = 0;
    this._statusPollTimer = null;
    this._statusPollTimeout = null;
    this._statusPollPending = false;
    // Set when the heartbeat probe has been written but its response not yet seen.
    // Used to suppress logging of the probe's SR response in onData.
    this._silentProbePending = false;
    // Set after _handleDisconnect runs so onSerialClose / _write / etc. can
    // short-circuit cleanly and only one "disconnect" event is emitted.
    this._disconnected = false;
}

util.inherits(G2, events.EventEmitter);

// Reset all internal state that becomes stale after a serial disconnect.
// This prepares the G2 object for a fresh reconnection without creating a new instance.
G2.prototype._resetInternalState = function () {
    // Buffers
    this._currentData = [];
    this.lineBuffer = [];

    // Queues (Queue has no clear method, so reinitialize)
    this.gcode_queue = new Queue();
    this.command_queue = new Queue();

    // Pending callbacks — these will never resolve, let them expire naturally
    this.expectations = [];
    this.readers = {};

    // Streaming state
    this.lines_to_send = 4;
    this._ignored_responses = 0;
    this._primed = false;
    this._streamDone = false;
    this.context = null;
    this.flooded = false;
    this.qtotal = 0;
    this.lines_sent = 0;

    // Flags
    this.pause_flag = false;
    this.quit_pending = false;
    this.resumePending = false;
    this.holdComplete = false;
    this.manual_hold = false;
    this.pause_hold = false;

    // Connection state — allow "SYSTEM READY" detection again
    this.connected = false;
    this._seen_ready = false;
};

// Creates a cycle context, which has a pass-through stream into which data can be piped
G2.prototype._createCycleContext = function () {
    if (this.context) {
        throw new Error("Cannot create a new cycle context.  One already exists.");
    }
    // Create and setup the pass-through stream
    var st = new stream.PassThrough();
    st.setEncoding("utf8");
    this._streamDone = false;
    this.lineBuffer = [];
    this.flushcallback = null;

    // Handle data coming in on the stream
    st.on(
        "data",
        function (chunk) {
            // console.log("=== STREAM DATA RECEIVED ===");
            // console.log("Chunk raw:", JSON.stringify(chunk.toString()));
            // console.log("Chunk length:", chunk.toString().length);
            // console.log("Chunk lines:", chunk.toString().split("\n").length);

            // Stream data comes in "chunks" which are often multiple lines
            chunk = chunk.toString();
            var newLines = false;
            // Repartition incoming "chunked" data as lines
            for (var i = 0; i < chunk.length; i++) {
                var ch = chunk[i];
                this.lineBuffer.push(ch);
                if (ch === "\n") {
                    newLines = true;
                    var s = this.lineBuffer.join("").trim();

                    // Enqueue individual lines in the g-code queue
                    this.gcode_queue.enqueue(s);

                    // The G2 sender doesn't actually start sending until it is "primed"
                    // Priming happens either when the number of lines to send reaches a certain threshold
                    // or the prime() function is called manually.
                    if (this.gcode_queue.getLength() >= PRIMED_THRESHOLD) {
                        this._primed = true;
                    }
                    this.lineBuffer = [];
                }
            }
            // If new lines were enqueued as a part of the re-chunkification process, send them.
            if (newLines) {
                this.sendMore();
            }
        }.bind(this)
    );

    ////####
    // Items that need to be pre-pended for all normal motions cycles.
    // So, if we are not in IdleRuntime, then ...
    // Set absolute, spindle speed default, units, and turn on output 4 & ...
    // M0 sets G2 to 'File Stop' stat:3; thus avoids accidentally starting in stat:4 (needs to be in first 4 commands or vulnerable)
    // ... these conditions are exited when in machine as it goes back to idle
    ////## {spph:true} makes sure that spindle shutoff and pull up is enabled for feedholds; no longer turned off in manual, needed?
    ////## S1000 is default for spindle speed so that m3 (and SO,1,1) will work correctly w/delay w/o speed
    ////## TODO: create default variable for S-value for VFD spindle control, just a dummy here now
    ////## TODO: fix this kludge to get the current_runtime !

    if (global.CUR_RUNTIME != "[IdleRuntime]") {
        // N1 M5 BEFORE the M0: the toolhead's spindle state only updates when a
        // queued engage executes, so a stale "running" state can survive from a
        // previous job (M30's spindle_stop is planner-queued and flushable).
        // With spph enabled, M0 would pause that stale state and RESUME it —
        // physically re-starting the spindle — when the cycle is released. M5
        // first clears the state in-order before M0's pause check runs. It's a
        // no-op when the spindle is already off (every normal start).
        var prependString =
          "N1 M5\n" + "N2 M0\n" + "N3 G90\n" + "N4 G61\n" + "{out4:1}\n" + "{spph:true}\n" + "N6 S1000\n";

        log.debug("=== PREPEND DEBUG ===");
        log.debug("Prepend string:", JSON.stringify(prependString));
        log.debug("Lines to send before:", this.lines_to_send);

        log.debug("PREPEND to cycle - " + global.CUR_RUNTIME);
        st.write(prependString);

        // FORCE enough lines_to_send to handle all prepend lines //** IMPORTANT */
        this.lines_to_send = Math.max(this.lines_to_send, 7);
        log.debug("Lines to send after adjustment:", this.lines_to_send);
    }

    // Handle a stream finishing or disconnecting.
    st.on(
        "end",
        function () {
            log.debug("cycle context end event");
            // Send whatever is left in the queue.  (There may be stuff unsent even after the stream is over)
            this._primed = true;
            this._streamDone = true;
            this.sendMore();
            log.info("***Stream END event.");
        }.bind(this)
    );

    // Handle a stream being piped into this context (currently do nothing)
    // chunk is defined but never used
    st.on("pipe", function (/* chunk */) {
        log.debug("Stream PIPE event");
    });

    // Create the promise that resolves when the machining cycle ends.
    var promise = this._createStatePromise([STAT_END]).then(
        function () {
            this.context = null;
            this._primed = false;
            log.debug("Cycle context promise resolved.");
            return this;
        }.bind(this)
    );

    // Actually create and return the context built from these configured entities
    var ctx = new CycleContext(this, st, promise);

    // The G2 instance keeps track of its current (singleton) cycle context.
    this.context = ctx;
};

// Actually open the serial port and configure G2 based on stored settings
G2.prototype.connect = function (path, callback) {
    // Store paths for safe keeping
    this._serialPath = path;

    // Open the serial port.  This used to be two ports, but now is only the one.
    log.info("Opening G2 port: " + this._serialPath);
    this._serialPort = new SerialPort({
        path: this._serialPath,
        baudRate: 115200,
        autoOpen: false,
        rtscts: true,
    });
    this._serialToken = "S";

    // Handle errors
    this._serialPort.on("error", this.onSerialError.bind(this));
    this._serialPort.on("close", this.onSerialClose.bind(this));

    // The control port is the only one to truly handle incoming data
    this._serialPort.on("data", this.onData.bind(this));

    // Flush and get status once the "ready" message has been received from the controller.
    // G2 reports a "SYSTEM READY" message on connect that indicates that the system is prepared to
    // recieve g-codes and JSON commands.  We don't want to do anything until we get that.
    this.once(
        "ready",
        function () {
            this.connected = true;

            ////## Have tested both reset and end-file during this start-up to clear "alarm" and bad stop
            ////##    a reset works, but disconnects G2 and requires new manual fabmo start
            ////##		this._write('\x18\n', function() {   ////## try reset not a kill
            ////##		this._write('M30\n', function() {    ////## try end file
            ////## Kludging 2 kills seems to allow a restart when g2 stuck
            this._write("\x04\n", function () {});
            this._write(
                "\x04\n",
                function () {
                    this.requestStatusReport(
                        function () {
                            callback(null, this);
                        }.bind(this)
                    );
                }.bind(this)
            );
            // this._write(
            //     "\x04\n",
            //     function () {
            //         // Clear any leftover alarm state (e.g. soft limit from previous session)
            //         this.command({ clear: null });
            //         this.requestStatusReport(
            //             function () {
            //                 this.startStatusPoll();
            //                 callback(null, this);
            //             }.bind(this)
            //         );
            //     }.bind(this)
            // );
        }.bind(this)
    );

    // Actually perform the connect, and wait for the 'ready' event.
    // We give 3 seconds for the ready event to materialize, which is plenty of time.  Typical
    // times to ready the system are on the order of tens or hundreds of milliseconds.
    this._serialPort.open(
        function (error) {
            if (error) {
                log.error("ERROR OPENING CONTROL PORT " + error);
                return callback(error);
            } else {
                log.info("G2 Port Opened.");
                setTimeout(
                    function checkConnected() {
                        if (!this.connected) {
                            return callback(new Error("Never got the SYSTEM READY from g2."));
                        }
                    }.bind(this),
                    3000
                );
            }
        }.bind(this)
    );
};

// Close the serial port - important for shutting down the application and not letting resources "dangle"
G2.prototype.disconnect = function (reason, callback) {
    log.info(reason);
    if (reason === "firmware") {
        intendedClose = true;
    }
    this.stopStatusPoll();
    this._serialPort.close(callback);
};

// Log serial errors.  Most of these are exit-able offenses, though.
G2.prototype.onSerialError = function (data) {
    // === ENHANCED SERIAL ERROR LOGGING ===
    var errorTime = new Date().toISOString();
    
    log.error("╔════════════════════════════════════════════════════════════════");
    log.error("║ G2 SERIAL ERROR EVENT");
    log.error("╠════════════════════════════════════════════════════════════════");
    log.error("║ Timestamp:           " + errorTime);
    log.error("║ Error Data:          " + JSON.stringify(data));
    log.error("║ Serial Path:         " + (this._serialPath || 'unknown'));
    log.error("║ Port Open:           " + (this._serialPort && this._serialPort.isOpen ? "YES" : "NO"));
    log.error("║ Connected:           " + this.connected);
    log.error("║ In Cycle Context:    " + (this.context ? "YES - FILE RUNNING" : "NO"));
    log.error("║ Lines Sent:          " + this.lines_sent);
    log.error("║ Queue Length:        " + this.gcode_queue.getLength());
    log.error("╚════════════════════════════════════════════════════════════════");
    
    // Save log immediately on serial errors
    require('./log').saveCurrentLog('g2-serial-error', function(err) {
        if (err) {
            log.error("Failed to save log on serial error: " + err);
        }
    });
};

// When the serial link to G2 is closed, log diagnostics and notify listeners.
// Recovery is user-initiated — call G2.reconnect() explicitly (e.g. from the
// /reconnect route or the dashboard's persistent disconnect dialog).
G2.prototype.onSerialClose = function () {
    this.connected = false;

    // === ENHANCED DIAGNOSTIC LOGGING ===
    var disconnectTime = new Date().toISOString();
    var timeSinceLastData = this._lastDataReceived ? (Date.now() - this._lastDataReceived) : 'N/A';

    log.error("╔════════════════════════════════════════════════════════════════");
    log.error("║ G2 SERIAL DISCONNECT EVENT");
    log.error("╠════════════════════════════════════════════════════════════════");
    log.error("║ Timestamp:           " + disconnectTime);
    log.error("║ Serial Path:         " + (this._serialPath || 'unknown'));
    log.error("║ Time Since Last Rx:  " + timeSinceLastData + " ms");
    log.error("║ Lines Sent:          " + this.lines_sent);
    log.error("║ GCode Queue Length:  " + this.gcode_queue.getLength());
    log.error("║ Command Queue Len:   " + this.command_queue.getLength());
    log.error("║ In Cycle Context:    " + (this.context ? "YES - FILE RUNNING" : "NO - idle"));
    log.error("║ Stream Done:         " + this._streamDone);
    log.error("║ Primed:              " + this._primed);
    log.error("║ Connected:           " + this.connected);
    log.error("║ Reconnecting:        " + this._reconnecting);
    log.error("║ Pause Flag:          " + this.pause_flag);
    log.error("║ Quit Pending:        " + this.quit_pending);
    log.error("║ Last G2 Status:      stat=" + (this.status.stat || 'unknown'));
    log.error("║ Heartbeat Pending:   " + this._heartbeatPending);

    // Log current runtime if available
    if (typeof global.CUR_RUNTIME !== 'undefined') {
        log.error("║ Current Runtime:     " + global.CUR_RUNTIME);
    }

    log.error("╚════════════════════════════════════════════════════════════════");

    // Save log for diagnostics
    require('./log').saveCurrentLog('g2-disconnect', function (err) {
        if (err) {
            log.error("Failed to save log on disconnect: " + err);
        }
    });

    // Intentional close (firmware update) — do nothing
    if (intendedClose) {
        log.info("Serial close was intentional (firmware update) - not handling as disconnect");
        return;
    }

    // Already mid-reconnect — let the retry loop handle the close
    if (this._reconnecting) {
        log.warn("Serial close during reconnect — handled by retry loop");
        return;
    }

    this._handleDisconnect("serial_close");
};

// Mark the G2 link as down, clean up internal state, and notify listeners
// so the dashboard can prompt the user. Idempotent — repeated calls are no-ops.
// Recovery (G2.reconnect) is NOT triggered automatically; it must be invoked
// explicitly (user action via /reconnect, or engine startup retry).
G2.prototype._handleDisconnect = function (reason) {
    if (this._disconnected) {
        return;
    }
    this._disconnected = true;
    this.connected = false;
    this.stopStatusPoll();

    var payload = {
        reason: reason,
        timestamp: new Date().toISOString(),
        timeSinceLastData: this._lastDataReceived
            ? Date.now() - this._lastDataReceived
            : null,
        lastStat: (this.status && this.status.stat) || null,
        inCycle: !!this.context,
        serialPath: this._serialPath || null,
    };

    // Drop listeners on the (now-stale) port so ghost events don't fire
    if (this._serialPort) {
        try {
            this._serialPort.removeAllListeners();
        } catch (e) {
            log.warn("Error removing serial listeners on disconnect: " + e);
        }
    }

    // Wipe queues / buffers / flags so a future reconnect starts clean
    this._resetInternalState();

    log.error(
        "G2 link lost (reason=" + reason + ") — awaiting user-initiated reconnect"
    );
    this.emit("disconnect", payload);
};

// User-initiated reconnect to G2 with exponential backoff.
// Called explicitly — by the /reconnect route, the dashboard's disconnect
// dialog, or from engine startup when the initial connection failed.
// Reuses the existing G2 object in-place so all external references
// (machine.driver, runtimes, config) remain valid.
G2.prototype.reconnect = function () {
    if (this._reconnecting) {
        log.warn("G2 reconnect already in progress — ignoring duplicate request");
        return;
    }
    var that = this;
    this._reconnecting = true;
    this._reconnectAttempts = 0;
    this.stopStatusPoll();

    // Notify listeners (machine.js) so the dashboard can swap the disconnect
    // modal for a "Reconnecting…" modal. /reconnect returns 200 immediately;
    // without this, the user would see the dialog dismiss and have no signal
    // that retries are still in flight.
    this.emit("reconnecting", {
        timestamp: new Date().toISOString(),
        maxTime: MAX_RECONNECT_TIME,
        serialPath: this._serialPath || null,
    });

    // _handleDisconnect normally has already cleaned up, but reconnect may also
    // be called from a clean state (engine startup) — make these idempotent.
    if (this._serialPort) {
        try {
            this._serialPort.removeAllListeners();
        } catch (e) {
            log.warn("Error removing serial listeners during reconnect: " + e);
        }
    }
    this._resetInternalState();

    var startTime = Date.now();
    var delay = RECONNECT_BASE_DELAY;

    function attemptReconnect() {
        var elapsed = Date.now() - startTime;
        if (elapsed >= MAX_RECONNECT_TIME) {
            log.error(
                "G2 reconnection failed after " +
                    Math.round(elapsed / 1000) +
                    "s — falling back to process exit."
            );
            require('./log').saveCurrentLog('g2-reconnect-failed', function () {
                process.exit(14);
            });
            return;
        }

        log.info(
            "G2 reconnection attempt (elapsed: " +
                Math.round(elapsed / 1000) +
                "s, next delay: " +
                Math.round(delay / 1000) +
                "s)"
        );

        // Check if the serial device exists before trying to open it
        fs.access(that._serialPath, fs.constants.R_OK | fs.constants.W_OK, function (err) {
            if (err) {
                log.warn("Serial device " + that._serialPath + " not available yet: " + err.code);
                scheduleNextRetry();
                return;
            }

            // Create a new serial port object on the same path
            var newPort = new SerialPort({
                path: that._serialPath,
                baudRate: 115200,
                autoOpen: false,
                rtscts: true,
            });

            var readyFired = false;
            var readyTimeout = null;

            // Handler for when G2 sends "SYSTEM READY"
            function onReady() {
                readyFired = true;
                if (readyTimeout) {
                    clearTimeout(readyTimeout);
                    readyTimeout = null;
                }

                that.connected = true;
                that._reconnecting = false;
                that._disconnected = false;
                that._seen_ready = true;

                // Wire the global serial close/error handlers to the new port so
                // a subsequent disconnect is detected (the retry loop only
                // attached local close/error handlers for the open attempt).
                that._serialPort.on("close", that.onSerialClose.bind(that));
                that._serialPort.on("error", that.onSerialError.bind(that));

                // Send kill commands to clear any stale G2 state, then notify success
                that._write("\x04\n", function () {});
                that._write("\x04\n", function () {
                    that.requestStatusReport(function () {
                        log.info("G2 reconnection successful.");
//                        that.startStatusPoll();
                        that.emit("reconnected");
                    });
                });
            }

            // Listen for the "ready" event (emitted when onMessage sees "SYSTEM READY")
            that.once("ready", onReady);

            // Wire up event handlers on the new port
            newPort.on("error", function (err) {
                log.error("Serial error during reconnect attempt: " + err);
            });
            newPort.on("close", function () {
                // Port closed during reconnection attempt — handled by retry loop
                if (that._reconnecting && !readyFired) {
                    log.warn("Serial port closed during reconnect attempt");
                }
            });
            newPort.on("data", that.onData.bind(that));

            // Replace the internal serial port reference
            that._serialPort = newPort;
            that._serialToken = "S";

            // Attempt to open
            newPort.open(function (openErr) {
                if (openErr) {
                    log.warn("Failed to open serial port: " + openErr);
                    that.removeListener("ready", onReady);
                    scheduleNextRetry();
                    return;
                }

                log.info("G2 port opened during reconnect — waiting for SYSTEM READY...");

                // Give G2 time to send "SYSTEM READY"
                readyTimeout = setTimeout(function () {
                    if (!readyFired) {
                        log.warn("No SYSTEM READY received within " + (RECONNECT_READY_TIMEOUT / 1000) + "s");
                        that.removeListener("ready", onReady);
                        // Close this port attempt and retry
                        try {
                            newPort.close(function () {
                                scheduleNextRetry();
                            });
                        } catch (e) {
                            scheduleNextRetry();
                        }
                    }
                }, RECONNECT_READY_TIMEOUT);
            });
        });
    }

    function scheduleNextRetry() {
        // Bail out if the user cancelled while an attempt was in flight
        if (!that._reconnecting) {
            return;
        }
        that._reconnectAttempts += 1;
        that.emit("reconnect-attempt-failed", {
            attempt: that._reconnectAttempts,
            nextDelayMs: delay,
        });
        that._reconnectTimer = setTimeout(function () {
            that._reconnectTimer = null;
            attemptReconnect();
        }, delay);
        // Exponential backoff with cap
        delay = Math.min(delay * 2, RECONNECT_MAX_DELAY);
    }

    // Start the first attempt after a short delay
    that._reconnectTimer = setTimeout(function () {
        that._reconnectTimer = null;
        attemptReconnect();
    }, RECONNECT_BASE_DELAY);
};

// User-initiated cancel of the reconnect retry loop. Clears the pending timer
// and re-emits "disconnect" so the dashboard restores the disconnect modal
// (with the Reconnect button) for the user to try again later.
G2.prototype.cancelReconnect = function () {
    if (!this._reconnecting) {
        return false;
    }
    log.warn("User cancelled G2 reconnect retry loop");
    if (this._reconnectTimer) {
        clearTimeout(this._reconnectTimer);
        this._reconnectTimer = null;
    }
    this._reconnecting = false;
    // _disconnected remains true — we are still not connected. Re-emit so the
    // dashboard updates its modal (idempotency in _handleDisconnect would
    // otherwise swallow this).
    this.emit("disconnect", {
        reason: "user_cancelled",
        timestamp: new Date().toISOString(),
        timeSinceLastData: this._lastDataReceived
            ? Date.now() - this._lastDataReceived
            : null,
        lastStat: (this.status && this.status.stat) || null,
        inCycle: !!this.context,
        serialPath: this._serialPath || null,
    });
    return true;
};

// Start periodic status poll to detect silent G2 failures.
// Sends a status report request if no data has been received recently.
// (Distinct from the blue LED "heartbeat" pulsing on the G2 card itself.)
G2.prototype.startStatusPoll = function () {
    this.stopStatusPoll();
    this._statusPollTimer = setInterval(
        function () {
            if (!this.connected || this._reconnecting || this._disconnected) {
                return;
            }
            // Use longer timeout during feedhold — G2 is alive but paused
            var inHold = this.pause_flag || this.status.inFeedHold;
            var timeout = inHold ? STATUS_POLL_FEEDHOLD_TIMEOUT : STATUS_POLL_TIMEOUT;
            // Skip if we received data recently — G2 is alive
            if (Date.now() - this._lastDataReceived < STATUS_POLL_INTERVAL) {
                return;
            }
            this._statusPollPending = true;
            this._sendSilentProbe();

            // Set timeout for response
            this._statusPollTimeout = setTimeout(
                function () {
                    if (this._statusPollPending) {
                        this._onStatusPollTimeout();
                    }
                }.bind(this),
                timeout
            );
        }.bind(this),
        STATUS_POLL_INTERVAL
    );
};

// Write the heartbeat probe directly to the serial port, bypassing command_queue
// AND the normal g2 log. The probe is identical in shape to a user-requested SR,
// so we tag _silentProbePending so onData can suppress logging of the response.
// _ignored_responses is incremented to balance flow control accounting (the
// returned {"r":{"sr":...}} should not be counted as a completed gcode line).
G2.prototype._sendSilentProbe = function () {
    if (!this._serialPort || !this._serialPort.isOpen) {
        return;
    }
    this._silentProbePending = true;
    this._ignored_responses += 1;
    this._serialPort.write(JSON.stringify({ sr: null }) + "\n", function () {});
};

// Stop the status poll timer and any pending response timeout
G2.prototype.stopStatusPoll = function () {
    if (this._statusPollTimer) {
        clearInterval(this._statusPollTimer);
        this._statusPollTimer = null;
    }
    if (this._statusPollTimeout) {
        clearTimeout(this._statusPollTimeout);
        this._statusPollTimeout = null;
    }
    this._statusPollPending = false;
};

// Called when G2 fails to respond to a status poll within STATUS_POLL_TIMEOUT.
// Logs diagnostics, closes the port (which triggers onSerialClose ->
// _handleDisconnect), and falls back to _handleDisconnect directly if the
// close attempt itself fails. No automatic reconnect — the user is notified
// via the "disconnect" event and must invoke G2.reconnect() explicitly.
G2.prototype._onStatusPollTimeout = function () {
    var timeoutTime = new Date().toISOString();
    var timeSinceLastData = Date.now() - this._lastDataReceived;

    log.error("╔════════════════════════════════════════════════════════════════");
    log.error("║ G2 STATUS POLL TIMEOUT");
    log.error("╠════════════════════════════════════════════════════════════════");
    log.error("║ Timestamp:           " + timeoutTime);
    log.error("║ Time Since Last Rx:  " + timeSinceLastData + " ms");
    log.error("║ In Feedhold:         " + (this.pause_flag || this.status.inFeedHold));
    log.error("║ G2 Status (stat):    " + (this.status.stat || 'unknown'));
    log.error("║ In Cycle Context:    " + (this.context ? "YES" : "NO"));
    log.error("║ Status Poll Pending: " + this._statusPollPending);
    log.error("╚════════════════════════════════════════════════════════════════");

    this.stopStatusPoll();
    try {
        this._serialPort.close(function (err) {
            if (err) {
                log.warn("Error closing port after status poll timeout: " + err);
                this._handleDisconnect("heartbeat_timeout");
            }
        }.bind(this));
    } catch (e) {
        log.warn("Exception closing port after status poll timeout: " + e);
        this._handleDisconnect("heartbeat_timeout");
    }
};

// Write to the serial port (and log it)
G2.prototype._write = function (s, callback) {
    if (!this.connected || !this._serialPort || !this._serialPort.isOpen) {
        log.error("Attempted write while disconnected: " + String(s).substring(0, 50));
        if (!this._reconnecting && !this._disconnected) {
            this._handleDisconnect("write_failed");
        }
        if (callback) {
            setImmediate(callback);
        }
        return;
    }
    log.g2(this._serialToken, "out", s);
    this._serialPort.write(
        s,
        function () {
            if (callback) {
                this._serialPort.drain(callback);
            }
        }.bind(this)
    );
};

// Clear the "alarm" state on the g2 controller.  Alarms happen in a few cases:
// - Limit switch triggered (not well handled)
// - Soft limit encountered (also not well handled)
// - Command recieved after a queue flush has  been issued (this is handled well by this module)
// - Firmware errors in G2 that put it in the alarm state as a safety feature
G2.prototype.clearAlarm = function () {
    this.command({ clear: null });
};

// Units are sort of weird, and our fork of the g2 firmware hijacks the "gun" command
// to set the system units.  (Conventionally, you have to use a G-code to do this)
// stat is defined but never used
G2.prototype.setUnits = function (units, callback) {
    this.command({ gun: units === 0 || units == "in" ? 0 : 1 });
    this.requestStatusReport(function (/* stat */) {
        callback();
    });
};

// Request a status report from G2
// The callback, if provided, is called with the status report contents.
G2.prototype.requestStatusReport = function (callback) {
    // Register the callback to be called when the next status report comes in
    typeof callback === "function" && this.once("status", callback);
    this.command({ sr: null });
};

// Called for every chunk of data returned from G2
G2.prototype.onData = function (data) {
    // Track data reception for status poll
    this._lastDataReceived = Date.now();
    this._statusPollPending = false;

    var t = new Date().getTime(); // Get current time for logging
    // raw_data event for listeners that want to snoop on all data.
    // Not usually used except for debugging
    this.emit("raw_data", data);

    // Although data comes in "chunks" from the serial stream, the information is processed as lines
    // The following section repartitions the incoming chunk as lines so that it can be interpreted
    var s = data.toString("ascii");
    var len = s.length;
    for (var i = 0; i < len; i++) {
        var c = s[i];
        if (c === "\n") {
            var json_string = this._currentData.join("");
            // eslint flags t as unused, used for logging
            // eslint-disable-next-line no-unused-vars
            t = new Date().getTime();
            try {
                // Responses from G2 are in JSON format (always) so we parse them out, and handle the messages
                var obj = JSON.parse(json_string);
                // Suppress logging the SR response that came back from a silent
                // heartbeat probe — keeps the g2 log free of idle noise.
                var isSilentProbeResponse =
                    this._silentProbePending &&
                    obj &&
                    ((obj.r && obj.r.sr) || obj.sr);
                if (isSilentProbeResponse) {
                    this._silentProbePending = false;
                } else {
                    log.g2("S", "in", json_string);
                }
                this.onMessage(obj);
            } catch (e) {
                this.handleExceptionReport(e);
                throw e;
            } finally {
                // if we hit a linefeed, we try to parse, if we succeed we clear the line and start anew
                // and if we fail to parse, we still clear the line and start anew.
                this._currentData = [];
            }
        } else {
            this._currentData.push(c);
        }
    }
};

// The footer is the part of the JSON response message that contains error information
// If the footer indicates an error code, we do a lookup on the error message and emit an error event
// Note that G2_ERRORS must be up-to-date with the current firmware in order for the lookup to be meaningful.
G2.prototype.handleFooter = function (response) {
    if (response.f) {
        if (response.f[1] !== 0) {
            var err_code = response.f[1];
            var err_msg = G2_ERRORS[err_code] || ["ERR_UNKNOWN", "Unknown Error"];
            this.emit("error", [err_code, err_msg[0], err_msg[1]]);
            return new Error(err_msg[1]);
        }
    }
};

// When there is an exception in the G2 firmware, it issues an "exception report"
// which comes as a part of the normal JSON response.  There are a number of ways
// to react to this, depending on the exception.  In time past, certain exceptions were
// ignored or handled in a special way.  Now, we mostly just make a note of the exception and report it in the log.
G2.prototype.handleExceptionReport = function (response) {
    if (response.er) {
        this._lastExceptionReport = response.er;
        var stat = response.er.st;
        if (stat === 207 && this.quit_pending) {
            this.quit_pending = false;
        }
        log.error("Response with an exception report:");
        log.error(JSON.stringify(response));
    }
};

G2.prototype.getLastException = function () {
    return this._lastExceptionReport || null;
};
G2.prototype.clearLastException = function () {
    this._lastExceptionReport = null;
};

/*
 * This function handles status reports that are returned by the tool.
 * Status reports contain position, velocity, status, input/output data, etc.
 * When they arrive, we update internal state, fire events, etc.
 *
 * 0	machine is initializing
 * 1	machine is ready for use
 * 2	machine is in alarm state (shut down)
 * 3	program stop or no more blocks (M0, M1, M60)
 * 4	program end via M2, M30
 * 5	motion is running
 * 6	motion is holding
 * 7	probe cycle active
 * 8	machine is running (cycling)
 * 9	machine is homing
 */
G2.prototype.handleStatusReport = function (response) {
    if (response.prb) {
        log.debug("GOT PROBE FINISH REPORT! Target at: " + response.prb.z);
        if (response.prb.e === 1) {
            this.status.targetHit = true;
            this.probeCompleting = true; // Block feedholds during completion
            log.debug("HIT TARGET!");

            // Clear the flag after probe completion window
            setTimeout(() => {
                this.probeCompleting = false;
                log.debug("Probe completion window closed");
            }, 500); // 500ms window
        }
    }
    if (response.sr) {
        // Update our copy of the system status
        for (var key in response.sr) {
            var value = response.sr[key];
            if (key === "unit") {
                value = value === 0 ? "in" : "mm";
            }
            // // for case of key = posa, posb, or posc then divide value by 0.0393701 to convert to inches ////##A
            // if (key === "posa" || key === "posb" || key === "posc") {
            //     value = value * 0.0393701;
            // }
            this.status[key] = value;
        }

        // "stat" is the system state (detailed in the list above)
        if ("stat" in response.sr) {
            switch (response.sr.stat) {
                // If we stopped and flushed, we might have provided a callback
                // We call it once we get the confirmation that the tool has actually stopped and flushed.
                case STAT_STOP:
                    if (this.flushcallback) {
                        this.flushcallback(null);
                        this.flushcallback = null;
                    }
                    break;
                case STAT_END:
                    this.status.line = null;
                    break;
                // A really bad error in the firmware causes a "panic" - these are rare, but they do
                // happen.  A panic is not resolvable without resetting the micrcontroller hosting G2
                // TODO: We might want to actually kill the engine here, or issue some kind of reset.
                case STAT_PANIC:
                    log.error("Panicked Response:");
                    log.error(JSON.stringify(response));
                    break;
            }

            // this.quit_pending is set when a quit is issued while the tool is running.
            // The reason to have this flag is that once a stop and flush are issued to the g2 controller
            // a second stop and flush can cause the system to crash.  A second quit will not be sent if
            // another quit is pending.  The quit is pending until g2 has fully transitioned to STAT_END
            // If it moves into STAT_STOP or STAT_HOLD during a pending quit, a stop and flush are
            // sent to exit the machining cycle.  A stop/flush that is issued too soon after the transition
            // to STAT_STOP or STAT_HOLDING can also cause the system to crash, so we give 50ms before doing
            // this.
            // TODO - This state jiggerypokery is because there are issues with state management surrounding
            //        job kills in the firmware.  Those issues should be resolved so that this is not necessary.
            if (this.quit_pending) {
                switch (response.sr.stat) {
                    case STAT_STOP:
                    case STAT_HOLDING:
                        log.info("Issuing the job kill command.");
                        setTimeout(
                            function () {
                                this._write("\x04\n", function () {});
                            }.bind(this),
                            50
                        );
                        break;
                    case STAT_END:
                        log.info("Clearing the quit pending state.");
                        this.lines_to_send = 4;
                        this.quit_pending = false;
                        this.pause_flag = false;
                        this.status.inFeedHold = false;
                        break;
                }
            } else {
                // If we move into the holding state, set a flag indicating that we're paused,
                // and pause the cycle context if it exists.
                switch (response.sr.stat) {
                    case STAT_HOLDING:
                        this.pause_flag = true;
                        this.status.resumeFlag = false; // clear for next resume display
                        this.status.inFeedHold = true; // for sensing input-generated-hold
                        if (this.context) {
                            this.context.pause();
                        }
                        break;
                    default:
                        this.pause_flag = false;
                        this.status.inFeedHold = false;
                        this.status.resumeFlag = false;
                        if (this.context) {
                            this.context.resume();
                        }
                        break;
                }
            }

            // this.expectations is a list of "expected states" and callbacks.
            // Certain function
            if (this.expectations.length > 0) {
                var expectation = this.expectations.pop();
                var stat = states[this.status.stat];
                if (stat in expectation) {
                    if (expectation[stat] === null) {
                        this.expectations.push(expectation);
                    } else {
                        expectation[stat](this);
                    }
                } else if (null in expectation) {
                    expectation[null](this);
                }
            }
        }

        this.stat = this.status.stat !== undefined ? this.status.stat : this.stat;
        this.hold = this.status.hold !== undefined ? this.status.hold : this.hold;

        // Latch holdComplete when hold reaches 10 (feedhold fully stopped).
        // A subsequent hold:0 from G2 (seen with small arc segments) must not
        // prevent resume from working.
        if (this.status.hold === 10) {
            this.holdComplete = true;
        }

        if (this.context) {
            this.context.emit("status", this.status);
        }

        // Emit status no matter what
        if ("stat" in response.sr) {
            this.emit("stat", response.sr.stat);
            if (this.context) {
                this.context.emit("stat", response.sr.stat);
            }
        }

        this.emit("status", this.status); // ##==> Primary low level 'g2.status' update; communicated to 'machine.status'

        //If an input induced feedhold is received during a resume then adjust so that
        // another resume can be received and feedhold can be properly reestablished.
        if (this.hold > 0 && this.resumePending) {
            //Set resumeFlag to false so that resume/quit will display in the UI
            this.status.resumeFlag = false;
            this.resumePending = false;
            this.pause_flag = true;
        }
    }
};

// Called once a proper JSON response is decoded from the chunks of data that come back from G2
G2.prototype.onMessage = function (response) {
    // TODO more elegant way of dealing with "response" data.

    if (response.r) {
        if (!this._seen_ready) {
            // Special message type for initial system ready message
            if (response.r.msg && response.r.msg === "SYSTEM READY") {
                this.emit("ready", this);
                return;
            }
        }
        if (this._ignored_responses > 0) {
            this._ignored_responses--;
        } else {
            this.lines_to_send += 1;
            this.sendMore();
        }
        var r = response.r;
        this.emit("response", false, response.r);
    } else {
        r = response;
    }

    // Notifications from the firmware velocity-jog cycle. The firmware emits
    // a top-level (not response-wrapped) {"jgv":0} message when CYCLE_JGV has
    // finished ramping to zero and exited. Hosts that called jogVelocity()
    // listen for "jogv_exit" to know when stop_pending can be cleared and
    // new motion can start.
    if (response.jgv === 0) {
        this.emit("jogv_exit");
    }

    // Deal with G2 status (top priority)
    this.handleStatusReport(r);

    // Deal with exceptions
    this.handleExceptionReport(r);

    // Deal with footer
    var err = this.handleFooter(response);

    // Emitted everytime a message is received, regardless of content
    this.emit("message", response);

    for (var key in r) {
        if (key in this.readers) {
            if (typeof this.readers[key][this.readers[key].length - 1] === "function") {
                var callback = this.readers[key].shift();
                if (err) {
                    callback(err);
                } else {
                    callback(null, r[key]);
                }
            }
        }
    }
};

// Handling normal and raw now the same
// eslint flags callback as unused, gets used in driver.js
// eslint-disable-next-line no-unused-vars
G2.prototype.manualFeedHold = function (callback) {
    this.pause_flag = true;
    log.debug("Processing manualFeedHold");
};

G2.prototype.manualResume = function () {
    this.status.resumeFlag = true;
    this.status.inFeedHold = false; // Clear stale feedhold flag to prevent re-pause before stat update arrives
    this.resumePending = true;
    log.debug("Processing manualResume");
};

// "pause" the current machining cycle by issuing a feedhold
// callback is called when the next state change takes place
G2.prototype.feedHold = function (callback) {
    // Block feedholds during probe completion
    if (this.probeCompleting) {
        log.warn("Feedhold blocked - probe completing");
        if (callback) callback(new Error("Feedhold blocked during probe completion"));
        return;
    }
    
    this.pause_flag = true;
    this.flooded = false;
    this.holdComplete = false; // clear latch at start of new feedhold
    typeof callback === "function" && this.once("state", callback);
    log.debug("Sending a feedhold");
    if (this.context) {
        this.context.pause();
    }
    this._write("!\n");
};

// Clears the queue, this means both the queue of g-codes in the engine to send,
// and whatever gcodes have been received but not yet executed in the g2 firmware context
G2.prototype.queueFlush = function (callback) {
    log.debug("Sending FabMo Queue Clear");
    this.flushcallback = callback;
    this.lines_to_send = 4;
    this.gcode_queue.clear(); // clear FabMo
    this._write("%\n"); // clear G2, though redundant in case of quitting a file
};

// Bring the system out of feedhold
// Like the quit() function below, to issue another resume while the first one is pending can
// make the system crashy - so we're careful not to do that.
// This function returns a promise that resolves when the machining cycle has resumed.
G2.prototype.resume = function () { 

    if (this.holdComplete || this.status.hold === 10) { // don't handle resume request until stopped in hold
        this.holdComplete = false; // clear the latch now that we are processing resume
        this.status.resumeFlag = true;
        this.status.hold = 0; // reset hold for next resume display, to be applied by g2core
        var thisPromise = _promiseCounter;
        if (this.resumePending) { // don't double-resume
            return;
        }
        log.info("Creating promise from resume " + thisPromise);
        _promiseCounter += 1;
        this.resumePending = true;
        var that = this;
        var promise = new Promise(function(resolve, reject) {
            var onStat = function (stat) {
                if (stat !== STAT_RUNNING) {
                    if (this.quit_pending && stat === STAT_HOLDING) {
                        return;
                    }
                    that.removeListener("stat", onStat);
                    //            log.info("Resolving promise (resume): " + thisPromise);
                    this.resumePending = false;
                    resolve(stat);
                }
            };

            that.on("stat", onStat);
        });
        this._write("~"); //cycle start command character

        if (this.context) {
            this.context.resume();
        }

        this.pause_flag = false;

        return promise;
    };  

};

// Quit means to stop the tool and abandon the machining cycle.
G2.prototype.quit = function () {
    if (this.quit_pending) {
        log.warn("Not quitting because a quit is already pending.");
        return;
    }
    this.quit_pending = true;
    if (this.stream) {
        this.stream.end();
    }
    // Issue kill and clear queues.
    this._write("\x04\n");
    this.queueFlush(function () {
        //Finally clear context and _reset primed flag so we're not reliant on getting a stat 4 to clear the context.
        this.context = null;
        this._primed = false;
    });
};

// When the gcode runtime asks that an M30 be sent, send it. This is pulled out from the
//  normal queuing and writing path because of a timing issue with the g2core that needs to be
//  resolved. Right now, when the g2core runs out of gcode in the buffer, it seems like it
//  goes to stat:3. However, if the last line of gcode was M30, it seems to either ignore it,
//  or consider it satisfied by stat:3. (maybe there is some time required to get to stat:3 from stat:5?
//  In any case, by sending the M30 after we receive the stat:3 status change update, we ensure
//  that the M30 is processed and that the g2core goes to stat:4 so that we end our current CycleContext
//  and can start a new one.
G2.prototype.sendM30 = function () {
    if (this.quit_pending) {
        log.warn("Not quitting because a quit is already pending.");
        return;
    }

    this.quit_pending = true;

    if (this.stream) {
        this.stream.end();
    }
    // Clear the gcodes we have queued up
    this.gcode_queue.clear();
    // Issue the M30
    this._write("M30\n");
};

// get the specified configuration value from g2.
// key can be an array of keys as well, in which case an object will be returned mapping keys to values
// This function is expected to not take too long, even if we're busy running a file, so a timeout is implemented.
G2.prototype.get = function (key, callback) {
    // Deal with possible array-ness of this
    // TODO - This sort of thing is pretty ugly - we should probably break this out into a get
    //        and a getMany or something like that.
    var keys;
    if (key instanceof Array) {
        keys = key;
        var is_array = true;
    } else {
        is_array = false;
        keys = [key];
    }

    // For each key
    async.map(
        keys,
        // Function called for each item in the keys array
        function (k, cb) {
            cb = cb.bind(this);
            var cmd = {};
            cmd[k] = null;

            // this.readers contains the key values that we're expecting to read back, and maps them
            // to the callbacks that are called once the values are retrieved
            if (k in this.readers) {
                this.readers[k].push(cb);
            } else {
                this.readers[k] = [cb];
            }

            // Ensure that an error callback is called if the data isn't read out
            setTimeout(
                function () {
                    if (k in this.readers) {
                        var callbacks = this.readers[k];
                        var stored_cb = callbacks[callbacks.length - 1];
                        // TODO - using the right equals here?
                        if (cb == stored_cb) {
                            if (typeof cb == "function") {
                                this.readers[k].shift();
                                cb(new Error("Timeout"), null);
                            }
                        }
                    }
                }.bind(this),
                CMD_TIMEOUT
            );

            // Actually issue the read to the controller, now that the response
            // handling is all set up correctly
            this.command(cmd);
        }.bind(this),

        // Function to call with the list of results
        function (err, result) {
            if (err) {
                return callback(err, result);
            } else {
                // If given an array, return one.  Else, return a single item.
                if (is_array) {
                    return callback(err, result);
                } else {
                    return callback(err, result[0]);
                }
            }
        }
    );
};

// Set configuration keys to values provided in the supplied object
// callback is called with an object that represents the actual values set
// For example:
// for obj = {'2su' : 400.18625 } : if, because of the internal resolution of that value,
// only 400.2 is achievable the callback will be called with {'2su' : 400.18625}
G2.prototype.setMany = function (obj, callback) {
    var keys = Object.keys(obj);
    async.map(
        keys,
        // Function called for each item in the keys array
        function (k, cb) {
            var cmd = {};
            cmd[k] = obj[k];
            if (k in this.readers) {
                this.readers[k].push(cb.bind(this));
            } else {
                this.readers[k] = [cb.bind(this)];
            }
            this.command(cmd);
        }.bind(this),

        // Function to call with the list of results
        function (err, result) {
            if (err) {
                return callback(err, result);
            } else {
                var retval = {};
                try {
                    for (var i = 0; i < keys.length; i++) {
                        retval[keys[i]] = result[i];
                    }
                } catch (e) {
                    callback(e, null);
                }
                return callback(null, retval);
            }
        }
    );
};

// Set works just like setMany above, but for a single value only
// TODO: This is just a specific version of above, rewrite this to call the above function!
G2.prototype.set = function (key, value, callback) {
    if (value === undefined) {
        return callback(new Error("Undefined value passed to G2"));
    }
    var cmd = {};
    cmd[key] = value;
    if (key in this.readers) {
        this.readers[key].push(callback);
    } else {
        this.readers[key] = [callback];
    }

    // Ensure that an errback is called if the data isn't read out
    setTimeout(
        function () {
            if (key in this.readers) {
                var callbacks = this.readers[key];
                var stored_cb = callbacks[callbacks.length - 1];
                if (callback == stored_cb) {
                    if (typeof callback == "function") {
                        this.readers[key].shift();
                        callback(new Error("Timeout"), null);
                    }
                }
            }
        }.bind(this),
        CMD_TIMEOUT
    );

    this.command(cmd);
};

// Send a command to G2 (can be string or JSON); set then triggers the sendMore function
////** ... see note on change below; may create problems for other commands and where they are inserted
G2.prototype.command = function (obj) {
    var cmd;
    if (typeof obj == "string") {
        cmd = obj.trim();
        this.command_queue.enqueue(cmd); ////** changed this (from gcode_queue) to support 'fro' injection
    } else {
        // G2 supports a "truncated" format that allows for more compact JSON
        cmd = JSON.stringify(obj);
        cmd = cmd.replace(/(:\s*)(true)(\s*[},])/g, "$1t$3");
        cmd = cmd.replace(/(:\s*)(false)(\s*[},])/g, "$1f$3");
        this.command_queue.enqueue(cmd);
    }
    this.sendMore();
};

// Velocity-mode jog (CYCLE_JGV in firmware ≥ this build).
// Sends per-axis target velocities directly to G2's velocity-jog cycle.
//
//   vec  - object mapping axis letter ("x","y","z","a","b","c") to a signed
//          velocity in *current g2 display units / min* (in/min if G20,
//          mm/min if G21). Missing axes retain their previous v_target.
//
// The firmware enters the cycle on the first nonzero velocity and stays in
// it until all targets are zero AND motion drains, or the host stops sending
// updates (firmware watchdog, default 500 ms). Hosts driving analog inputs
// should refresh at least every ~200 ms.
G2.prototype.jogVelocity = function (vec) {
    if (!vec || typeof vec !== "object") {
        return;
    }
    var payload = {};
    var axes = ["x", "y", "z", "a", "b", "c"];
    for (var i = 0; i < axes.length; i++) {
        var ax = axes[i];
        if (vec[ax] === undefined || vec[ax] === null) continue;
        payload["jgv" + ax] = Number(vec[ax]);
    }
    if (Object.keys(payload).length === 0) {
        return;
    }
    this.command(payload);
};

// Ramp all axes to zero — this lets the firmware cycle decelerate and exit
// cleanly. The cycle exits when motion has drained; callers that need to know
// when that happens should listen for the {"jgv":0} notification on the
// "response" stream.
G2.prototype.jogStop = function () {
    this.command({ jgvx: 0, jgvy: 0, jgvz: 0, jgva: 0, jgvb: 0, jgvc: 0 });
};

// Return a promise that resolves when one of the provided states is encountered
// states - a list of states which will cause the promise to resolve
// The promise resolves with the state that caused the resolution as an argument
G2.prototype._createStatePromise = function (states) {
    // Track the promise created (debug)
    var thisPromise = _promiseCounter;
    log.info("Creating promise from start " + thisPromise);
    _promiseCounter += 1;
    var that = this;
    return new Promise(function(resolve, reject) {
        var onStat = function (stat) {
            for (var i = 0; i < states.length; i++) {
                if (stat === states[i] && !this.manual_hold && !this.pause_hold) {
                    that.removeListener("stat", onStat);
                    log.info(
                        "Resolving promise " + thisPromise + " because of state " + stat + " which is one of " + states
                    );
                    resolve(stat);
                }
            }
        };
        that.on("stat", onStat);
    });
};

// Wait for a state or states (as reported in the status report 'stat' member)
// See _createStatePromise for more information
// states - either a single state or list of states
G2.prototype.waitForState = function (states) {
    if (!states.length) {
        states = [states];
    }
    return this._createStatePromise(states);
};

// Run data from a stream, rather than a string or a list
// This allows us to run huge files from disk, or say, http, or from
// a stream processor that is streaming from one of those sources without
// having to load the entire file into memory.
G2.prototype.runStream = function (s, manualPrime = false) {
    this._createCycleContext();
    if (manualPrime) {
        this.prime();
    }
    s.pipe(this.context._stream);
    return this.context;
};

// G2 begins running G-Codes as soon as it recieves them, and in certain cases, it is possible for
// G2 to "plan to a stop" when this is not the desired behavior.  This typically happens at the start of
// of a run, when the host has only sent a few moves down, and G2's planner outpaces the moves coming in.
// To resolve this, this module provides a "priming" behavior that will prevent it from sending any g-codes
// to G2 until it is "primed" with enough of them so that it's not going to starve the planner after it starts
// sending.  The difficulty with this is, if the prime threshold is 10 g-codes, and the host wants to send a
// file that is only 5 g-codes long, the system will never be primed, and no g-codes are sent.  The prime()
// function then, is provided for cases where we know we're not sending anymore g-codes, and we want G2
// to just run whatever we've sent so far.
G2.prototype.prime = function () {
    log.info("Priming driver (manually)");
    this._primed = true;
    this.sendMore();
};

// // TODO - This was mostly an informational thing that should no longer be needed
// G2.prototype.getInfo = function () {
//     return (
//         "G2: primed:" +
//         (this._primed ? "1" : "0") +
//         " l2s:" +
//         this.lines_to_send +
//         " gcq:" +
//         this.gcode_queue.getLength()
//     );
// };

// This function is called internally when it's time to send more g-codes or commands from the queue.
// This implements the so-called "linemode" protocol (see G2 source documentation for more info)
// https://github.com/synthetos/g2/wiki/g2core-Communications
G2.prototype.sendMore = function () {
    // Don't send anything if we're disconnected
    if (!this.connected) {
        return;
    }
    // Don't ever send anything if we're paused
    if (this.pause_flag) {
        //log.debug("====> sendMore() blocked by pause_flag, command_queue length: " + this.command_queue.getLength());
        return;
    }

    // "commands" (JSON messages) preempt g-codes.  Send these first, regardless of whether or not we're primed.
    // ... Feedrate overrides come in here, and are sent as commands.
    var count = this.command_queue.getLength();
    if (count) {
        //log.debug("====> sendMore() sending " + count + " commands");
        var to_send = count;
        var codes = this.command_queue.multiDequeue(count);
        codes.push("");
        this._ignored_responses += to_send;
        this._write(codes.join("\n"), function () {});
    }

    // If we're primed, go ahead and send more g-codes
    if (this._primed) {
        count = this.gcode_queue.getLength();
        if (this.lines_to_send >= THRESH) {
            if (count >= THRESH || this._streamDone) {
                // Send some lines, but no more than we are allowed per linemode protocol
                to_send = Math.min(this.lines_to_send, count);
                codes = this.gcode_queue.multiDequeue(to_send);
                // Ensures that when we join below that we get a \n on the end
                codes.push("");
                if (codes.length > 1) {
                    this.lines_to_send -= to_send /*-offset*/;
                    this._write(codes.join("\n"), function () {});
                }
            }
        }
    } else {
        var queueLength = this.gcode_queue.getLength();
        //console.log("Queue length:", queueLength, "Type:", typeof queueLength);
        //console.log("Queue length > 0:", queueLength > 0);

        if (this.gcode_queue.getLength() > 0) {
            log.debug("Not sending because not primed.");
        }
    }
};

// Set the position of the motion system using the G28.3 code (on start)
// position - An object mapping axes to position values. Axes that are not included will not be updated.
G2.prototype.setMachinePosition = function (position, callback) {
    var axes = ["x", "y", "z", "a", "b", "c"];
    var gcodes = new stream.Readable();
    let mult = this.status.unit === "mm" ? 1 : 1 / 25.4; // Convert saved position from mm to current for restore
    // ** UPDATE INITIAL LOCATION (offsets + values) **
    gcodes.push("G55 \n"); // Set coordinate system to G55 to match FabMo
    axes.forEach(function (axis) {
        // For each axis, if it is in the position object, add a G28.3 command to the stream
        if (position[axis] != undefined) {
            gcodes.push("G28.3 " + axis + (position[axis] * mult).toFixed(5) + "\n");
        }
    });
    gcodes.push(null);
    this.runStream(gcodes, true).then(function () {
        callback && callback();
    });
};

G2.prototype.updateMachinePosition = function () {
    // This is a hack to work around a bug in the g2 firmware that prevents updating the displayed location after a UNITS CHANGE.
    // STRATEGY: Make a small (one step), incremental(G91) move in Z-axis, then reverse in order to FORCE the UPDATE
    log.debug(" G2 HACK to >>> Update Machine Position Display");
    var self = this;
    var d, s;
    this.get("3su", function (err, result) {
        // use unit value to determine Z step size (channel 3)
        if (err) {
            log.error("ERROR: Unable to get 3su value from G2");
            return;
        }
        d = (1.1 / result).toFixed(5); // get 1 step+ in current units
        s = "G91 \nG01 Z" + d + "F100 \nG01 Z-" + d + " \nG90 \nM30";
        self.gcode_queue.enqueue(s);
        self._primed = true;
        self.sendMore();
    });
};

// Function works like "once()" for a state change
// callbacks is an associative array mapping states to callbacks
// If the *next* state change matches a state in the associative array, the callback it maps to is called.
// If null is specified in the array, this callback is used for any state that is unspecified
//
// eg:
// this.expectStateChange {
//                          STAT_END : end_callback,
//                          STAT_PAUSE : pause_callback,
//                          null : other_callback};
//
// In the above example, when the next change of state happens, the appropriate callback is called in the case
// that the new state is either STAT_END or STAT_PAUSE.  If the new state is neither, other_callback is called.
G2.prototype.expectStateChange = function (callbacks) {
    if ("timeout" in callbacks) {
        var fn = callbacks.timeout;
        setTimeout(
            function () {
                if (this.expectations.length > 0) {
                    callbacks = this.expectations[this.expectations.length - 1];
                    if (callbacks.timeout === fn) {
                        log.debug("Calling timeout function");
                        this.expectations.pop();
                        fn(this);
                    }
                }
            }.bind(this),
            EXPECT_TIMEOUT
        );
    }
    this.expectations.push(callbacks);
};

// Name helper for the states - useful for error messages.
var states = {
    0: "init",
    1: "ready",
    2: "alarm",
    3: "stop",
    4: "end",
    5: "running",
    6: "holding",
    7: "probe",
    8: "cycling",
    9: "homing",
    11: "interlock",
    12: "shutdown",
    13: "panic",
};

// export the class
exports.G2 = G2;

// Convenient names for states
exports.STAT_INIT = STAT_INIT;
exports.STAT_READY = STAT_READY;
exports.STAT_ALARM = STAT_ALARM;
exports.STAT_STOP = STAT_STOP;
exports.STAT_END = STAT_END;
exports.STAT_RUNNING = STAT_RUNNING;
exports.STAT_HOLDING = STAT_HOLDING;
exports.STAT_PROBE = STAT_PROBE;
exports.STAT_CYCLING = STAT_CYCLING;
exports.STAT_HOMING = STAT_HOMING;
exports.STAT_INTERLOCK = STAT_INTERLOCK;
exports.STAT_SHUTDOWN = STAT_SHUTDOWN;
exports.STAT_PANIC = STAT_PANIC;

G2.prototype.STAT_INIT = STAT_INIT;
G2.prototype.STAT_READY = STAT_READY;
G2.prototype.STAT_ALARM = STAT_ALARM;
G2.prototype.STAT_STOP = STAT_STOP;
G2.prototype.STAT_END = STAT_END;
G2.prototype.STAT_RUNNING = STAT_RUNNING;
G2.prototype.STAT_HOLDING = STAT_HOLDING;
G2.prototype.STAT_PROBE = STAT_PROBE;
G2.prototype.STAT_CYCLING = STAT_CYCLING;
G2.prototype.STAT_HOMING = STAT_HOMING;
G2.prototype.STAT_INTERLOCK = STAT_INTERLOCK;
G2.prototype.STAT_SHUTDOWN = STAT_SHUTDOWN;
G2.prototype.STAT_PANIC = STAT_PANIC;