API Reference

Here you will find the methods that you can use to interact with the JSD device.

Setters

serialFilters

usbVendorId usbProductId are the filters that you can use to connect to the device

machine.serialFilters = [
  {
    usbVendorId: 0x04d8,
    usbProductId: 0x0053,
  },
];

serialConfigPort

Warning

This is better don’t use once constructor was called

machine.serialConfigPort = {
  baudRate: 9600,
  dataBits: 8,
  stopBits: 1,
  parity: "none",
  bufferSize: 32768,
  flowControl: "none",
};

Getters

listenOnPort

Address of the machine

console.log(machine.listenOnPort)

serialFilters

get the filters that apply when require a serial device

console.log(machine.serialFilters)

serialConfigPort

get the configuration of the serial port

console.log(machine.serialConfigPort)

isConnected

Check if the machine is connected

console.log(machine.isConnected)

isDisconnected

Check if the machine is disconnected

console.log(machine.isDisconnected)

deviceNumber

Get the number of device, isn’t the same of the address.

Warning

Number of device is util if you have more than one jsd in the same pc

console.log(machine.deviceNumber)

uuid

Get the uuid of the connection

When you create a new instance of the class, the uuid is generated

console.log(machine.uuid)

typeDevice

Get the type of the device each class has a different type, in this case is jsd

console.log(machine.typeDevice)

queue

Get the queue of commands that are waiting to be executed

console.log(machine.queue)

Methods for vision

Info

To almost all methods you need listen to the event, because the methods take a while to execute

isAvailableToDispense

Check if a machine is available to dispense based on its status.

const isAvailable = machine.vision.isAvailableToDispense({ machine: 1 });
console.log(isAvailable); // true or false

requestMachineStatus

Request the current status of a machine.

Note

Listen to the vision:machine-status event for the response

await machine.vision.requestMachineStatus({ machine: 1 });

machine.on('vision:machine-status', (data) => {
  console.log('Machine status:', data);
});

requestStatusChannel

Request status of a specific channel.

Note

Listen to the vision:channel-status event for the response

await machine.vision.requestStatusChannel({ machine: 1, selection: 15 });

machine.on('vision:channel-status', (data) => {
  console.log('Channel status:', data);
});

assignChannels

Get status of all channels in a machine.

Warning

This method triggers a sequence of requests for all selections in the configured range

Note

Listen to the vision:channels event for the response

const channels = await machine.vision.assignChannels({ machine: 1 });
console.log('All channels:', channels);

// Or listen to the events
machine.on('vision:channels', (data) => {
  console.log('Channels data:', data);
});
machine.on("vision:channels-progress", (event) => {
  console.log(event.detail);
});

requestStatusSelection

Request status of a specific selection.

Info

Valid selection range is from 1 to 240

Note

Listen to the vision:status-selection event for the response

await machine.vision.requestStatusSelection({ selection: 25 });

machine.on('vision:status-selection', (data) => {
  console.log('Selection status:', data);
});

configureSelectionDispense

Configure dispense parameters for a selection.

Note

Listen to the vision:selection-dispense-config event for confirmation

await machine.vision.configureSelectionDispense({
  selection: 10,
  speed: 5,
  timePostRun: 2
});

machine.on('vision:selection-dispense-config', (data) => {
  console.log('Configuration saved:', data);
});

requestSelectionDispenseConfig

Get current dispense configuration for a selection.

Note

Listen to the vision:selection-dispense-config event for the response

await machine.vision.requestSelectionDispenseConfig({ machine: 1 });

machine.on('vision:selection-dispense-config', (data) => {
  console.log('Dispense configuration:', data);
});

configureAddChannelToSelection

Add a channel to a selection.

Note

Listen to the vision:channels-linked-to-selection event for confirmation

await machine.vision.configureAddChannelToSelection({
  selection: 10,
  machine: 1,
  tray: 2,
  channel: 5
});

machine.on('vision:channels-linked-to-selection', (data) => {
  console.log('Channel added:', data);
});

