spindle1.js

// turn off prettier for this file
/* eslint-disable */
// spindle1.js
const EventEmitter = require('events').EventEmitter;
const util = require("util");
const ModbusRTU = require("modbus-serial");
const client = new ModbusRTU();
const fs = require("fs");
const log = require("./log").logger("spindleVFD");

// At this time only using the Modbus-Serial library for VFD control of RPM and reading registers and status
// RUN/STOP is still implemented as and OUPUT 1 from FabMo to RUN input on VFD (Delta = M1); FWD/REV is optional,
// ... also to be implemented as OUTPUT#? (Delta=M0) [see Lenze notes for info on that VFD]
// Only Spin is implemented for spindle1'spindleVFD1; spindleVFD2 is a placeholder for future expansion

// Constructor for Spin
function Spin() {
    EventEmitter.call(this);
    this.status = {
        vfdEnabled: true,
        vfdDesgFreq: 0,
        vfdAchvFreq: 0,
        vfdAmps: 0
    };
    this.vfdSettings = {};
    this.vfdBusy = false;
    this.laststatus = {};
    this.unlockRequired = false;
}

// Inherit from EventEmitter
util.inherits(Spin, EventEmitter);

// Load settings for a VFD
Spin.prototype.loadVFDSettings = function() {
    const configFile = "./spindles/spindle1_settings.json";
    return new Promise((resolve, reject) => {
        fs.readFile(configFile, "utf8", (err, data) => {
            if (err) {
                this.disableSpindle(`Settings file error: ${err.message}`, true);
                reject(err);
            } else {
                try {
                    this.settings = JSON.parse(data);
                    log.info("VFD Settings loaded from settings file:", this.settings.VFD_Settings);
                    resolve();
                } catch (parseErr) {
                    this.disableSpindle(`Settings file parse error: ${parseErr.message}`, true);
                    reject(parseErr);
                }
            }
        });
    });
};

// Connect to a VFD
Spin.prototype.connectVFD = function() {
    return new Promise((resolve, reject) => {
        const settings = this.settings.VFD_Settings;
        this.vfdSettings = settings;

        // Use a timeout for initial connection
        const connectionTimeout = setTimeout(() => {
            this.disableSpindle('Connection timeout - no VFD detected', true);
            reject(new Error('Connection timeout'));
        }, 3000); // 3 second timeout for initial connection

        client.connectRTUBuffered(settings.COM_PORT, {
            baudRate: settings.BAUDRATE,
            parity: settings.PARITY,
            dataBits: settings.BYTESIZE,
            stopBits: settings.STOPBITS
        })
        .then(() => {
            clearTimeout(connectionTimeout);
            client.setID(settings.MB_ADDRESS);
            log.info("Connected to VFD via MODBUS");
            if (settings.Registers.UNLOCK_PARAMETERS !== null) {
                this.unlockRequired = true;
            }
            log.info("Unlock required: " + this.unlockRequired);
            this.startSpindleVFD();
            resolve();
        })
        .catch((error) => {
            clearTimeout(connectionTimeout);
            this.disableSpindle(`Connection failed: ${error.message}`, true);
            reject(error);
        });
    });
};

