Configuration.js

import { logger } from "./logger.js";

export class ConfigurationObject {
  constructor({
    ledOn = true,
    ledFlash = true,
    controllerFlip = false,
    midiThru = false,
    deviceId = 0,
    i2cMaster = false,
    fadermin = 0,
    fadermax = 8192,
    firmwareVersion = "unknown",
    usbControls = [],
    trsControls = [],
  }) {
    this.ledOn = ledOn;
    this.ledFlash = ledFlash;
    this.controllerFlip = controllerFlip;
    this.midiThru = midiThru;
    this.deviceId = deviceId;
    this.firmwareVersion = firmwareVersion;
    this.i2cMaster = i2cMaster;
    this.fadermin = fadermin;
    this.fadermax = fadermax;
    this.usbControls = usbControls;
    this.trsControls = trsControls;
  }

  isEquivalent(otherConfig) {
    let optionEquivalents =
      this.ledOn == otherConfig.ledOn &&
      this.ledFlash == otherConfig.ledFlash &&
      this.controllerFlip == otherConfig.controllerFlip &&
      this.midiThru == otherConfig.midiThru;

    if ("i2cMaster" in this || "i2cMaster" in otherConfig) {
      optionEquivalents =
        optionEquivalents && this.i2cMaster == otherConfig.i2cMaster;
    }

    if ("fadermax" in this || "fadermax" in otherConfig) {
      optionEquivalents =
        optionEquivalents &&
        this.fadermax == otherConfig.fadermax &&
        this.fadermin == otherConfig.fadermin;
    }

    let usbEquivalent = true;
    let trsEquivalent = true;

    this.usbControls.forEach((control, i) => {
      let otherControl = otherConfig.usbControls[i];
      if (
        control.channel != otherControl.channel ||
        control.cc != otherControl.cc
      ) {
        usbEquivalent = false;
      }
    });

    this.trsControls.forEach((control, i) => {
      let otherControl = otherConfig.trsControls[i];
      if (
        control.channel != otherControl.channel ||
        control.cc != otherControl.cc
      ) {
        usbEquivalent = false;
      }
    });

    return optionEquivalents && usbEquivalent && trsEquivalent;
  }

  toSysexArray() {
    let array = Array.from({ length: 84 }, (v) => 0);

    array[0] = this.deviceId;
    array[1] = this.firmwareArray()[0];
    array[2] = this.firmwareArray()[1];
    array[3] = this.firmwareArray()[2];

    array[4] = this.ledOn ? 1 : 0;
    array[5] = this.ledFlash ? 1 : 0;
    array[6] = this.controllerFlip ? 1 : 0;

    array[7] = this.i2cMaster;

    let faderminMSB = this.fadermin >> 7;
    let faderminLSB = this.fadermin - (faderminMSB << 7);
    array[8] = faderminLSB;
    array[9] = faderminMSB;
    let fadermaxMSB = this.fadermax >> 7;
    let fadermaxLSB = this.fadermax - (fadermaxMSB << 7);
    array[10] = fadermaxLSB;
    array[11] = fadermaxMSB;

    array[12] = this.midiThru ? 1 : 0;

    let usbChannelOffset = 20;
    let trsChannelOffset = 36;
    let usbControlOffset = 52;
    let trsControlOffset = 68;

    this.usbControls.forEach((control, index) => {
      array[index + usbChannelOffset] = control.channel;
      array[index + usbControlOffset] = control.cc;
    });
    this.trsControls.forEach((control, index) => {
      array[index + trsChannelOffset] = control.channel;
      array[index + trsControlOffset] = control.cc;
    });

    return array;
  }

  toDeviceOptionsSysexArray() {
    const fullArray = this.toSysexArray();
    return fullArray.slice(4, 20);
  }

  toUSBOptionsSysexArray() {
    const fullArray = this.toSysexArray();
    const channels = fullArray.slice(20, 36);
    const ccs = fullArray.slice(52, 68);
    return channels.concat(ccs);
  }

  toTRSOptionsSysexArray() {
    const fullArray = this.toSysexArray();
    const channels = fullArray.slice(36, 52);
    const ccs = fullArray.slice(68, 84);
    return channels.concat(ccs);
  }