requestChannelsLinkedToSelection

Get all channels linked to a specific selection.

Note

Listen to the vision:channels-linked-to-selection event for the response

await machine.vision.requestChannelsLinkedToSelection({ selection: 10 });

machine.on('vision:channels-linked-to-selection', (data) => {
  console.log('Linked channels:', data);
});

requestMachineIdentification

Request machine identification information.

Note

Listen to the vision:machine-id event for the response

await machine.vision.requestMachineIdentification({ machine: 1 });

machine.on('vision:machine-id', (data) => {
  console.log('Machine ID:', data);
});

configureWorkingTemperature

Program the working temperature for a machine.

Note

Listen to the vision:current-temperature event for confirmation

await machine.vision.configureWorkingTemperature({
  machine: 1,
  temperature: 4, // degrees Celsius
  enable: true
});

machine.on('vision:current-temperature', (data) => {
  console.log('Temperature configured:', data);
});

requestWorkingTemperature

Get the current working temperature configuration.

Note

Listen to the vision:current-temperature event for the response

await machine.vision.requestWorkingTemperature({ machine: 1 });

machine.on('vision:current-temperature', (data) => {
  console.log('Current temperature:', data);
});

configureWaitingTimings

Program waiting timings for different operations.

Note

Listen to the vision:time-waiting-for-product-collection event for confirmation

await machine.vision.configureWaitingTimings({
  collectPosition: 3,
  dispenseManoeuvres: 5,
  afterPickup: 2
});

machine.on('vision:time-waiting-for-product-collection', (data) => {
  console.log('Timings configured:', data);
});

requestWaitingTimings

Get the current waiting timings configuration.

Note

Listen to the vision:time-waiting-for-product-collection event for the response

await machine.vision.requestWaitingTimings();

machine.on('vision:time-waiting-for-product-collection', (data) => {
  console.log('Waiting timings:', data);
});

resetSoldOutChannels

Reset sold-out status for all channels in a machine.

Note

Listen to the vision:reset-sold-out-channels event for confirmation

await machine.vision.resetSoldOutChannels({ machine: 1 });

machine.on('vision:reset-sold-out-channels', (data) => {
  console.log('Sold-out status reset:', data);
});

resetAllErrors

Reset all faults and perform self-test for a machine.

Warning

This will reset all error states

Note

• Listen to the vision:reset-sold-out-channels event for confirmation
• Listen to the vision:active-faults event for the updated active faults report

await machine.vision.resetAllErrors({ machine: 1 });

machine.on('vision:reset-sold-out-channels', (data) => {
  console.log('Sold out channels reset:', data);
});
machine.on('vision:active-faults', (data) => {
  console.log('Active errors:', data);
});

configureTimeWaitingAfterPickup

Program the time to wait after product pickup.

Note

Listen to the vision:time-waiting-after-product-collection event for confirmation

await machine.vision.configureTimeWaitingAfterPickup({ time: 5 }); // 5 seconds

machine.on('vision:time-waiting-after-product-collection', (data) => {
  console.log('Time configured:', data);
});

requestTimeWaitingAfterPickup

Get the current time waiting after pickup configuration.

Note

Listen to the vision:time-waiting-after-product-collection event for the response

await machine.vision.requestTimeWaitingAfterPickup();

machine.on('vision:time-waiting-after-product-collection', (data) => {
  console.log('Time after pickup:', data);
});

requestJSDVersion

Request the JSD firmware version.

Note

Listen to the vision:jsd-version event for the response

await machine.vision.requestJSDVersion();

machine.on('vision:jsd-version', (data) => {
  console.log('JSD version:', data);
});

requestReportActiveFaults

Request a report of currently active faults.

Note

Listen to the vision:active-faults event for the response

await machine.vision.requestReportActiveFaults({ machine: 1 });

machine.on('vision:active-faults', (data) => {
  console.log('Active faults:', data);
});

requestReportInactiveFaults

Request a report of inactive faults (historical).