let vfdFailures = 0;
let vfdDisabled = false;
// Set up 1-second UPDATES to spindleVFD status 
Spin.prototype.startSpindleVFD = function() {
    const settings = this.settings.VFD_Settings;
    const MAX_VFD_FAILS = 10;  
    // Reset the disabled flag when starting
    vfdDisabled = false;
    vfdFailures = 0;
    
    // Store intervalId as instance property so it can be cleared properly
    if (this.vfdInterval) {
        clearInterval(this.vfdInterval);
    }

    if (this.status.vfdEnabled) {
        this.vfdInterval = setInterval(() => {
            // Check if already disabled - stop immediately
            if (vfdDisabled || !this.status.vfdEnabled || this.status.vfdDesgFreq === -1) {
                clearInterval(this.vfdInterval);
                this.vfdInterval = null;
                return;
            }
            
            if (this.vfdBusy) {
                log.error("VFD is busy; skipping update");
                // this.vfdBusy = false // removed for Yaskawa workflow
                return;
            }
            
            Promise.race([
                readVFD(settings.Registers.TRIG_READ_FREQ, settings.READ_LENGTH),
                new Promise((_, reject) => setTimeout(() => reject(new Error("VFD not responding > USB?")), 5000))
            ])
            .then((data) => {
                // Success - process data
                // Offsets are computed from config addresses so the register layout is config-driven
                // data[0] is always TRIG_READ_FREQ (commanded/designated frequency)
                var achvOffset = settings.Registers.READ_ATTAINED_FREQUENCY - settings.Registers.TRIG_READ_FREQ;
                var ampsOffset = settings.Registers.READ_OUTPUT_CURRENT - settings.Registers.TRIG_READ_FREQ;

                this.status.vfdDesgFreq = data[0] * settings.Registers.RPM_MULT;
                this.status.vfdAchvFreq = data[achvOffset] * settings.Registers.RPM_MULT;

                var vCur = settings.Registers.READ_AMPS_HI === true ? ((data[ampsOffset] >> 8) & 0xFF) : data[ampsOffset];
                vCur = vCur * settings.Registers.AMP_MULT;
                this.status.vfdAmps = vCur;
                
                this.updateStatus(this.status);
                vfdFailures = 0; // Reset failure count on success
            })
            .catch((error) => {
                // Ignore errors if we've already disabled
                if (vfdDisabled) {
                    return;
                }
                
                // Handle errors here where 'error' is actually defined
                vfdFailures++;
                log.error(`***Error reading VFD: ${error.message}`);
                
                if (vfdFailures >= MAX_VFD_FAILS) {
                    vfdDisabled = true; // Set flag immediately
                    log.error(`Last Error (of ${MAX_VFD_FAILS}): ${error.message}`);
                    
                    // Handle specific error types
                    if (error.message.includes("Illegal data address")) {
                        this.disableSpindle(`Invalid VFD register configuration: ${error.message}`);
                    } else {
                        this.disableSpindle(`Too many communication errors (${MAX_VFD_FAILS}): ${error.message}`);
                    }
                    
                    // Clear the interval using instance property
                    clearInterval(this.vfdInterval);
                    this.vfdInterval = null;
                }
            });
        }, 1000);
    }
};

// Method to update VFD status Globally via "machine"
Spin.prototype.updateStatus = function(newStatus) {
    // for the change-check here, probably most efficient to just do this manual comparison
    if (this.laststatus.vfdDesgFreq !== newStatus.vfdDesgFreq || 
        this.laststatus.vfdAchvFreq !== newStatus.vfdAchvFreq ||
        this.laststatus.vfdAmps !== newStatus.vfdAmps) {
        this.status = Object.assign({}, this.status, newStatus);
        this.emit('statusChanged', this.status); // Emit status change to trigger event on machine
        // log.info("VFD Status Changed: " + JSON.stringify(this.status));
        this.laststatus = {...this.status};
    }
};

Spin.prototype.disableSpindle = function(reason, isInitialFailure = false) {
    if (this.status.vfdEnabled === false && this.status.vfdDesgFreq === -1) {
        // Already disabled, don't spam logs
        return;
    }
    
    this.status.vfdEnabled = false;
    this.status.vfdDesgFreq = -1;
    this.status.vfdAchvFreq = 0;
    this.status.vfdAmps = 0;
    
    // Clear any running interval
    if (this.vfdInterval) {
        clearInterval(this.vfdInterval);
        this.vfdInterval = null;
    }
    
    // Single, clean disable message
    if (isInitialFailure) {
        log.warn(`Spindle/VFD initialization failed: ${reason}`);
        log.info("Spindle RPM control disabled for this session.");
    } else {
        log.warn(`Spindle/VFD connection lost: ${reason}`);
        log.info("Spindle RPM control disabled due to communication errors.");
    }
    
    this.updateStatus(this.status);
};