  toJsonString() {
    let o = ConfigurationObject.clone(this);
    // truncate all controllers to length $length;
    let controllerCount = this.device().controlCount;

    o.usbControls = o.usbControls.splice(0, controllerCount);
    o.usbControls.forEach((c) => delete c.val);

    o.trsControls = o.trsControls.splice(0, controllerCount);

    return JSON.stringify(o, false, 2);
  }

  isNewConfigInvalid(json) {
    if (json.deviceId != this.deviceId) {
      return `Cannot update - this data file is for a ${
        ConfigurationObject.devices[json.deviceId].name
      }, but you are trying to install it on a ${this.device().name} `;
    }

    // if(json.firmwareVersion != this.firmwareVersion) {
    //   return(`Cannot update - this data file is for firmware version ${json.firmwareVersion}, but you are trying to install it on a device running firmware version ${this.firmwareVersion}`);
    // }

    return false;
  }

  updateFromJson(json) {
    Object.keys(json).forEach((key) => {
      this[key] = json[key];
    });

    return this;
  }

  device() {
    return ConfigurationObject.devices[this.deviceId];
  }

  firmwareArray() {
    let arr = this.firmwareVersion.trim().split(".");
    return arr.map((n) => parseInt(n));
  }

  static clone(obj) {
    let newObj = new ConfigurationObject({
      ledOn: obj.ledOn,
      ledFlash: obj.ledFlash,
      controllerFlip: obj.controllerFlip,
      midiThru: obj.midiThru,
      usbControls: [],
      trsControls: [],
      deviceId: obj.deviceId,
      firmwareVersion: obj.firmwareVersion,
      i2cMaster: obj.i2cMaster,
      fadermin: obj.fadermin,
      fadermax: obj.fadermax,
    });

    obj.usbControls.forEach((control, i) => {
      newObj.usbControls[i] = { ...control };
    });
    obj.trsControls.forEach((control, i) => {
      newObj.trsControls[i] = { ...control };
    });

    return newObj;
  }

  static returnConfigHashFromSysex(data) {
    logger("Generating config from", data);
    let offset = 8;

    let deviceId = data[5];
    let firmwareVersion = data[6] + "." + data[7] + "." + data[8];

    let ledOn = data[1 + offset];
    let ledFlash = data[2 + offset];
    let controllerFlip = data[3 + offset];

    let i2cMaster = data[4 + offset] == 1;

    let faderminLSB = data[5 + offset];
    let faderminMSB = data[6 + offset];
    let fadermin = (faderminMSB << 7) + faderminLSB;

    let fadermaxLSB = data[7 + offset];
    let fadermaxMSB = data[8 + offset];
    let fadermax = (fadermaxMSB << 7) + fadermaxLSB;

    let midiThru = data[9 + offset];

    let usbControls = [];
    let trsControls = [];

    data.slice(17 + offset, 33 + offset).forEach((chan, i) => {
      if (chan != 0x7f) {
        usbControls[i] = {
          channel: chan,
        };
      }
    });

    data.slice(33 + offset, 49 + offset).forEach((chan, i) => {
      if (chan != 0x7f) {
        trsControls[i] = {
          channel: chan,
        };
      }
    });

    data.slice(49 + offset, 65 + offset).forEach((cc, i) => {
      if (cc != 0x7f) {
        usbControls[i].cc = cc;
      }
    });

    data.slice(65 + offset, 81 + offset).forEach((cc, i) => {
      if (cc != 0x7f) {
        trsControls[i].cc = cc;
      }
    });

    usbControls.forEach((c) => (c.val = 0));

    return new ConfigurationObject({
      ledOn,
      ledFlash,
      controllerFlip,
      midiThru,
      usbControls,
      trsControls,
      deviceId,
      firmwareVersion,
      i2cMaster,
      fadermin,
      fadermax,
    });
  }
}

ConfigurationObject.devices = [
  {
    name: "unknown",
    controlCount: 0,
    capabilities: {},
  },
  {
    name: "Oxion development board",
    controlCount: 4,
    capabilities: {
      led: true,
    },
  },
  {
    name: "16n",
    controlCount: 16,
    capabilities: {
      i2c: true,
      led: true,
    },
  },
  {
    name: "16n (LC)",
    controlCount: 16,
    capabilities: {
      i2c: true,
      led: true,
    },
    sendShortMessages: true,
  },
];