Note

Listen to the vision:active-faults event for the response

await machine.vision.requestReportInactiveFaults({ machine: 1 });

machine.on('vision:active-faults', (data) => {
  console.log('Inactive faults:', data);
});

clearInactiveFaults

Clear the inactive faults log.

Note

Listen to the vision:active-faults event for confirmation

await machine.vision.clearInactiveFaults({ machine: 1 });

machine.on('vision:active-faults', (data) => {
  console.log('Inactive faults cleared:', data);
});

requestJSDDispensingQueueStatus

Request the current status of the JSD dispensing queue.

Note

Listen to the vision:jsd-dispensing-queue event for the response

await machine.vision.requestJSDDispensingQueueStatus();

machine.on('vision:jsd-dispensing-queue', (data) => {
  console.log('Queue status:', data);
});

clearJSDDispensingQueue

Clear the JSD dispensing queue.

Warning

This will cancel all pending dispense operations

Note

Listen to the vision:jsd-dispensing-queue event for confirmation

await machine.vision.clearJSDDispensingQueue();

machine.on('vision:jsd-dispensing-queue', (data) => {
  console.log('Queue cleared:', data);
});

configureSpecialCharacteristicsSelection

Define special characteristics for a selection (perishable, fragile, elevator adjustments).

Note

Listen to the vision:special-characteristics-selection event for confirmation

await machine.vision.configureSpecialCharacteristicsSelection({
  selection: 15,
  perishable: true,
  fragileOrHeavy: false,
  typeAdjustElevator: 1,
  timeAdjustElevator: 3
});

machine.on('vision:special-characteristics-selection', (data) => {
  console.log('Special characteristics configured:', data);
});

requestSpecialCharacteristicsSelection

Get special characteristics configured for a selection.

Note

Listen to the vision:special-characteristics-selection event for the response

await machine.vision.requestSpecialCharacteristicsSelection({ selection: 15 });

machine.on('vision:special-characteristics-selection', (data) => {
  console.log('Special characteristics:', data);
});

configurePerishableProducts

Configure perishable products settings for a machine.

Note

Listen to the vision:perishable-products-config event for confirmation

await machine.vision.configurePerishableProducts({
  machine: 1,
  enable: true,
  temperatureLimit: 8, // degrees Celsius
  minutesToExpiry: 120 // 2 hours
});

machine.on('vision:perishable-products-config', (data) => {
  console.log('Perishable products configured:', data);
});

requestActiveFaults

Request currently active faults for a machine.

Note

Listen to the vision:active-faults-list event for the response

await machine.vision.requestActiveFaults({ machine: 1 });

machine.on('vision:active-faults-list', (data) => {
  console.log('Active faults:', data);
});

configureExtendedDispenseStatusData

Configure whether to receive extended dispense status data.

Note

Listen to the vision:extended-dispense-status-data event for confirmation

await machine.vision.configureExtendedDispenseStatusData({ enable: true });

machine.on('vision:extended-dispense-status-data', (data) => {
  console.log('Extended status configured:', data);
});

requestExtendedDispenseStatusDataConfig

Get the current extended dispense status data configuration.

Note

Listen to the vision:extended-dispense-status-data event for the response

await machine.vision.requestExtendedDispenseStatusDataConfig();

machine.on('vision:extended-dispense-status-data', (data) => {
  console.log('Extended status config:', data);
});

requestStatusTrayPositioningPhototransistors

Request the status of tray positioning phototransistors.

Note

Listen to the vision:trays-positioning-phototransistors-status event for the response

await machine.vision.requestStatusTrayPositioningPhototransistors({ machine: 1 });

machine.on('vision:trays-positioning-phototransistors-status', (data) => {
  console.log('Phototransistors status:', data);
});

dispenseFromChannel

Dispense a product from a specific channel.

Note

Listen to the vision:dispense-status event for the dispense result

