Vision: events

Complete reference. The signature is a listener argument tuple, not a wrapper object.

vision:wrong-cmd

The device rejected a command format; opcodeName identifies the command.

type Arguments = [
    data: {
      opcodeName: string;
      opcode: number;
      params: string[];
    }
  ];

jsd.on('vision:wrong-cmd', payload => console.log(payload));

vision:machine-status

Machine status snapshot; also updates the local status cache.

type Arguments = [
    data: {
      machine: MachineValid;
      status: MachineStatusName;
      machineInService: boolean;
      doorOpen: boolean;
      availabilityToDispense: MachineAvailableStatus;
      hasLightsOn: boolean;
      temperature: string;
    }
  ];

jsd.on('vision:machine-status', payload => console.log(payload));

vision:channels-progress

Progress of assignChannels(), including current and verified selections.

type Arguments = [
    data: {
      progress: number;
      current: number;
      verified: number;
    }
  ];

jsd.on('vision:channels-progress', payload => console.log(payload));

vision:channels

Complete channel assignment result after all 80 selections are verified.

type Arguments = [data: SelectionStatus[]];

jsd.on('vision:channels', payload => console.log(payload));

vision:channel-status

Whether the channel corresponding to a selection is active.

type Arguments = [
    data: {
      machine: MachineValid;
      selection: OneTo240;
      active: boolean;
    }
  ];

jsd.on('vision:channel-status', payload => console.log(payload));

vision:status-selection

Configuration or association state of a selection.

type Arguments = [
    data: {
      selection: OneTo240;
      status: StatusSelectionName;
    }
  ];

jsd.on('vision:status-selection', payload => console.log(payload));

vision:dispense-status

Token-correlated dispense status, including optional extended failure details.

type Arguments = [
    data: {
      token: DispenseToken;
      status: string;
      machine: MachineValid | null;
      tray: ValidTray | null;
      channel: ValidChannel | null;
      extendedStatus: string | null;
    }
  ];

jsd.on('vision:dispense-status', payload => console.log(payload));

vision:selection-dispense-config

Speed and post-run configuration returned for a selection.

type Arguments = [
    data: {
      selection: OneTo240;
      speed: SpeedOption;
      timePostRun: TimePostRunOption;
    }
  ];

jsd.on('vision:selection-dispense-config', payload => console.log(payload));

vision:channels-linked-to-selection

Channels associated with a selection and the response status.

type Arguments = [
    data: {
      selection: OneTo240;
      linkedChannels: {
        machine: MachineValid;
        tray: ValidTray;
        channel: ValidChannel;
      }[];
      status: StatusChannelsLinkedToSelection;
    }
  ];

jsd.on('vision:channels-linked-to-selection', payload => console.log(payload));

vision:machine-id

Machine model, serial number, and firmware identification.

type Arguments = [
    data: {
      machine: MachineValid;
      model: string;
      serialNumber: string;
      firmwareVersion: string;
    }
  ];

jsd.on('vision:machine-id', payload => console.log(payload));

vision:current-temperature

Working, internal, and air temperatures, plus cooling-unit state.

type Arguments = [
    data: {
      machine: MachineValid;
      workingTemperature: string;
      currentTemperatureInsideMachine: string;
      currentTemperatureAir: string;
      coolUnitStatus: 'ON' | 'OFF';
    }
  ];

jsd.on('vision:current-temperature', payload => console.log(payload));

vision:alarm-faults-events

Alarm or fault event becoming active or cleared.

type Arguments = [
    data: {
      machine: MachineValid;
      event: string;
      status: 'ACTIVE' | 'CLEARED';
    }
  ];

jsd.on('vision:alarm-faults-events', payload => console.log(payload));

vision:time-waiting-for-product-collection

Configured collection and dispense waiting intervals.

type Arguments = [
    data: {
      minutesProductCollection: Range<1, 11>;
      secondsTimeBetweenDispenseManoeuvres: Range<0, 66>;
      secondsBetweenCollectAndStartNextDispense: Range<1, 256>;
    }
  ];

jsd.on('vision:time-waiting-for-product-collection', payload => console.log(payload));

vision:collect

Response to a product collection cycle.

type Arguments = [
    data: {
      machine: MachineValid;
      status: string;
    }
  ];

jsd.on('vision:collect', payload => console.log(payload));

vision:reset-sold-out-channels

Result of resetting sold-out channels.

type Arguments = [
    data: {
      machine: MachineValid;
      status: string;
    }
  ];

jsd.on('vision:reset-sold-out-channels', payload => console.log(payload));