// Set to true to enable post-write register survey (for debugging only; disable for production)
const VFD_SURVEY_ENABLED = false;

// Registers to survey -- edit this list to add/remove registers of interest
const VFD_SURVEY_REGS = [
    { reg: 2,  label: "Frequency Reference (written value)" },
    //{ reg: 3,  label: "Min Frequency Clamp" },
    //{ reg: 16, label: "U1-01 mirror / internal ref?" },
    //{ reg: 17, label: "internal ref B?" },
    { reg: 32, label: "Status A" },
    { reg: 35, label: "Freq Ref echo" },
    { reg: 36, label: "Output Frequency (attained)" },
    { reg: 37, label: "Output Voltage" },
    { reg: 38, label: "Output Current" },
    //{ reg: 43, label: "Input Status" },
    { reg: 44, label: "Status B" },
    //{ reg: 45, label: "Output Status" },
    //{ reg: 49, label: "DC Bus Voltage" },
];

let surveyScanPending = false;

// Targeted register survey - reads only the registers listed in VFD_SURVEY_REGS
Spin.prototype.surveyRegisters = function() {
    log.info(`=== VFD SURVEY SCAN (${VFD_SURVEY_REGS.length} registers) ===`);
    
    var results = [];
    var chain = Promise.resolve();
    
    VFD_SURVEY_REGS.forEach(function(entry) {
        chain = chain.then(() => {
            return readVFD(entry.reg, 1)
                .then((data) => {
                    var val = data[0];
                    log.info(`  reg[${entry.reg}] (0x${entry.reg.toString(16).padStart(4,'0')}) = ${val} (0x${val.toString(16).padStart(4,'0')})  -- ${entry.label}`);
                    results.push({ reg: entry.reg, val: val, label: entry.label });
                })
                .catch((err) => {
                    log.info(`  reg[${entry.reg}] = READ ERROR: ${err.message}  -- ${entry.label}`);
                    results.push({ reg: entry.reg, val: null, label: entry.label, err: err.message });
                });
        });
    });
    
    return chain.then(() => {
        log.info(`=== VFD SURVEY COMPLETE ===`);
        var nonZero = results.filter(r => r.val !== null && r.val !== 0);
        log.info(`  Non-zero: ${nonZero.map(r => `[${r.reg}]=${r.val}`).join(', ')}`);
        return results;
    });
};




Spin.prototype.setSpindleVFDFreq = function(data) {
    this.vfdBusy = true;
    return new Promise((resolve, reject) => {
        const unlockAndSetFrequency = () => {
            // Unlock VFD first, if required
            if (this.unlockRequired) {
                return writeVFD(this.vfdSettings.Registers.UNLOCK_PARAMETERS, this.vfdSettings.Registers.PASSWORD)
                    .then(() => {
                        log.info("VFD Unlocked");
                        // Once unlocked, proceed to set frequency
                        return this.setFrequency(data);
                    });
            } else {
                // If no unlock needed, go straight to setting frequency
                return this.setFrequency(data);
            }
        };

        unlockAndSetFrequency()
            .then(result => {
                this.vfdBusy = false;
                resolve(result);
            })
            .catch(error => {
                log.error("Error in setting frequency: ", error);
                this.vfdBusy = false;
                // Lets just log and continue for the moment
                resolve (null);
                //reject(error);
            });
    });
};