const result = await machine.vision.dispenseFromChannel({
  machine: 1,
  tray: 2,
  channel: 5,
  speed: 5,
  timePostRun: 2,
  cart: false
});

console.log('Dispense initiated:', result);

machine.on('vision:dispense-status', (data) => {
  console.log('Dispense completed:', data);
});

dispense

Dispense from a selection using the channel assignment logic.

Info

Selection range is from 1 to 81

Note

Listen to the vision:dispense-status event for the dispense result

const result = await machine.vision.dispense({
  machine: 1,
  selection: 15,
  speed: 5,
  timePostRun: 2,
  cart: false
});

console.log('Dispense initiated:', result);

machine.on('vision:dispense-status', (data) => {
  console.log('Dispense completed:', data);
});

dispenseCart

Dispense multiple selections in a cart operation.

Warning

This method sends dispense commands in batches of 10 and waits for machines to be available before sending the next batch

Note

This method returns the results directly

const cartItems = [
  { machine: 1, selection: 10 },
  { machine: 1, selection: 15 },
  { machine: 2, selection: 20 }
];

const results = await machine.vision.dispenseCart(cartItems);
console.log('Cart dispense results:', results);
// Example output: [{ selection: 10, dispensed: true }, { selection: 15, dispensed: true }, ...]

requestDispenseStatusFromChannel

Get the dispense status from a channel using a token.

Note

The token is received when initiating a dispense operation

Note

Listen to the vision:dispense-status event for the response

await machine.vision.requestDispenseStatusFromChannel({ token: 'abc123' });

machine.on('vision:dispense-status', (data) => {
  console.log('Dispense status:', data);
});

dispenseFromSelection

Dispense from a selection directly.

Note

Listen to the vision:dispense-status event for the dispense result

const result = await machine.vision.dispenseFromSelection({
  selection: 25,
  cart: false
});

console.log('Dispense initiated:', result);

machine.on('vision:dispense-status', (data) => {
  console.log('Dispense completed:', data);
});

requestDispenseStatusFromSelection

Get the dispense status from a selection using a token.

Note

The token is received when initiating a dispense operation

Note

Listen to the vision:dispense-status event for the response

await machine.vision.requestDispenseStatusFromSelection({ token: 'xyz789' });

machine.on('vision:dispense-status', (data) => {
  console.log('Dispense status:', data);
});

lightsOn

Turn on the lights for a machine.

Note

Listen to the vision:machine-status event for confirmation

await machine.vision.lightsOn({ machine: 1 });

machine.on('vision:machine-status', (data) => {
  console.log('Lights turned on:', data);
});

lightsOff

Turn off the lights for a machine.

Note

Listen to the vision:machine-status event for confirmation

await machine.vision.lightsOff({ machine: 1 });

machine.on('vision:machine-status', (data) => {
  console.log('Lights turned off:', data);
});

resetFaultsAndSelfTest

Reset faults and perform self-test.

await machine.vision.resetFaultsAndSelfTest({ machine: 1 });

// machine.on('vision:machine-status', (data) => {
//   console.log('Self-test completed:', data);
// });

collect

Perform a collect cycle to move the elevator to the collection position.

await machine.vision.collect({ machine: 1 });

// machine.on('vision:machine-status', (data) => {
//   console.log('Collect cycle completed:', data);
// });

dispenseFromChannelExtended

Dispense from a channel with extended options for fragile/heavy products and elevator adjustments.

Note

Listen to the vision:dispense-status event for the dispense result

const result = await machine.vision.dispenseFromChannelExtended({
  machine: 1,
  tray: 2,
  channel: 5,
  speed: 3,
  timePostRun: 3,
  fragileOrHeavy: true,
  typeAdjustElevator: 2,
  timeAdjustElevator: 4,
  cart: false
});

console.log('Extended dispense initiated:', result);

machine.on('vision:dispense-status', (data) => {
  console.log('Dispense completed:', data);
});

requestDispenseStatusFromChannelExtended

Get the dispense status from a channel with extended data using a token.

Note

The token is received when initiating an extended dispense operation