vision:time-waiting-after-product-collection

Configured interval following product pickup.

type Arguments = [
    data: {
      secondsBetweenCollectAndStartNextDispense: Range<15, 121>;
    }
  ];

jsd.on('vision:time-waiting-after-product-collection', payload => console.log(payload));

vision:jsd-version

JSD software identity and build information.

type Arguments = [
    data: {
      name: string;
      compileNumber: string;
      compileDate: string;
      description: string;
    }
  ];

jsd.on('vision:jsd-version', payload => console.log(payload));

vision:active-faults

Detailed fault record including counters, duration, and date.

type Arguments = [
    data: {
      machine: MachineValid;
      status: 'ACTIVE' | 'CLEARED';
      fault: number;
      appearancesNumber: number;
      partialNumberActivated: number;
      minutesActive: number;
      date: string;
    }
  ];

jsd.on('vision:active-faults', payload => console.log(payload));

vision:jsd-dispensing-queue

Counts of free, processed, and pending dispensing queue entries.

type Arguments = [
    data: {
      free: number;
      processed: number;
      notProcessed: number;
    }
  ];

jsd.on('vision:jsd-dispensing-queue', payload => console.log(payload));

vision:special-characteristics-selection

Perishable, fragile/heavy, and elevator settings for a selection.

type Arguments = [
    data: {
      selection: OneTo240;
      perishable: boolean;
      fragileOrHeavy: boolean;
      typeAdjustElevator: 'lower' | 'upper';
      timeAdjustElevator: number;
    }
  ];

jsd.on('vision:special-characteristics-selection', payload => console.log(payload));

vision:perishable-products-config

Temperature limit, expiry delay, and perishable alarm configuration.

type Arguments = [
    data: {
      machine: MachineValid;
      perishableActive: boolean;
      alarmPerisableTriggered: boolean;
      maxTemperature: string;
      minutesBeforeExpire: number;
    }
  ];

jsd.on('vision:perishable-products-config', payload => console.log(payload));

vision:active-faults-list

Current fault codes and descriptions for a machine.

type Arguments = [
    data: {
      machine: MachineValid;
      faults: {
        code: number;
        description: string;
      }[];
      ok: boolean;
    }
  ];

jsd.on('vision:active-faults-list', payload => console.log(payload));

vision:jsd-status-reset

JSD restart acknowledgement or completion state.

type Arguments = [
    data: {
      type: JsdResetStatus;
    }
  ];

jsd.on('vision:jsd-status-reset', payload => console.log(payload));

vision:extended-dispense-status-data

Whether extended dispense status reporting is enabled.

type Arguments = [
    data: {
      enabled: boolean;
    }
  ];

jsd.on('vision:extended-dispense-status-data', payload => console.log(payload));

vision:trays-positioning-phototransistors-status

Tray positioning phototransistor readings.

type Arguments = [
    data: {
      machine: MachineValid;
      trays: { [key: number]: string | null };
    }
  ];

jsd.on('vision:trays-positioning-phototransistors-status', payload => console.log(payload));

vision:jsd-license-error

A licensing or price-control restriction rejected the operation.

type Arguments = [
    data: {
      type: 'unknown' | 'expired-license' | 'app-number-not-licensed' | 'price-control-active-direct-dispense-not-allowed';
      opcode: number;
      actionName: string;
      params: string[];
    }
  ];

jsd.on('vision:jsd-license-error', payload => console.log(payload));

vision:dispensing

A tracked dispense is in progress.

type Arguments = [
    data: {
      token: DispenseToken;
      machine: MachineValid | null;
      tray: ValidTray | null;
      channel: ValidChannel | null;
      selection: Range0To81 | null;
    }
  ];

jsd.on('vision:dispensing', payload => console.log(payload));

vision:waiting-collection

A non-cart tracked dispense reached collection or waiting-for-collection state.

type Arguments = [
    data: {
      machine: MachineValid | null;
    }
  ];

jsd.on('vision:waiting-collection', payload => console.log(payload));

vision:door

Door state emitted for every machine-status response, even when unchanged.

type Arguments = [
    data: {
      machine: MachineValid;
      open: boolean;
    }
  ];

jsd.on('vision:door', payload => console.log(payload));

vision:connection

Machine connection state emitted for every machine-status response, even when unchanged.

type Arguments = [
    data: {
      machine: MachineValid;
      connected: boolean;
    }
  ];

jsd.on('vision:connection', payload => console.log(payload));

Aliases used in these signatures are defined in reference types.