// with debugs
Spin.prototype.setFrequency = function(data) {
    var vfd_req = Math.round(data / this.vfdSettings.Registers.RPM_MULT);
    var useMultiple = (this.vfdSettings.Modbus_Function_Codes.WRITE_SINGLE_REGISTER === 16 || 
                       this.vfdSettings.Modbus_Function_Codes.WRITE_SINGLE_REGISTER === 0x10);
    
    log.info(`VFD setFrequency called: input=${data} RPM, RPM_MULT=${this.vfdSettings.Registers.RPM_MULT}, calculated_reg_value=${vfd_req}, FC16=${useMultiple}`);
    log.info(`VFD write target: reg=${this.vfdSettings.Registers.SET_FREQUENCY} (hex: 0x${this.vfdSettings.Registers.SET_FREQUENCY.toString(16)})`);

    // *** Schedule the full survey scan 1 second after this write ***
    if (VFD_SURVEY_ENABLED && !surveyScanPending) {
        surveyScanPending = true;
        setTimeout(() => {
            var waitCount = 0;
            var waitForIdle = setInterval(() => {
                waitCount++;
                if (!this.vfdBusy || waitCount >= 10) {
                    clearInterval(waitForIdle);
                    if (this.vfdBusy) {
                        log.info('=== VFD SURVEY: timed out waiting for idle, running anyway ===');
                    }
                    this.vfdBusy = true;
                    this.surveyRegisters()
                        .then(() => {
                            this.vfdBusy = false;
                            surveyScanPending = false;
                        })
                        .catch((err) => {
                            log.error(`Survey scan failed: ${err.message}`);
                            this.vfdBusy = false;
                            surveyScanPending = false;
                        });
                }
            }, 100);
        }, 1000);
    }

    // *** This return is critical - setSpindleVFDFreq calls .then() on this result ***
    return writeVFD(this.vfdSettings.Registers.SET_FREQUENCY, vfd_req, useMultiple)
        .then(result => {
            log.info(`VFD write completed, result=${JSON.stringify(result)}`);
            return result;
        });
};



Spin.prototype.debugReadRegisters = function(startReg, length) {
    log.info(`DEBUG: Reading ${length} registers starting at ${startReg} (hex: 0x${startReg.toString(16)})`);
    return readVFD(startReg, length)
        .then((data) => {
            log.info(`DEBUG RAW DATA from reg ${startReg} (len ${length}):`);
            data.forEach((val, idx) => {
                log.info(`  reg[${startReg + idx}] = ${val} (hex: 0x${val.toString(16).padStart(4,'0')})`);
            });
            return data;
        })
        .catch((err) => {
            log.error(`DEBUG read failed at reg ${startReg}: ${err.message}`);
        });
};



// ------------------- Calls to ModbusRTU ------------------
function readVFD(data, length) {
    return new Promise((resolve, reject) => {
        client.readHoldingRegisters(data, length)
            .then((data) => {
                if (data && data.data) {
                    resolve(data.data);
                } else {
                    log.error("***No data returned from VFD");
                    reject(new Error("No data returned from VFD"));
                }
            })
            .catch((error) => {
                // log.error("***Error reading VFD: " + error);
                reject(error);
            });
    });
}

// this funciton should now handle both single and multiple register writes (for V1000) based on the useMultiple flag
function writeVFD(reg, data, useMultiple) {
    return new Promise((resolve, reject) => {
        var writePromise;
        if (useMultiple) {
            // FC16 - Write Multiple Registers (required by Yaskawa V1000)
            writePromise = client.writeRegisters(reg, [data]);
        } else {
            // FC06 - Write Single Register (Delta, Lenze)
            writePromise = client.writeRegister(reg, data);
        }
        writePromise
            .then(() => resolve(data))
            .catch(error => {
                log.error("***Error writing VFD:", error);
                resolve(null);
            });
    });
}

function disconnectVFD() {
    return new Promise((resolve, reject) => {
        client.close()
            .then(() => {
                log.info("Disconnected from VFD");
                resolve();
            })
            .catch((error) => {
                log.error("***Error disconnecting from VFD: " + error);
                reject(error);
            });
    });
}


// Setting up a single instance of Spindle
const singletonInstance = new Spin();

module.exports = singletonInstance;