Note

Listen to the vision:dispense-status event for the response

await machine.vision.requestDispenseStatusFromChannelExtended({ token: 'ext456' });

machine.on('vision:dispense-status', (data) => {
  console.log('Extended dispense status:', data);
});

restartJSD

Request a complete JSD reset.

Danger

This will perform a complete reset of the JSD system. Use with caution!

Note

Listen to the vision:jsd-status-reset event for confirmation

await machine.vision.restartJSD();

machine.on('vision:jsd-status-reset', (data) => {
  console.log('JSD restarted:', data);
});

Methods for manifest

requestLogsEvent

Request logs events from the machine.

Note

Listen to the manifest:log event for the response

await machine.requestLogsEvent({ previous: false });

machine.on('manifest:log', (data) => {
  console.log('Logs event:', data);
});

// Request previous logs
await machine.requestLogsEvent({ previous: true });

requestLogs

Request logs and return them as an array of strings. This method handles fetching logs in batches if necessary.

Warning

This method throws an error if logs are already being fetched

try {
  const logs = await machine.requestLogs();
  console.log('All logs:', logs);
  // Example output: ['Log entry 1', 'Log entry 2', ...]
} catch (error) {
  console.error('Error fetching logs:', error);
}

requestLogsByDate

Request logs filtered by a specific date range.

Note

Listen to the manifest:log event for the response

const since = new Date('2026-01-01');
const until = new Date('2026-02-12');

await machine.requestLogsByDate({ since, until });

machine.on('manifest:log', (data) => {
  console.log('Logs in date range:', data);
});

requestForSendingManifest

Request to start sending a manifest file to the machine.

Info

You need to provide the file size in bytes and the CRC checksum

Note

Listen to the manifest:completed event to know when the manifest upload is complete

await machine.requestForSendingManifest({
  fileSizeBytes: 2048,
  crc: 'A3F5C8'
});

machine.on('manifest:completed', (data) => {
  console.log('Manifest upload completed:', data);
});

sendManifestDataBlock

Send a block of manifest data to the machine.

Info

Manifest data is sent in blocks. Each block needs the previous block ID

Note

Listen to the manifest:block event for confirmation

const dataBlock = new Uint8Array([0x01, 0x02, 0x03, 0x04, /* ... */]);

await machine.sendManifestDataBlock({
  prevBlockId: 0,
  dataBlock: dataBlock
});

machine.on('manifest:block', (data) => {
  console.log('Block received:', data);
  // Send next block...
});

Methods for licensing

requestFeatureStatus

Request the status of a specific feature by its ID.

Note

Listen to the licensing:feature-status event for the response

await machine.requestFeatureStatus({ feature: 101 });

machine.on('licensing:feature-status', (data) => {
  console.log('Feature status:', data);
  // Example: { feature: 101, active: true }
});

requestTemporaryLicenseStatus

Request the status of the temporary license.

Note

Listen to the licensing:temporary-license-status event for the response

await machine.requestTemporaryLicenseStatus();

machine.on('licensing:temporary-license-status', (data) => {
  console.log('Temporary license status:', data);
  // Example: { status: 'active', remainingDays: 30, daysSinceExpiration: 0 }
});

requestSeedData

Request seed data for license generation.

Note

Listen to the licensing:seed event for the response

await machine.requestSeedData();

machine.on('licensing:seed', (data) => {
  console.log('Seed data:', data);
  // Example: { seed: '...', hex: '...' }
  // Use this seed data to generate a license
});

requestLicenseActivation

Request activation of a license using a license string.

Note

This method sends the license activation request to the machine

await machine.requestLicenseActivation({
  license: 'XXXX-YYYY-ZZZZ-AAAA-BBBB'
});

Methods for MDB Card Holder

Info

To almost all methods you need listen to the event, because the methods take a while to execute

requestStatus

Request for status of the MDB Card Holder device.

Note

Listen to the mdbCardHolder:condition-status event for the response

await machine.requestStatus({
  numberDevice: 1
});

requestIdentification

Request for identification of the MDB Card Holder device.

Info

Listen to the mdbCardHolder:identification event for the response

await machine.requestIdentification({
  deviceNumber: 1,
});

requestConfiguration

Request for configuration of the MDB Card Holder device.

Info

Listen to the mdbCardHolder:configuration-data event for the response

await machine.requestConfiguration({
  deviceNumber: 1,
});

requestSetFunctionalitiesConfiguration

Request for functionalities configuration of the MDB Card Holder device.

• @param options.deviceNumber The device number to request functionalities configuration for. Defaults to 1.
• @param options.alwaysIdle Whether the device should always be idle (true) or not (false).
• @param options.remoteVend Whether remote vend is enabled (true) or not (false).

Info

Listen to the mdbCardHolder:configuration-data event for the response Listen to the mdbCardHolder:feature-configuration event for the response

await machine.requestSetFunctionalitiesConfiguration({
  deviceNumber: 1,
  alwaysIdle: true,
  remoteVend: false,
});

requestGetFunctionalitiesConfiguration

Request for functionalities configuration of the MDB Card Holder device.

Info

Listen to the mdbCardHolder:feature-configuration event for the response

await machine.requestGetFunctionalitiesConfiguration({
  deviceNumber: 1,
});

requestEnable

Request to enable or disable the MDB Card Holder device.

Info

Listen to the mdbCardHolder:condition-status event for the response

await machine.requestEnable({
  deviceNumber: 1,
  enable: true
});

requestBalanceData

Request for balance data of the MDB Card Holder device.

Info

Listen to the mdbCardHolder:balance-statement event for the response

await machine.requestBalanceData({
  deviceNumber: 1,

});

requestSaleApproval

Request for sale approval of the MDB Card Holder device.

Info

Listen to the mdbCardHolder:sale-approval event for the response

await machine.requestSaleApproval({
  deviceNumber: 1,
  amount: 100,
  productId: null, // null|number
});

requestSaleCancellation

Request for sale cancellation of the MDB Card Holder device.

Info

Listen to the mdbCardHolder:sale-cancellation event for the response

await machine.requestSaleCancellation({
  deviceNumber: 1,
});

requestSaleSuccessConfirmation

Request for sale success confirmation of the MDB Card Holder device.

Info

Listen to the mdbCardHolder:sale-success-confirmation event for the response

await machine.requestSaleSuccessConfirmation({
  deviceNumber: 1,
});

requestSaleFailureConfirmation

Request for sale failure confirmation of the MDB Card Holder device.

Info

Listen to the mdbCardHolder:sale-failure-confirmation event for the response

await machine.requestSaleFailureConfirmation({
  deviceNumber: 1,
});

requestEndSession

Request to end session of the MDB Card Holder device.

Info

Listen to the mdbCardHolder:end-session event for the response

await machine.requestEndSession({
  deviceNumber: 1,
});

requestCashRecord

Request for cash record of the MDB Card Holder device.

Info

Listen to the mdbCardHolder:sale-approval event for the response

await machine.requestCashRecord({
  deviceNumber: 1,
  amount: 100,
  productId: null, // null|number
});

requestSelectionRequestDenied

Request for selection request denied of the MDB Card Holder device.

Info

Listen to the mdbCardHolder:selection-request event for the response

await machine.requestSelectionRequestDenied({
  deviceNumber: 1,
  reasonCode: "unknown", // "'unknown' | 'product-not-available' | 'out-of-stock' | 'faulty-selection' | 'no-ingredients' | 'selection-locked' | 'inhibited-selection' | 'expired-product' | 'temperature' | 'occupied-machine' | 'insufficient-credit' | 'temporarily-occupied-machine'"
});

requestRevalue

Request for revalue of the MDB Card Holder device.

Info

Listen to the mdbCardHolder:revalue event for the response

await machine.requestRevalue({
  deviceNumber: 1,
  amount: 100
});