ZCLIP.js

A javascript implementation of ZCL over IP.

Installation
Examples
API
Supported Clusters
Run the tests
Support

Installation

npm install zclip

Examples

Examples are located in /examples

var coap = require('coap');
var zcl = require('../.')(coap);

var deviceIp = '::1';
var clusterEndpoint = 1;

var onOff = zcl.clusters.OnOff({
  ip: deviceIp,
  endpoint: clusterEndpoint
});

onOff.on({}, (err, response) => {
  if (err) {
    console.error(err);
  }

  console.log(response.code);
});

API

zclip.clusters.Alarms
zclip.clusters.ApplianceControl
zclip.clusters.ApplianceEventsAndAlert
zclip.clusters.ApplianceIdentification
zclip.clusters.ApplianceStatistics
zclip.clusters.BallastConfiguration
zclip.clusters.Basic
zclip.clusters.BinaryInputBasic
zclip.clusters.ColorControl
zclip.clusters.Commissioning
zclip.clusters.DehumidificationControl
zclip.clusters.DeviceTemperatureConfiguration
zclip.clusters.Diagnostics
zclip.clusters.DoorLock
zclip.clusters.ElectricalMeasurement
zclip.clusters.FanControl
zclip.clusters.FlowMeasurement
zclip.clusters.Groups
zclip.clusters.IasAce
zclip.clusters.IasWd
zclip.clusters.IasZone
zclip.clusters.Identify
zclip.clusters.IlluminanceLevelSensing
zclip.clusters.IlluminanceMeasurement
zclip.clusters.LevelControl
zclip.clusters.MeterIdentification
zclip.clusters.OccupancySensing
zclip.clusters.OnOff
zclip.clusters.OnOffSwitchConfiguration
zclip.clusters.OverTheAirBootloading
zclip.clusters.PollControl
zclip.clusters.PowerConfiguration
zclip.clusters.PowerProfile
zclip.clusters.PressureMeasurement
zclip.clusters.PumpConfigurationAndControl
zclip.clusters.RelativeHumidityMeasurement
zclip.clusters.RssiLocation
zclip.clusters.Scenes
zclip.clusters.ShadeConfiguration
zclip.clusters.TemperatureMeasurement
zclip.clusters.Thermostat
zclip.clusters.ThermostatUserInterfaceConfiguration
zclip.clusters.Time
zclip.clusters.WindowCovering
zclip.discover
zclip.RD

zclip.clusters.Alarms

var alarmsCluster = zcl.clusters.Alarms({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

alarms.bind

alarmsCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

alarms.read

alarmsCluster.read(args, callback);

args - None
callback
- err
- response
  - alarmCount <int16u> (server)
- responseCode

alarms.alarm

alarms.alarm(args, callback);

args
- alarmCode <enum8>
- clusterId <cluster_id>
callback
- err
- response
- responseCode

alarms.getAlarmResponse

alarms.getAlarmResponse(args, callback);

args
- status <status>
- alarmCode <enum8>
- clusterId <cluster_id>
- timeStamp <int32u>
callback
- err
- response
- responseCode

alarms.getAlarm

alarms.getAlarm(args, callback);

args - None
callback
- err
- response
- responseCode

alarms.resetAlarmLog

alarms.resetAlarmLog(args, callback);

args - None
callback
- err
- response
- responseCode

zclip.clusters.ApplianceControl

var applianceControlCluster = zcl.clusters.ApplianceControl({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

applianceControl.bind

applianceControlCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

applianceControl.read

applianceControlCluster.read(args, callback);

args - None
callback
- err
- response
  - startTime <int16u> (server)
  - finishTime <int16u> (server)
  - remainingTime <int16u> (server)
- responseCode

applianceControl.signalStateResponse

applianceControl.signalStateResponse(args, callback);

args
- applianceStatus <appliancestatus>
- remoteEnableFlagsAndDeviceStatus2 <remoteenableflagsanddevicestatus2>
- applianceStatus2 <int24u>
callback
- err
- response
- responseCode

applianceControl.signalStateNotification

applianceControl.signalStateNotification(args, callback);

args
- applianceStatus <appliancestatus>
- remoteEnableFlagsAndDeviceStatus2 <remoteenableflagsanddevicestatus2>
- applianceStatus2 <int24u>
callback
- err
- response
- responseCode

applianceControl.writeFunctions

applianceControl.writeFunctions(args, callback);

args
- functionId <int16u>
- functionDataType <enum8>
- functionData <int8u>
callback
- err
- response
- responseCode

applianceControl.overloadPauseResume

applianceControl.overloadPauseResume(args, callback);

args - None
callback
- err
- response
- responseCode

applianceControl.overloadPause

applianceControl.overloadPause(args, callback);

args - None
callback
- err
- response
- responseCode

applianceControl.overloadWarning

applianceControl.overloadWarning(args, callback);

args
- warningEvent <warningevent>
callback
- err
- response
- responseCode

zclip.clusters.ApplianceEventsAndAlert

var applianceEventsAndAlertCluster = zcl.clusters.ApplianceEventsAndAlert({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

applianceEventsAndAlert.bind

applianceEventsAndAlertCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

applianceEventsAndAlert.read

applianceEventsAndAlertCluster.read(args, callback);

args - None
callback
- err
- response
- responseCode

applianceEventsAndAlert.getAlertsResponse

applianceEventsAndAlert.getAlertsResponse(args, callback);

args
- alertsCount <alertcount>
- alertStructures <alertstructure>
callback
- err
- response
- responseCode

applianceEventsAndAlert.alertsNotification

applianceEventsAndAlert.alertsNotification(args, callback);

args
- alertsCount <alertcount>
- alertStructures <alertstructure>
callback
- err
- response
- responseCode

applianceEventsAndAlert.eventsNotification

applianceEventsAndAlert.eventsNotification(args, callback);

args
- eventHeader <int8u>
- eventId <eventidentification>
callback
- err
- response
- responseCode

zclip.clusters.ApplianceIdentification

var applianceIdentificationCluster = zcl.clusters.ApplianceIdentification({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

applianceIdentification.bind

applianceIdentificationCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

applianceIdentification.read

applianceIdentificationCluster.read(args, callback);

args - None
callback
- err
- response
  - basicIdentification <int56u> (server)
  - companyName <char_string> (server)
  - companyId <int16u> (server)
  - brandName <char_string> (server)
  - brandId <int16u> (server)
  - model <octet_string> (server)
  - partNumber <octet_string> (server)
  - productRevision <octet_string> (server)
  - softwareRevision <octet_string> (server)
  - productTypeName <octet_string> (server)
  - productTypeId <int16u> (server)
  - cecedSpecificationVersion <int8u> (server)
- responseCode

zclip.clusters.ApplianceStatistics

var applianceStatisticsCluster = zcl.clusters.ApplianceStatistics({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

applianceStatistics.bind

applianceStatisticsCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

applianceStatistics.read

applianceStatisticsCluster.read(args, callback);

args - None
callback
- err
- response
  - logMaxSize <int32u> (server)
  - logQueueMaxSize <int8u> (server)
- responseCode

applianceStatistics.logRequest

applianceStatistics.logRequest(args, callback);

args
- logId <int32u>
callback
- err
- response
- responseCode

applianceStatistics.logQueueRequest

applianceStatistics.logQueueRequest(args, callback);

args - None
callback
- err
- response
- responseCode

applianceStatistics.logQueueResponse

applianceStatistics.logQueueResponse(args, callback);

args
- logQueueSize <int8u>
- logIds <int32u>
callback
- err
- response
- responseCode

applianceStatistics.statisticsAvailable

applianceStatistics.statisticsAvailable(args, callback);

args
- logQueueSize <int8u>
- logIds <int32u>
callback
- err
- response
- responseCode

zclip.clusters.BallastConfiguration

var ballastConfigurationCluster = zcl.clusters.BallastConfiguration({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

ballastConfiguration.bind

ballastConfigurationCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

ballastConfiguration.read

ballastConfigurationCluster.read(args, callback);

args - None
callback
- err
- response
  - physicalMinLevel <int8u> (server)
  - physicalMaxLevel <int8u> (server)
  - ballastStatus <bitmap8> (server)
  - minLevel <int8u> (server)
  - maxLevel <int8u> (server)
  - powerOnLevel <int8u> (server)
  - powerOnFadeTime <int16u> (server)
  - intrinsicBallastFactor <int8u> (server)
  - ballastFactorAdjustment <int8u> (server)
  - lampQuality <int8u> (server)
  - lampType <char_string> (server)
  - lampManufacturer <char_string> (server)
  - lampRatedHours <int24u> (server)
  - lampBurnHours <int24u> (server)
  - lampAlarmMode <bitmap8> (server)
  - lampBurnHoursTripPoint <int24u> (server)
- responseCode

zclip.clusters.Basic

var basicCluster = zcl.clusters.Basic({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

basic.bind

basicCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

basic.read

basicCluster.read(args, callback);

args - None
callback
- err
- response
  - zclVersion <int8u> (server)
  - applicationVersion <int8u> (server)
  - stackVersion <int8u> (server)
  - hardwareVersion <int8u> (server)
  - manufacturerName <char_string> (server)
  - modelIdentifier <char_string> (server)
  - dateCode <char_string> (server)
  - powerSource <enum8> (server)
  - genericDeviceClass <enum8> (server)
  - genericDeviceType <enum8> (server)
  - productCode <octet_string> (server)
  - productUrl <char_string> (server)
  - locationDescription <char_string> (server)
  - physicalEnvironment <enum8> (server)
  - deviceEnabled <boolean> (server)
  - alarmMask <bitmap8> (server)
  - disableLocalConfig <bitmap8> (server)
- responseCode

basic.resetToFactoryDefaults

basic.resetToFactoryDefaults(args, callback);

args - None
callback
- err
- response
- responseCode

zclip.clusters.BinaryInputBasic

var binaryInputBasicCluster = zcl.clusters.BinaryInputBasic({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

binaryInputBasic.bind

binaryInputBasicCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

binaryInputBasic.read

binaryInputBasicCluster.read(args, callback);

args - None
callback
- err
- response
  - activeText <char_string> (server)
  - description <char_string> (server)
  - inactiveText <char_string> (server)
  - outOfService <boolean> (server)
  - polarity <enum8> (server)
  - presentValue <boolean> (server)
  - reliability <enum8> (server)
  - statusFlags <bitmap8> (server)
  - applicationType <int32u> (server)
- responseCode

zclip.clusters.ColorControl

var colorControlCluster = zcl.clusters.ColorControl({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

colorControl.bind

colorControlCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

colorControl.read

colorControlCluster.read(args, callback);

args - None
callback
- err
- response
  - currentHue <int8u> (server)
  - currentSaturation <int8u> (server)
  - remainingTime <int16u> (server)
  - currentX <int16u> (server)
  - currentY <int16u> (server)
  - driftCompensation <enum8> (server)
  - compensationText <char_string> (server)
  - colorTemperature <int16u> (server)
  - colorMode <enum8> (server)
  - colorControlOptions <bitmap8> (server)
  - numberOfPrimaries <int8u> (server)
  - primary1X <int16u> (server)
  - primary1Y <int16u> (server)
  - primary1Intensity <int8u> (server)
  - primary2X <int16u> (server)
  - primary2Y <int16u> (server)
  - primary2Intensity <int8u> (server)
  - primary3X <int16u> (server)
  - primary3Y <int16u> (server)
  - primary3Intensity <int8u> (server)
  - primary4X <int16u> (server)
  - primary4Y <int16u> (server)
  - primary4Intensity <int8u> (server)
  - primary5X <int16u> (server)
  - primary5Y <int16u> (server)
  - primary5Intensity <int8u> (server)
  - primary6X <int16u> (server)
  - primary6Y <int16u> (server)
  - primary6Intensity <int8u> (server)
  - whitePointX <int16u> (server)
  - whitePointY <int16u> (server)
  - colorPointRX <int16u> (server)
  - colorPointRY <int16u> (server)
  - colorPointRIntensity <int8u> (server)
  - colorPointGX <int16u> (server)
  - colorPointGY <int16u> (server)
  - colorPointGIntensity <int8u> (server)
  - colorPointBX <int16u> (server)
  - colorPointBY <int16u> (server)
  - colorPointBIntensity <int8u> (server)
  - coupleColorTempToLevelMinMireds <int16u> (server)
  - startUpColorTemperatureMireds <int16u> (server)
- responseCode

colorControl.moveToColorTemperature

colorControl.moveToColorTemperature(args, callback);

args
- colorTemperature <int16u>
- transitionTime <int16u>
callback
- err
- response
- responseCode

colorControl.moveHue

colorControl.moveHue(args, callback);

args
- moveMode <huemovemode>
- rate <int8u>
callback
- err
- response
- responseCode

colorControl.stepHue

colorControl.stepHue(args, callback);

args
- stepMode <huestepmode>
- stepSize <int8u>
- transitionTime <int8u>
callback
- err
- response
- responseCode

colorControl.moveToSaturation

colorControl.moveToSaturation(args, callback);

args
- saturation <int8u>
- transitionTime <int16u>
callback
- err
- response
- responseCode

colorControl.moveSaturation

colorControl.moveSaturation(args, callback);

args
- moveMode <saturationmovemode>
- rate <int8u>
callback
- err
- response
- responseCode

colorControl.stepSaturation

colorControl.stepSaturation(args, callback);

args
- stepMode <saturationstepmode>
- stepSize <int8u>
- transitionTime <int8u>
callback
- err
- response
- responseCode

colorControl.moveToHueAndSaturation

colorControl.moveToHueAndSaturation(args, callback);

args
- hue <int8u>
- saturation <int8u>
- transitionTime <int16u>
callback
- err
- response
- responseCode

colorControl.moveToColor

colorControl.moveToColor(args, callback);

args
- colorx <int16u>
- colory <int16u>
- transitionTime <int16u>
callback
- err
- response
- responseCode

colorControl.moveColor

colorControl.moveColor(args, callback);

args
- ratex <int16s>
- ratey <int16s>
callback
- err
- response
- responseCode

colorControl.stepColor

colorControl.stepColor(args, callback);

args
- stepx <int16s>
- stepy <int16s>
- transitionTime <int16u>
callback
- err
- response
- responseCode

zclip.clusters.Commissioning

var commissioningCluster = zcl.clusters.Commissioning({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

commissioning.bind

commissioningCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

commissioning.read

commissioningCluster.read(args, callback);

args - None
callback
- err
- response
  - shortAddress <int16u> (server)
  - extendedPanId <ieee_address> (server)
  - panId <int16u> (server)
  - channelMask <bitmap32> (server)
  - protocolVersion <int8u> (server)
  - stackProfile <int8u> (server)
  - startupControl <enum8> (server)
  - trustCenterAddress <ieee_address> (server)
  - trustCenterMasterKey <security_key> (server)
  - networkKey <security_key> (server)
  - useInsecureJoin <boolean> (server)
  - preconfiguredLinkKey <security_key> (server)
  - networkKeySequenceNumber <int8u> (server)
  - networkKeyType <enum8> (server)
  - networkManagerAddress <int16u> (server)
  - scanAttempts <int8u> (server)
  - timeBetweenScans <int16u> (server)
  - rejoinInterval <int16u> (server)
  - maxRejoinInterval <int16u> (server)
  - indirectPollRate <int16u> (server)
  - parentRetryThreshold <int8u> (server)
  - concentratorFlag <boolean> (server)
  - concentratorRadius <int8u> (server)
  - concentratorDiscoveryTime <int8u> (server)
- responseCode

commissioning.restartDeviceResponse

commissioning.restartDeviceResponse(args, callback);

args
- status <enum8>
callback
- err
- response
- responseCode

commissioning.saveStartupParametersResponse

commissioning.saveStartupParametersResponse(args, callback);

args
- status <enum8>
callback
- err
- response
- responseCode

commissioning.restoreStartupParametersResponse

commissioning.restoreStartupParametersResponse(args, callback);

args
- status <enum8>
callback
- err
- response
- responseCode

commissioning.resetStartupParametersResponse

commissioning.resetStartupParametersResponse(args, callback);

args
- status <enum8>
callback
- err
- response
- responseCode

zclip.clusters.DehumidificationControl

var dehumidificationControlCluster = zcl.clusters.DehumidificationControl({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

dehumidificationControl.bind

dehumidificationControlCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

dehumidificationControl.read

dehumidificationControlCluster.read(args, callback);

args - None
callback
- err
- response
  - relativeHumidity <int8u> (server)
  - dehumidificationCooling <int8u> (server)
  - rhDehumidificationSetpoint <int8u> (server)
  - relativeHumidityMode <enum8> (server)
  - dehumidificationLockout <enum8> (server)
  - dehumidificationHysteresis <int8u> (server)
  - dehumidificationMaxCool <int8u> (server)
  - relativeHumidityDisplay <enum8> (server)
- responseCode

zclip.clusters.DeviceTemperatureConfiguration

var deviceTemperatureConfigurationCluster = zcl.clusters.DeviceTemperatureConfiguration({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

deviceTemperatureConfiguration.bind

deviceTemperatureConfigurationCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

deviceTemperatureConfiguration.read

deviceTemperatureConfigurationCluster.read(args, callback);

args - None
callback
- err
- response
  - currentTemperature <int16s> (server)
  - minTempExperienced <int16s> (server)
  - maxTempExperienced <int16s> (server)
  - overTempTotalDwell <int16u> (server)
  - deviceTempAlarmMask <bitmap8> (server)
  - lowTempThreshold <int16s> (server)
  - highTempThreshold <int16s> (server)
  - lowTempDwellTripPoint <int24u> (server)
  - highTempDwellTripPoint <int24u> (server)
- responseCode

zclip.clusters.Diagnostics

var diagnosticsCluster = zcl.clusters.Diagnostics({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

diagnostics.bind

diagnosticsCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

diagnostics.read

diagnosticsCluster.read(args, callback);

args - None
callback
- err
- response
  - numberOfResets <int16u> (server)
  - persistentMemoryWrites <int16u> (server)
  - macRxBroadcast <int32u> (server)
  - macTxBroadcast <int32u> (server)
  - macRxUnicast <int32u> (server)
  - macTxUnicast <int32u> (server)
  - macTxUnicastRetry <int16u> (server)
  - macTxUnicastFail <int16u> (server)
  - apsRxBroadcast <int16u> (server)
  - apsTxBroadcast <int16u> (server)
  - apsRxUnicast <int16u> (server)
  - apsUnicastSuccess <int16u> (server)
  - apsTxUnicastRetries <int16u> (server)
  - apsTxUnicastFailures <int16u> (server)
  - routeDiscoveryInitiated <int16u> (server)
  - neighborAdded <int16u> (server)
  - neighborMoved <int16u> (server)
  - neighborStale <int16u> (server)
  - joinIndication <int16u> (server)
  - childMoved <int16u> (server)
  - networkFrameControlFailure <int16u> (server)
  - apsFrameControlFailure <int16u> (server)
  - apsUnauthorizedKey <int16u> (server)
  - networkDecryptionFailure <int16u> (server)
  - apsDecryptionFailure <int16u> (server)
  - packetBufferAllocationFailures <int16u> (server)
  - relayedUnicasts <int16u> (server)
  - phyToMacQueueLimitReached <int16u> (server)
  - packetValidateDropCount <int16u> (server)
  - averageMacRetryPerApsMessageSent <int16u> (server)
  - lastMessageLqi <int8u> (server)
  - lastMessageRssi <int8s> (server)
- responseCode

zclip.clusters.DoorLock

var doorLockCluster = zcl.clusters.DoorLock({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

doorLock.bind

doorLockCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

doorLock.read

doorLockCluster.read(args, callback);

args - None
callback
- err
- response
  - lockState <enum8> (server)
  - lockType <enum8> (server)
  - actuatorEnabled <boolean> (server)
  - doorState <enum8> (server)
  - doorOpenEvents <int32u> (server)
  - doorClosedEvents <int32u> (server)
  - openPeriod <int16u> (server)
  - numLockRecordsSupported <int16u> (server)
  - numTotalUsersSupported <int16u> (server)
  - numPinUsersSupported <int16u> (server)
  - numRfidUsersSupported <int16u> (server)
  - numWeekdaySchedulesSupportedPerUser <int8u> (server)
  - numYeardaySchedulesSupportedPerUser <int8u> (server)
  - numHolidaySchedulesSupportedPerUser <int8u> (server)
  - maxPinLength <int8u> (server)
  - minPinLength <int8u> (server)
  - maxRfidCodeLength <int8u> (server)
  - minRfidCodeLength <int8u> (server)
  - enableLogging <boolean> (server)
  - language <char_string> (server)
  - ledSettings <int8u> (server)
  - autoRelockTime <int32u> (server)
  - soundVolume <int8u> (server)
  - operatingMode <enum8> (server)
  - supportedOperatingModes <bitmap16> (server)
  - defaultConfigurationRegister <bitmap16> (server)
  - enableLocalProgramming <boolean> (server)
  - enableOneTouchLocking <boolean> (server)
  - enableInsideStatusLed <boolean> (server)
  - enablePrivacyModeButton <boolean> (server)
  - wrongCodeEntryLimit <int8u> (server)
  - userCodeTemporaryDisableTime <int8u> (server)
  - sendPinOverTheAir <boolean> (server)
  - requirePinForRfOperation <boolean> (server)
  - zigbeeSecurityLevel <enum8> (server)
  - alarmMask <bitmap16> (server)
  - keypadOperationEventMask <bitmap16> (server)
  - rfOperationEventMask <bitmap16> (server)
  - manualOperationEventMask <bitmap16> (server)
  - rfidOperationEventMask <bitmap16> (server)
  - keypadProgrammingEventMask <bitmap16> (server)
  - rfProgrammingEventMask <bitmap16> (server)
  - rfidProgrammingEventMask <bitmap16> (server)
- responseCode

doorLock.getYeardayScheduleResponse

doorLock.getYeardayScheduleResponse(args, callback);

args
- scheduleId <int8u>
- userId <int16u>
- status <int8u>
- localStartTime <int32u>
- localEndTime <int32u>
callback
- err
- response
- responseCode

doorLock.unlockDoorResponse

doorLock.unlockDoorResponse(args, callback);

args
- status <int8u>
callback
- err
- response
- responseCode

doorLock.toggleResponse

doorLock.toggleResponse(args, callback);

args
- status <int8u>
callback
- err
- response
- responseCode

doorLock.unlockWithTimeoutResponse

doorLock.unlockWithTimeoutResponse(args, callback);

args
- status <int8u>
callback
- err
- response
- responseCode

doorLock.getLogRecordResponse

doorLock.getLogRecordResponse(args, callback);

args
- logEntryId <int16u>
- timestamp <int32u>
- eventType <enum8>
- source <int8u>
- eventIdOrAlarmCode <int8u>
- userId <int16u>
- pin <char_string>
callback
- err
- response
- responseCode

doorLock.setPinResponse

doorLock.setPinResponse(args, callback);

args
- status <doorlocksetpinoridstatus>
callback
- err
- response
- responseCode

doorLock.getPinResponse

doorLock.getPinResponse(args, callback);

args
- userId <int16u>
- userStatus <doorlockuserstatus>
- userType <doorlockusertype>
- pin <char_string>
callback
- err
- response
- responseCode

doorLock.clearPinResponse

doorLock.clearPinResponse(args, callback);

args
- status <int8u>
callback
- err
- response
- responseCode

doorLock.clearAllPinsResponse

doorLock.clearAllPinsResponse(args, callback);

args
- status <int8u>
callback
- err
- response
- responseCode

doorLock.setUserStatusResponse

doorLock.setUserStatusResponse(args, callback);

args
- status <int8u>
callback
- err
- response
- responseCode

doorLock.clearYeardayScheduleResponse

doorLock.clearYeardayScheduleResponse(args, callback);

args
- status <int8u>
callback
- err
- response
- responseCode

doorLock.setHolidayScheduleResponse

doorLock.setHolidayScheduleResponse(args, callback);

args
- status <int8u>
callback
- err
- response
- responseCode

doorLock.getHolidayScheduleResponse

doorLock.getHolidayScheduleResponse(args, callback);

args
- scheduleId <int8u>
- status <int8u>
- localStartTime <int32u>
- localEndTime <int32u>
- operatingModeDuringHoliday <enum8>
callback
- err
- response
- responseCode

doorLock.clearHolidayScheduleResponse

doorLock.clearHolidayScheduleResponse(args, callback);

args
- status <int8u>
callback
- err
- response
- responseCode

doorLock.setUserTypeResponse

doorLock.setUserTypeResponse(args, callback);

args
- status <int8u>
callback
- err
- response
- responseCode

doorLock.getUserTypeResponse

doorLock.getUserTypeResponse(args, callback);

args
- userId <int16u>
- userType <doorlockusertype>
callback
- err
- response
- responseCode

doorLock.setRfidResponse

doorLock.setRfidResponse(args, callback);

args
- status <doorlocksetpinoridstatus>
callback
- err
- response
- responseCode

doorLock.getRfidResponse

doorLock.getRfidResponse(args, callback);

args
- userId <int16u>
- userStatus <doorlockuserstatus>
- userType <doorlockusertype>
- rfid <char_string>
callback
- err
- response
- responseCode

doorLock.clearRfidResponse

doorLock.clearRfidResponse(args, callback);

args
- status <int8u>
callback
- err
- response
- responseCode

doorLock.clearAllRfidsResponse

doorLock.clearAllRfidsResponse(args, callback);

args
- status <int8u>
callback
- err
- response
- responseCode

doorLock.operationEventNotification

doorLock.operationEventNotification(args, callback);

args
- source <int8u>
- eventCode <doorlockoperationeventcode>
- userId <int16u>
- pin <char_string>
- timeStamp <int32u>
- data <char_string>
callback
- err
- response
- responseCode

doorLock.programmingEventNotification

doorLock.programmingEventNotification(args, callback);

args
- source <int8u>
- eventCode <doorlockprogrammingeventcode>
- userId <int16u>
- pin <char_string>
- userType <doorlockusertype>
- userStatus <doorlockuserstatus>
- timeStamp <int32u>
- data <char_string>
callback
- err
- response
- responseCode

zclip.clusters.ElectricalMeasurement

var electricalMeasurementCluster = zcl.clusters.ElectricalMeasurement({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

electricalMeasurement.bind

electricalMeasurementCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

electricalMeasurement.read

electricalMeasurementCluster.read(args, callback);

args - None
callback
- err
- response
  - measurementType <bitmap32> (server)
  - dcVoltage <int16s> (server)
  - dcVoltageMin <int16s> (server)
  - dcVoltageMax <int16s> (server)
  - dcCurrent <int16s> (server)
  - dcCurrentMin <int16s> (server)
  - dcCurrentMax <int16s> (server)
  - dcPower <int16s> (server)
  - dcPowerMin <int16s> (server)
  - dcPowerMax <int16s> (server)
  - dcVoltageMultiplier <int16u> (server)
  - dcVoltageDivisor <int16u> (server)
  - dcCurrentMultiplier <int16u> (server)
  - dcCurrentDivisor <int16u> (server)
  - dcPowerMultiplier <int16u> (server)
  - dcPowerDivisor <int16u> (server)
  - acFrequency <int16u> (server)
  - acFrequencyMin <int16u> (server)
  - acFrequencyMax <int16u> (server)
  - neutralCurrent <int16u> (server)
  - totalActivePower <int32s> (server)
  - totalReactivePower <int32s> (server)
  - totalApparentPower <int32u> (server)
  - measured1stHarmonicCurrent <int16s> (server)
  - measured3rdHarmonicCurrent <int16s> (server)
  - measured5thHarmonicCurrent <int16s> (server)
  - measured7thHarmonicCurrent <int16s> (server)
  - measured9thHarmonicCurrent <int16s> (server)
  - measured11thHarmonicCurrent <int16s> (server)
  - measuredPhase1stHarmonicCurrent <int16s> (server)
  - measuredPhase3rdHarmonicCurrent <int16s> (server)
  - measuredPhase5thHarmonicCurrent <int16s> (server)
  - measuredPhase7thHarmonicCurrent <int16s> (server)
  - measuredPhase9thHarmonicCurrent <int16s> (server)
  - measuredPhase11thHarmonicCurrent <int16s> (server)
  - acFrequencyMultiplier <int16u> (server)
  - acFrequencyDivisor <int16u> (server)
  - powerMultiplier <int32u> (server)
  - powerDivisor <int32u> (server)
  - harmonicCurrentMultiplier <int8s> (server)
  - phaseHarmonicCurrentMultiplier <int8s> (server)
  - instantaneousVoltage <int16s> (server)
  - instantaneousLineCurrent <int16u> (server)
  - instantaneousActiveCurrent <int16s> (server)
  - instantaneousReactiveCurrent <int16s> (server)
  - instantaneousPower <int16s> (server)
  - rmsVoltage <int16u> (server)
  - rmsVoltageMin <int16u> (server)
  - rmsVoltageMax <int16u> (server)
  - rmsCurrent <int16u> (server)
  - rmsCurrentMin <int16u> (server)
  - rmsCurrentMax <int16u> (server)
  - activePower <int16s> (server)
  - activePowerMin <int16s> (server)
  - activePowerMax <int16s> (server)
  - reactivePower <int16s> (server)
  - apparentPower <int16u> (server)
  - powerFactor <int8s> (server)
  - averageRmsVoltageMeasurementPeriod <int16u> (server)
  - averageRmsUnderVoltageCounter <int16u> (server)
  - rmsExtremeOverVoltagePeriod <int16u> (server)
  - rmsExtremeUnderVoltagePeriod <int16u> (server)
  - rmsVoltageSagPeriod <int16u> (server)
  - rmsVoltageSwellPeriod <int16u> (server)
  - acVoltageMultiplier <int16u> (server)
  - acVoltageDivisor <int16u> (server)
  - acCurrentMultiplier <int16u> (server)
  - acCurrentDivisor <int16u> (server)
  - acPowerMultiplier <int16u> (server)
  - acPowerDivisor <int16u> (server)
  - overloadAlarmsMask <bitmap8> (server)
  - voltageOverload <int16s> (server)
  - currentOverload <int16s> (server)
  - acOverloadAlarmsMask <bitmap16> (server)
  - acVoltageOverload <int16s> (server)
  - acCurrentOverload <int16s> (server)
  - acActivePowerOverload <int16s> (server)
  - acReactivePowerOverload <int16s> (server)
  - averageRmsOverVoltage <int16s> (server)
  - averageRmsUnderVoltage <int16s> (server)
  - rmsExtremeOverVoltage <int16s> (server)
  - rmsExtremeUnderVoltage <int16s> (server)
  - rmsVoltageSag <int16s> (server)
  - rmsVoltageSwell <int16s> (server)
  - lineCurrentPhaseB <int16u> (server)
  - activeCurrentPhaseB <int16s> (server)
  - reactiveCurrentPhaseB <int16s> (server)
  - rmsVoltagePhaseB <int16u> (server)
  - rmsVoltageMinPhaseB <int16u> (server)
  - rmsVoltageMaxPhaseB <int16u> (server)
  - rmsCurrentPhaseB <int16u> (server)
  - rmsCurrentMinPhaseB <int16u> (server)
  - rmsCurrentMaxPhaseB <int16u> (server)
  - activePowerPhaseB <int16s> (server)
  - activePowerMinPhaseB <int16s> (server)
  - activePowerMaxPhaseB <int16s> (server)
  - reactivePowerPhaseB <int16s> (server)
  - apparentPowerPhaseB <int16u> (server)
  - powerFactorPhaseB <int8s> (server)
  - averageRmsVoltageMeasurementPeriodPhaseB <int16u> (server)
  - averageRmsOverVoltageCounterPhaseB <int16u> (server)
  - averageRmsUnderVoltageCounterPhaseB <int16u> (server)
  - rmsExtremeOverVoltagePeriodPhaseB <int16u> (server)
  - rmsExtremeUnderVoltagePeriodPhaseB <int16u> (server)
  - rmsVoltageSagPeriodPhaseB <int16u> (server)
  - rmsVoltageSwellPeriodPhaseB <int16u> (server)
  - lineCurrentPhaseC <int16u> (server)
  - activeCurrentPhaseC <int16s> (server)
  - reactiveCurrentPhaseC <int16s> (server)
  - rmsVoltagePhaseC <int16u> (server)
  - rmsVoltageMinPhaseC <int16u> (server)
  - rmsVoltageMaxPhaseC <int16u> (server)
  - rmsCurrentPhaseB <int16u> (server)
  - rmsCurrentMinPhaseC <int16u> (server)
  - rmsCurrentMaxPhaseC <int16u> (server)
  - activePowerPhaseC <int16s> (server)
  - activePowerMinPhaseC <int16s> (server)
  - activePowerMaxPhaseC <int16s> (server)
  - reactivePowerPhaseC <int16s> (server)
  - apparentPowerPhaseC <int16u> (server)
  - powerFactorPhaseC <int8s> (server)
  - averageRmsVoltageMeasurementPeriodPhaseC <int16u> (server)
  - averageRmsOverVoltageCounterPhaseC <int16u> (server)
  - averageRmsUnderVoltageCounterPhaseC <int16u> (server)
  - rmsExtremeOverVoltagePeriodPhaseC <int16u> (server)
  - rmsExtremeUnderVoltagePeriodPhaseC <int16u> (server)
  - rmsVoltageSagPeriodPhaseC <int16u> (server)
  - rmsVoltageSwellPeriodPhaseC <int16u> (server)
- responseCode

electricalMeasurement.getProfileInfoCommand

electricalMeasurement.getProfileInfoCommand(args, callback);

args - None
callback
- err
- response
- responseCode

electricalMeasurement.getMeasurementProfileCommand

electricalMeasurement.getMeasurementProfileCommand(args, callback);

args
- attributeId <int16u>
- startTime <int32u>
- numberOfIntervals <enum8>
callback
- err
- response
- responseCode

zclip.clusters.FanControl

var fanControlCluster = zcl.clusters.FanControl({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

fanControl.bind

fanControlCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

fanControl.read

fanControlCluster.read(args, callback);

args - None
callback
- err
- response
  - fanMode <enum8> (server)
  - fanModeSequence <enum8> (server)
- responseCode

zclip.clusters.FlowMeasurement

var flowMeasurementCluster = zcl.clusters.FlowMeasurement({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

flowMeasurement.bind

flowMeasurementCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

flowMeasurement.read

flowMeasurementCluster.read(args, callback);

args - None
callback
- err
- response
  - measuredValue <int16u> (server)
  - minMeasuredValue <int16u> (server)
  - maxMeasuredValue <int16u> (server)
  - tolerance <int16u> (server)
- responseCode

zclip.clusters.Groups

var groupsCluster = zcl.clusters.Groups({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

groups.bind

groupsCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

groups.read

groupsCluster.read(args, callback);

args - None
callback
- err
- response
  - nameSupport <bitmap8> (server)
- responseCode

groups.addGroupResponse

groups.addGroupResponse(args, callback);

args
- status <status>
- groupId <int16u>
callback
- err
- response
- responseCode

groups.viewGroupResponse

groups.viewGroupResponse(args, callback);

args
- status <status>
- groupId <int16u>
- groupName <char_string>
callback
- err
- response
- responseCode

groups.getGroupMembershipResponse

groups.getGroupMembershipResponse(args, callback);

args
- capacity <int8u>
- groupCount <int8u>
- groupList <int16u>
callback
- err
- response
- responseCode

groups.removeGroupResponse

groups.removeGroupResponse(args, callback);

args
- status <status>
- groupId <int16u>
callback
- err
- response
- responseCode

groups.removeAllGroups

groups.removeAllGroups(args, callback);

args - None
callback
- err
- response
- responseCode

groups.addGroupIfIdentifying

groups.addGroupIfIdentifying(args, callback);

args
- groupId <int16u>
- groupName <char_string>
callback
- err
- response
- responseCode

zclip.clusters.IasAce

var iasAceCluster = zcl.clusters.IasAce({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

iasAce.bind

iasAceCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

iasAce.read

iasAceCluster.read(args, callback);

args - None
callback
- err
- response
- responseCode

iasAce.armResponse

iasAce.armResponse(args, callback);

args
- armNotification <iasacearmnotification>
callback
- err
- response
- responseCode

iasAce.getZoneIdMapResponse

iasAce.getZoneIdMapResponse(args, callback);

args
- section0 <bitmap16>
- section1 <bitmap16>
- section2 <bitmap16>
- section3 <bitmap16>
- section4 <bitmap16>
- section5 <bitmap16>
- section6 <bitmap16>
- section7 <bitmap16>
- section8 <bitmap16>
- section9 <bitmap16>
- section10 <bitmap16>
- section11 <bitmap16>
- section12 <bitmap16>
- section13 <bitmap16>
- section14 <bitmap16>
- section15 <bitmap16>
callback
- err
- response
- responseCode

iasAce.getZoneInformationResponse

iasAce.getZoneInformationResponse(args, callback);

args
- zoneId <int8u>
- zoneType <iaszonetype>
- ieeeAddress <ieee_address>
- zoneLabel <char_string>
callback
- err
- response
- responseCode

iasAce.zoneStatusChanged

iasAce.zoneStatusChanged(args, callback);

args
- zoneId <int8u>
- zoneStatus <enum16>
- audibleNotification <iasaceaudiblenotification>
- zoneLabel <char_string>
callback
- err
- response
- responseCode

iasAce.panelStatusChanged

iasAce.panelStatusChanged(args, callback);

args
- panelStatus <iasacepanelstatus>
- secondsRemaining <int8u>
- audibleNotification <iasaceaudiblenotification>
- alarmStatus <iasacealarmstatus>
callback
- err
- response
- responseCode

iasAce.getPanelStatusResponse

iasAce.getPanelStatusResponse(args, callback);

args
- panelStatus <iasacepanelstatus>
- secondsRemaining <int8u>
- audibleNotification <iasaceaudiblenotification>
- alarmStatus <iasacealarmstatus>
callback
- err
- response
- responseCode

iasAce.setBypassedZoneList

iasAce.setBypassedZoneList(args, callback);

args
- numberOfZones <int8u>
- zoneIds <int8u>
callback
- err
- response
- responseCode

iasAce.bypassResponse

iasAce.bypassResponse(args, callback);

args
- numberOfZones <int8u>
- bypassResult <iasacebypassresult>
callback
- err
- response
- responseCode

iasAce.getZoneStatusResponse

iasAce.getZoneStatusResponse(args, callback);

args
- zoneStatusComplete <boolean>
- numberOfZones <int8u>
- zoneStatusResult <iasacezonestatusresult>
callback
- err
- response
- responseCode

iasAce.getZoneStatus

iasAce.getZoneStatus(args, callback);

args
- startingZoneId <int8u>
- maxNumberOfZoneIds <int8u>
- zoneStatusMaskFlag <boolean>
- zoneStatusMask <bitmap16>
callback
- err
- response
- responseCode

zclip.clusters.IasWd

var iasWdCluster = zcl.clusters.IasWd({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

iasWd.bind

iasWdCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

iasWd.read

iasWdCluster.read(args, callback);

args - None
callback
- err
- response
  - maxDuration <int16u> (server)
- responseCode

iasWd.startWarning

iasWd.startWarning(args, callback);

args
- warningInfo <warninginfo>
- warningDuration <int16u>
- strobeDutyCycle <int8u>
- strobeLevel <enum8>
callback
- err
- response
- responseCode

iasWd.squawk

iasWd.squawk(args, callback);

args
- squawkInfo <squawkinfo>
callback
- err
- response
- responseCode

zclip.clusters.IasZone

var iasZoneCluster = zcl.clusters.IasZone({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

iasZone.bind

iasZoneCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

iasZone.read

iasZoneCluster.read(args, callback);

args - None
callback
- err
- response
  - zoneState <enum8> (server)
  - zoneType <enum16> (server)
  - zoneStatus <bitmap16> (server)
  - iasCieAddress <ieee_address> (server)
  - zoneId <int8u> (server)
  - numberOfZoneSensitivityLevelsSupported <int8u> (server)
  - currentZoneSensitivityLevel <int8u> (server)
- responseCode

iasZone.zoneStatusChangeNotification

iasZone.zoneStatusChangeNotification(args, callback);

args
- zoneStatus <iaszonestatus>
- extendedStatus <bitmap8>
- zoneId <int8u>
- delay <int16u>
callback
- err
- response
- responseCode

iasZone.zoneEnrollRequest

iasZone.zoneEnrollRequest(args, callback);

args
- zoneType <iaszonetype>
- manufacturerCode <int16u>
callback
- err
- response
- responseCode

iasZone.initiateNormalOperationModeResponse

iasZone.initiateNormalOperationModeResponse(args, callback);

args - None
callback
- err
- response
- responseCode

iasZone.initiateTestModeResponse

iasZone.initiateTestModeResponse(args, callback);

args - None
callback
- err
- response
- responseCode

zclip.clusters.Identify

var identifyCluster = zcl.clusters.Identify({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

identify.bind

identifyCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

identify.read

identifyCluster.read(args, callback);

args - None
callback
- err
- response
  - identifyTime <int16u> (server)
  - commissionState <bitmap8> (server)
- responseCode

identify.identifyQueryResponse

identify.identifyQueryResponse(args, callback);

args
- timeout <int16u>
callback
- err
- response
- responseCode

identify.identifyQuery

identify.identifyQuery(args, callback);

args - None
callback
- err
- response
- responseCode

identify.ezModeInvoke

identify.ezModeInvoke(args, callback);

args
- action <bitmap8>
callback
- err
- response
- responseCode

identify.updateCommissionState

identify.updateCommissionState(args, callback);

args
- action <enum8>
- commissionStateMask <bitmap8>
callback
- err
- response
- responseCode

zclip.clusters.IlluminanceLevelSensing

var illuminanceLevelSensingCluster = zcl.clusters.IlluminanceLevelSensing({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

illuminanceLevelSensing.bind

illuminanceLevelSensingCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

illuminanceLevelSensing.read

illuminanceLevelSensingCluster.read(args, callback);

args - None
callback
- err
- response
  - levelStatus <enum8> (server)
  - lightSensorType <enum8> (server)
  - illuminanceLevelTarget <int16u> (server)
- responseCode

zclip.clusters.IlluminanceMeasurement

var illuminanceMeasurementCluster = zcl.clusters.IlluminanceMeasurement({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

illuminanceMeasurement.bind

illuminanceMeasurementCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

illuminanceMeasurement.read

illuminanceMeasurementCluster.read(args, callback);

args - None
callback
- err
- response
  - measuredValue <int16u> (server)
  - minMeasuredValue <int16u> (server)
  - maxMeasuredValue <int16u> (server)
  - tolerance <int16u> (server)
  - lightSensorType <enum8> (server)
- responseCode

zclip.clusters.LevelControl

var levelControlCluster = zcl.clusters.LevelControl({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

levelControl.bind

levelControlCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

levelControl.read

levelControlCluster.read(args, callback);

args - None
callback
- err
- response
  - currentLevel <int8u> (server)
  - remainingTime <int16u> (server)
  - options <bitmap8> (server)
  - onOffTransitionTime <int16u> (server)
  - onLevel <int8u> (server)
  - onTransitionTime <int16u> (server)
  - offTransitionTime <int16u> (server)
  - defaultMoveRate <int8u> (server)
  - startUpCurrentLevel <int8u> (server)
- responseCode

levelControl.moveToLevel

levelControl.moveToLevel(args, callback);

args
- level <int8u>
- transitionTime <int16u>
callback
- err
- response
- responseCode

levelControl.move

levelControl.move(args, callback);

args
- moveMode <movemode>
- rate <int8u>
callback
- err
- response
- responseCode

levelControl.step

levelControl.step(args, callback);

args
- stepMode <stepmode>
- stepSize <int8u>
- transitionTime <int16u>
callback
- err
- response
- responseCode

levelControl.stop

levelControl.stop(args, callback);

args - None
callback
- err
- response
- responseCode

levelControl.moveToLevelWithOnOff

levelControl.moveToLevelWithOnOff(args, callback);

args
- level <int8u>
- transitionTime <int16u>
callback
- err
- response
- responseCode

levelControl.moveWithOnOff

levelControl.moveWithOnOff(args, callback);

args
- moveMode <movemode>
- rate <int8u>
callback
- err
- response
- responseCode

levelControl.stepWithOnOff

levelControl.stepWithOnOff(args, callback);

args
- stepMode <stepmode>
- stepSize <int8u>
- transitionTime <int16u>
callback
- err
- response
- responseCode

levelControl.stopWithOnOff

levelControl.stopWithOnOff(args, callback);

args - None
callback
- err
- response
- responseCode

zclip.clusters.MeterIdentification

var meterIdentificationCluster = zcl.clusters.MeterIdentification({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

meterIdentification.bind

meterIdentificationCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

meterIdentification.read

meterIdentificationCluster.read(args, callback);

args - None
callback
- err
- response
  - companyName <char_string> (server)
  - meterTypeId <int16u> (server)
  - dataQualityId <int16u> (server)
  - customerName <char_string> (server)
  - model <octet_string> (server)
  - partNumber <octet_string> (server)
  - productRevision <octet_string> (server)
  - softwareRevision <octet_string> (server)
  - utilityName <char_string> (server)
  - pod <char_string> (server)
  - availablePower <int24s> (server)
  - powerThreshold <int24s> (server)
- responseCode

zclip.clusters.OccupancySensing

var occupancySensingCluster = zcl.clusters.OccupancySensing({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

occupancySensing.bind

occupancySensingCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

occupancySensing.read

occupancySensingCluster.read(args, callback);

args - None
callback
- err
- response
  - occupancy <bitmap8> (server)
  - occupancySensorType <enum8> (server)
  - pirOccupiedToUnoccupiedDelay <int16u> (server)
  - pirUnoccupiedToOccupiedDelay <int16u> (server)
  - pirUnoccupiedToOccupiedThreshold <int8u> (server)
  - ultrasonicOccupiedToUnoccupiedDelay <int16u> (server)
  - ultrasonicUnoccupiedToOccupiedDelay <int16u> (server)
  - ultrasonicUnoccupiedToOccupiedThreshold <int8u> (server)
- responseCode

zclip.clusters.OnOff

var onOffCluster = zcl.clusters.OnOff({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

onOff.bind

onOffCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

onOff.read

onOffCluster.read(args, callback);

args - None
callback
- err
- response
  - onOff <boolean> (server)
  - startUpOnOff <enum8> (server)
- responseCode

onOff.off

onOff.off(args, callback);

args - None
callback
- err
- response
- responseCode

onOff.on

onOff.on(args, callback);

args - None
callback
- err
- response
- responseCode

onOff.toggle

onOff.toggle(args, callback);

args - None
callback
- err
- response
- responseCode

zclip.clusters.OnOffSwitchConfiguration

var onOffSwitchConfigurationCluster = zcl.clusters.OnOffSwitchConfiguration({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

onOffSwitchConfiguration.bind

onOffSwitchConfigurationCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

onOffSwitchConfiguration.read

onOffSwitchConfigurationCluster.read(args, callback);

args - None
callback
- err
- response
  - switchType <enum8> (server)
  - switchActions <enum8> (server)
- responseCode

zclip.clusters.OverTheAirBootloading

var overTheAirBootloadingCluster = zcl.clusters.OverTheAirBootloading({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

overTheAirBootloading.bind

overTheAirBootloadingCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

overTheAirBootloading.read

overTheAirBootloadingCluster.read(args, callback);

args - None
callback
- err
- response
  - otaUpgradeServerId <ieee_address> (client)
  - offsetAddressIntoTheFile <int32u> (client)
  - otaCurrentFileVersion <int32u> (client)
  - otaCurrentZigBeeStackVersion <int16u> (client)
  - otaDownloadedFileVersion <int32u> (client)
  - otaDownloadedZigBeeStackVersion <int16u> (client)
  - otaUpgradeStatus <enum8> (client)
  - manufacturerId <int16u> (client)
  - imageTypeId <int16u> (client)
  - minimumBlockRequestPeriod <int16u> (client)
  - imageStamp <int32u> (client)
  - upgradeActivationPolicy <enum8> (client)
  - upgradeTimeoutPolicy <enum8> (client)
- responseCode

overTheAirBootloading.imageNotify

overTheAirBootloading.imageNotify(args, callback);

args
- payloadType <enum8>
- queryJitter <int8u>
- manufacturerId <int16u>
- imageType <int16u>
- newFileVersion <int32u>
callback
- err
- response
- responseCode

overTheAirBootloading.queryNextImageRequest

overTheAirBootloading.queryNextImageRequest(args, callback);

args
- fieldControl <int8u>
- manufacturerId <int16u>
- imageType <int16u>
- currentFileVersion <int32u>
- hardwareVersion <int16u>
callback
- err
- response
- responseCode

overTheAirBootloading.queryNextImageResponse

overTheAirBootloading.queryNextImageResponse(args, callback);

args
- status <status>
- manufacturerId <int16u>
- imageType <int16u>
- fileVersion <int32u>
- imageSize <int32u>
callback
- err
- response
- responseCode

overTheAirBootloading.imageBlockRequest

overTheAirBootloading.imageBlockRequest(args, callback);

args
- fieldControl <int8u>
- manufacturerId <int16u>
- imageType <int16u>
- fileVersion <int32u>
- fileOffset <int32u>
- maxDataSize <int8u>
- requestNodeAddress <ieee_address>
callback
- err
- response
- responseCode

overTheAirBootloading.imagePageRequest

overTheAirBootloading.imagePageRequest(args, callback);

args
- fieldControl <int8u>
- manufacturerId <int16u>
- imageType <int16u>
- fileVersion <int32u>
- fileOffset <int32u>
- maxDataSize <int8u>
- pageSize <int16u>
- responseSpacing <int16u>
- requestNodeAddress <ieee_address>
callback
- err
- response
- responseCode

overTheAirBootloading.imageBlockResponse

overTheAirBootloading.imageBlockResponse(args, callback);

args
- status <status>
- manufacturerId <int16u>
- imageType <int16u>
- fileVersion <int32u>
- fileOffset <int32u>
- dataSize <int8u>
- imageData <int8u>
callback
- err
- response
- responseCode

overTheAirBootloading.upgradeEndRequest

overTheAirBootloading.upgradeEndRequest(args, callback);

args
- status <status>
- manufacturerId <int16u>
- imageType <int16u>
- fileVersion <int32u>
callback
- err
- response
- responseCode

overTheAirBootloading.upgradeEndResponse

overTheAirBootloading.upgradeEndResponse(args, callback);

args
- manufacturerId <int16u>
- imageType <int16u>
- fileVersion <int32u>
- currentTime <utc_time>
- upgradeTime <utc_time>
callback
- err
- response
- responseCode

overTheAirBootloading.querySpecificFileRequest

overTheAirBootloading.querySpecificFileRequest(args, callback);

args
- requestNodeAddress <ieee_address>
- manufacturerId <int16u>
- imageType <int16u>
- fileVersion <int32u>
- currentZigbeeStackVersion <int16u>
callback
- err
- response
- responseCode

overTheAirBootloading.querySpecificFileResponse

overTheAirBootloading.querySpecificFileResponse(args, callback);

args
- status <status>
- manufacturerId <int16u>
- imageType <int16u>
- fileVersion <int32u>
- imageSize <int32u>
callback
- err
- response
- responseCode

zclip.clusters.PollControl

var pollControlCluster = zcl.clusters.PollControl({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

pollControl.bind

pollControlCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

pollControl.read

pollControlCluster.read(args, callback);

args - None
callback
- err
- response
  - checkInInterval <int32u> (server)
  - longPollInterval <int32u> (server)
  - shortPollInterval <int16u> (server)
  - fastPollTimeout <int16u> (server)
  - checkInIntervalMin <int32u> (server)
  - longPollIntervalMin <int32u> (server)
  - fastPollTimeoutMax <int16u> (server)
- responseCode

pollControl.checkInResponse

pollControl.checkInResponse(args, callback);

args
- startFastPolling <boolean>
- fastPollTimeout <int16u>
callback
- err
- response
- responseCode

pollControl.fastPollStop

pollControl.fastPollStop(args, callback);

args - None
callback
- err
- response
- responseCode

pollControl.setLongPollInterval

pollControl.setLongPollInterval(args, callback);

args
- newLongPollInterval <int32u>
callback
- err
- response
- responseCode

pollControl.setShortPollInterval

pollControl.setShortPollInterval(args, callback);

args
- newShortPollInterval <int16u>
callback
- err
- response
- responseCode

zclip.clusters.PowerConfiguration

var powerConfigurationCluster = zcl.clusters.PowerConfiguration({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

powerConfiguration.bind

powerConfigurationCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

powerConfiguration.read

powerConfigurationCluster.read(args, callback);

args - None
callback
- err
- response
  - mainsVoltage <int16u> (server)
  - mainsFrequency <int8u> (server)
  - mainsAlarmMask <bitmap8> (server)
  - mainsVoltageMinThreshold <int16u> (server)
  - mainsVoltageMaxThreshold <int16u> (server)
  - mainsVoltageDwellTrip <int16u> (server)
  - batteryVoltage <int8u> (server)
  - batteryPercentageRemaining <int8u> (server)
  - batteryManufacturer <char_string> (server)
  - batterySize <enum8> (server)
  - batteryAhrRating <int16u> (server)
  - batteryQuantity <int8u> (server)
  - batteryRatedVoltage <int8u> (server)
  - batteryAlarmMask <bitmap8> (server)
  - batteryVoltageMinThreshold <int8u> (server)
  - batteryVoltageThreshold1 <int8u> (server)
  - batteryVoltageThreshold2 <int8u> (server)
  - batteryVoltageThreshold3 <int8u> (server)
  - batteryPercentageMinThreshold <int8u> (server)
  - batteryPercentageThreshold1 <int8u> (server)
  - batteryPercentageThreshold2 <int8u> (server)
  - batteryPercentageThreshold3 <int8u> (server)
  - batteryAlarmState <bitmap32> (server)
  - battery2Voltage <int8u> (server)
  - battery2PercentageRemaining <int8u> (server)
  - battery2Manufacturer <char_string> (server)
  - battery2Size <enum8> (server)
  - battery2AhrRating <int16u> (server)
  - battery2Quantity <int8u> (server)
  - battery2RatedVoltage <int8u> (server)
  - battery2AlarmMask <bitmap8> (server)
  - battery2VoltageMinThreshold <int8u> (server)
  - battery2VoltageThreshold1 <int8u> (server)
  - battery2VoltageThreshold2 <int8u> (server)
  - battery2VoltageThreshold3 <int8u> (server)
  - battery2PercentageMinThreshold <int8u> (server)
  - battery2PercentageThreshold1 <int8u> (server)
  - battery2PercentageThreshold2 <int8u> (server)
  - battery2PercentageThreshold3 <int8u> (server)
  - battery2AlarmState <bitmap32> (server)
  - battery3Voltage <int8u> (server)
  - battery3PercentageRemaining <int8u> (server)
  - battery3Manufacturer <char_string> (server)
  - battery3Size <enum8> (server)
  - battery3AhrRating <int16u> (server)
  - battery3Quantity <int8u> (server)
  - battery3RatedVoltage <int8u> (server)
  - battery3AlarmMask <bitmap8> (server)
  - battery3VoltageMinThreshold <int8u> (server)
  - battery3VoltageThreshold1 <int8u> (server)
  - battery3VoltageThreshold2 <int8u> (server)
  - battery3VoltageThreshold3 <int8u> (server)
  - battery3PercentageMinThreshold <int8u> (server)
  - battery3PercentageThreshold1 <int8u> (server)
  - battery3PercentageThreshold2 <int8u> (server)
  - battery3PercentageThreshold3 <int8u> (server)
  - battery3AlarmState <bitmap32> (server)
- responseCode

zclip.clusters.PowerProfile

var powerProfileCluster = zcl.clusters.PowerProfile({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

powerProfile.bind

powerProfileCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

powerProfile.read

powerProfileCluster.read(args, callback);

args - None
callback
- err
- response
  - totalProfileNum <int8u> (server)
  - multipleScheduling <boolean> (server)
  - energyFormatting <bitmap8> (server)
  - energyRemote <boolean> (server)
  - scheduleMode <bitmap8> (server)
- responseCode

powerProfile.getPowerProfilePriceExtended

powerProfile.getPowerProfilePriceExtended(args, callback);

args
- options <bitmap8>
- powerProfileId <int8u>
- powerProfileStartTime <int16u>
callback
- err
- response
- responseCode

powerProfile.powerProfileResponse

powerProfile.powerProfileResponse(args, callback);

args
- totalProfileNum <int8u>
- powerProfileId <int8u>
- numOfTransferredPhases <int8u>
- transferredPhases <transferredphase>
callback
- err
- response
- responseCode

powerProfile.powerProfileStateResponse

powerProfile.powerProfileStateResponse(args, callback);

args
- powerProfileCount <int8u>
- powerProfileRecords <powerprofilerecord>
callback
- err
- response
- responseCode

powerProfile.getPowerProfilePrice

powerProfile.getPowerProfilePrice(args, callback);

args
- powerProfileId <int8u>
callback
- err
- response
- responseCode

powerProfile.powerProfilesStateNotification

powerProfile.powerProfilesStateNotification(args, callback);

args
- powerProfileCount <int8u>
- powerProfileRecords <powerprofilerecord>
callback
- err
- response
- responseCode

powerProfile.getOverallSchedulePrice

powerProfile.getOverallSchedulePrice(args, callback);

args - None
callback
- err
- response
- responseCode

powerProfile.energyPhasesScheduleRequest

powerProfile.energyPhasesScheduleRequest(args, callback);

args
- powerProfileId <int8u>
callback
- err
- response
- responseCode

powerProfile.energyPhasesScheduleStateResponse

powerProfile.energyPhasesScheduleStateResponse(args, callback);

args
- powerProfileId <int8u>
- numOfScheduledPhases <int8u>
- scheduledPhases <scheduledphase>
callback
- err
- response
- responseCode

powerProfile.energyPhasesScheduleStateNotification

powerProfile.energyPhasesScheduleStateNotification(args, callback);

args
- powerProfileId <int8u>
- numOfScheduledPhases <int8u>
- scheduledPhases <scheduledphase>
callback
- err
- response
- responseCode

powerProfile.powerProfileScheduleConstraintsNotification

powerProfile.powerProfileScheduleConstraintsNotification(args, callback);

args
- powerProfileId <int8u>
- startAfter <int16u>
- stopBefore <int16u>
callback
- err
- response
- responseCode

zclip.clusters.PressureMeasurement

var pressureMeasurementCluster = zcl.clusters.PressureMeasurement({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

pressureMeasurement.bind

pressureMeasurementCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

pressureMeasurement.read

pressureMeasurementCluster.read(args, callback);

args - None
callback
- err
- response
  - measuredValue <int16s> (server)
  - minMeasuredValue <int16s> (server)
  - maxMeasuredValue <int16s> (server)
  - tolerance <int16u> (server)
  - scaledValue <int16s> (server)
  - minScaledValue <int16s> (server)
  - maxScaledValue <int16s> (server)
  - scaledTolerance <int16s> (server)
  - scale <int8s> (server)
- responseCode

zclip.clusters.PumpConfigurationAndControl

var pumpConfigurationAndControlCluster = zcl.clusters.PumpConfigurationAndControl({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

pumpConfigurationAndControl.bind

pumpConfigurationAndControlCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

pumpConfigurationAndControl.read

pumpConfigurationAndControlCluster.read(args, callback);

args - None
callback
- err
- response
  - maxPressure <int16s> (server)
  - maxSpeed <int16u> (server)
  - maxFlow <int16u> (server)
  - minConstPressure <int16s> (server)
  - maxConstPressure <int16s> (server)
  - minCompPressure <int16s> (server)
  - maxCompPressure <int16s> (server)
  - minConstSpeed <int16u> (server)
  - maxConstSpeed <int16u> (server)
  - minConstFlow <int16u> (server)
  - maxConstFlow <int16u> (server)
  - minConstTemp <int16s> (server)
  - maxConstTemp <int16s> (server)
  - pumpStatus <bitmap16> (server)
  - effectiveOperationMode <enum8> (server)
  - effectiveControlMode <enum8> (server)
  - capacity <int16s> (server)
  - speed <int16u> (server)
  - lifetimeRunningHours <int24u> (server)
  - power <int24u> (server)
  - lifetimeEnergyConsumed <int32u> (server)
  - operationMode <enum8> (server)
  - controlMode <enum8> (server)
  - alarmMask <bitmap16> (server)
- responseCode

zclip.clusters.RelativeHumidityMeasurement

var relativeHumidityMeasurementCluster = zcl.clusters.RelativeHumidityMeasurement({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

relativeHumidityMeasurement.bind

relativeHumidityMeasurementCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

relativeHumidityMeasurement.read

relativeHumidityMeasurementCluster.read(args, callback);

args - None
callback
- err
- response
  - measuredValue <int16u> (server)
  - minMeasuredValue <int16u> (server)
  - maxMeasuredValue <int16u> (server)
  - tolerance <int16u> (server)
- responseCode

zclip.clusters.RssiLocation

var rssiLocationCluster = zcl.clusters.RssiLocation({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

rssiLocation.bind

rssiLocationCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

rssiLocation.read

rssiLocationCluster.read(args, callback);

args - None
callback
- err
- response
  - locationType <data8> (server)
  - locationMethod <enum8> (server)
  - locationAge <int16u> (server)
  - qualityMeasure <int8u> (server)
  - numberOfDevices <int8u> (server)
  - coordinate1 <int16s> (server)
  - coordinate2 <int16s> (server)
  - coordinate3 <int16s> (server)
  - power <int16s> (server)
  - pathLossExponent <int16u> (server)
  - reportingPeriod <int16u> (server)
  - calculationPeriod <int16u> (server)
  - numberRssiMeasurements <int8u> (server)
- responseCode

rssiLocation.deviceConfigurationResponse

rssiLocation.deviceConfigurationResponse(args, callback);

args
- status <status>
- power <int16s>
- pathLossExponent <int16u>
- calculationPeriod <int16u>
- numberRssiMeasurements <int8u>
- reportingPeriod <int16u>
callback
- err
- response
- responseCode

rssiLocation.locationDataResponse

rssiLocation.locationDataResponse(args, callback);

args
- status <status>
- locationType <locationtype>
- coordinate1 <int16s>
- coordinate2 <int16s>
- coordinate3 <int16s>
- power <int16s>
- pathLossExponent <int16u>
- locationMethod <locationmethod>
- qualityMeasure <int8u>
- locationAge <int16u>
callback
- err
- response
- responseCode

rssiLocation.locationDataNotification

rssiLocation.locationDataNotification(args, callback);

args
- locationType <locationtype>
- coordinate1 <int16s>
- coordinate2 <int16s>
- coordinate3 <int16s>
- power <int16s>
- pathLossExponent <int16u>
- locationMethod <locationmethod>
- qualityMeasure <int8u>
- locationAge <int16u>
callback
- err
- response
- responseCode

rssiLocation.compactLocationDataNotification

rssiLocation.compactLocationDataNotification(args, callback);

args
- locationType <locationtype>
- coordinate1 <int16s>
- coordinate2 <int16s>
- coordinate3 <int16s>
- qualityMeasure <int8u>
- locationAge <int16u>
callback
- err
- response
- responseCode

rssiLocation.rssiPing

rssiLocation.rssiPing(args, callback);

args
- locationType <locationtype>
callback
- err
- response
- responseCode

rssiLocation.rssiRequest

rssiLocation.rssiRequest(args, callback);

args - None
callback
- err
- response
- responseCode

rssiLocation.reportRssiMeasurements

rssiLocation.reportRssiMeasurements(args, callback);

args
- measuringDevice <ieee_address>
- neighbors <int8u>
- neighborsInfo <neighborinfo>
callback
- err
- response
- responseCode

rssiLocation.requestOwnLocation

rssiLocation.requestOwnLocation(args, callback);

args
- blindNode <ieee_address>
callback
- err
- response
- responseCode

zclip.clusters.Scenes

var scenesCluster = zcl.clusters.Scenes({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

scenes.bind

scenesCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

scenes.read

scenesCluster.read(args, callback);

args - None
callback
- err
- response
  - sceneCount <int8u> (server)
  - currentScene <int8u> (server)
  - currentGroup <int16u> (server)
  - sceneValid <boolean> (server)
  - nameSupport <bitmap8> (server)
  - lastConfiguredBy <ieee_address> (server)
- responseCode

scenes.addSceneResponse

scenes.addSceneResponse(args, callback);

args
- status <status>
- groupId <int16u>
- sceneId <int8u>
callback
- err
- response
- responseCode

scenes.viewSceneResponse

scenes.viewSceneResponse(args, callback);

args
- status <status>
- groupId <int16u>
- sceneId <int8u>
- transitionTime <int16u>
- sceneName <char_string>
- extensionFieldSets <sceneextensionfieldset>
callback
- err
- response
- responseCode

scenes.removeSceneResponse

scenes.removeSceneResponse(args, callback);

args
- status <status>
- groupId <int16u>
- sceneId <int8u>
callback
- err
- response
- responseCode

scenes.removeAllScenesResponse

scenes.removeAllScenesResponse(args, callback);

args
- status <status>
- groupId <int16u>
callback
- err
- response
- responseCode

scenes.storeSceneResponse

scenes.storeSceneResponse(args, callback);

args
- status <status>
- groupId <int16u>
- sceneId <int8u>
callback
- err
- response
- responseCode

scenes.recallScene

scenes.recallScene(args, callback);

args
- groupId <int16u>
- sceneId <int8u>
callback
- err
- response
- responseCode

scenes.getSceneMembershipResponse

scenes.getSceneMembershipResponse(args, callback);

args
- status <status>
- capacity <int8u>
- groupId <int16u>
- sceneCount <int8u>
- sceneList <int8u>
callback
- err
- response
- responseCode

zclip.clusters.ShadeConfiguration

var shadeConfigurationCluster = zcl.clusters.ShadeConfiguration({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

shadeConfiguration.bind

shadeConfigurationCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

shadeConfiguration.read

shadeConfigurationCluster.read(args, callback);

args - None
callback
- err
- response
  - physicalClosedLimit <int16u> (server)
  - motorStepSize <int8u> (server)
  - status <bitmap8> (server)
  - closedLimit <int16u> (server)
  - mode <enum8> (server)
- responseCode

zclip.clusters.TemperatureMeasurement

var temperatureMeasurementCluster = zcl.clusters.TemperatureMeasurement({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

temperatureMeasurement.bind

temperatureMeasurementCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

temperatureMeasurement.read

temperatureMeasurementCluster.read(args, callback);

args - None
callback
- err
- response
  - measuredValue <int16s> (server)
  - minMeasuredValue <int16s> (server)
  - maxMeasuredValue <int16s> (server)
  - tolerance <int16u> (server)
- responseCode

zclip.clusters.Thermostat

var thermostatCluster = zcl.clusters.Thermostat({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

thermostat.bind

thermostatCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

thermostat.read

thermostatCluster.read(args, callback);

args - None
callback
- err
- response
  - localTemperature <int16s> (server)
  - outdoorTemperature <int16s> (server)
  - occupancy <bitmap8> (server)
  - absMinHeatSetpointLimit <int16s> (server)
  - absMaxHeatSetpointLimit <int16s> (server)
  - absMinCoolSetpointLimit <int16s> (server)
  - absMaxCoolSetpointLimit <int16s> (server)
  - piCoolingDemand <int8u> (server)
  - piHeatingDemand <int8u> (server)
  - hvacSystemTypeConfiguration <bitmap8> (server)
  - localTemperatureCalibration <int8s> (server)
  - occupiedCoolingSetpoint <int16s> (server)
  - occupiedHeatingSetpoint <int16s> (server)
  - unoccupiedCoolingSetpoint <int16s> (server)
  - unoccupiedHeatingSetpoint <int16s> (server)
  - minHeatSetpointLimit <int16s> (server)
  - maxHeatSetpointLimit <int16s> (server)
  - minCoolSetpointLimit <int16s> (server)
  - maxCoolSetpointLimit <int16s> (server)
  - minSetpointDeadBand <int8s> (server)
  - remoteSensing <bitmap8> (server)
  - controlSequenceOfOperation <enum8> (server)
  - systemMode <enum8> (server)
  - alarmMask <bitmap8> (server)
  - thermostatRunningMode <enum8> (server)
  - startOfWeek <enum8> (server)
  - numberOfWeeklyTransitions <int8u> (server)
  - numberOfDailyTransitions <int8u> (server)
  - temperatureSetpointHold <enum8> (server)
  - temperatureSetpointHoldDuration <int16u> (server)
  - thermostatProgrammingOperationMode <bitmap8> (server)
  - hvacRelayState <bitmap16> (server)
  - setpointChangeSource <enum8> (server)
  - setpointChangeAmount <int16s> (server)
  - setpointChangeSourceTimestamp <utc_time> (server)
  - acType <enum8> (server)
  - acCapacity <int16u> (server)
  - acRefrigerantType <enum8> (server)
  - acCompressor <enum8> (server)
  - acErrorCode <bitmap32> (server)
  - acLouverPosition <enum8> (server)
  - acCoilTemperature <int16s> (server)
  - acCapacityFormat <enum8> (server)
- responseCode

thermostat.currentWeeklySchedule

thermostat.currentWeeklySchedule(args, callback);

args
- numberOfTransitionsForSequence <enum8>
- dayOfWeekForSequence <dayofweek>
- modeForSequence <modeforsequence>
- payload <int8u>
callback
- err
- response
- responseCode

thermostat.relayStatusLog

thermostat.relayStatusLog(args, callback);

args
- timeOfDay <int16u>
- relayStatus <bitmap16>
- localTemperature <int16s>
- humidityInPercentage <int8u>
- setpoint <int16s>
- unreadEntries <int16u>
callback
- err
- response
- responseCode

thermostat.getWeeklySchedule

thermostat.getWeeklySchedule(args, callback);

args
- daysToReturn <dayofweek>
- modeToReturn <modeforsequence>
callback
- err
- response
- responseCode

thermostat.clearWeeklySchedule

thermostat.clearWeeklySchedule(args, callback);

args - None
callback
- err
- response
- responseCode

thermostat.getRelayStatusLog

thermostat.getRelayStatusLog(args, callback);

args - None
callback
- err
- response
- responseCode

zclip.clusters.ThermostatUserInterfaceConfiguration

var thermostatUserInterfaceConfigurationCluster = zcl.clusters.ThermostatUserInterfaceConfiguration({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

thermostatUserInterfaceConfiguration.bind

thermostatUserInterfaceConfigurationCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

thermostatUserInterfaceConfiguration.read

thermostatUserInterfaceConfigurationCluster.read(args, callback);

args - None
callback
- err
- response
  - temperatureDisplayMode <enum8> (server)
  - keypadLockout <enum8> (server)
  - scheduleProgrammingVisibility <enum8> (server)
- responseCode

zclip.clusters.Time

var timeCluster = zcl.clusters.Time({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

time.bind

timeCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

time.read

timeCluster.read(args, callback);

args - None
callback
- err
- response
  - time <utc_time> (server)
  - timeStatus <bitmap8> (server)
  - timeZone <int32s> (server)
  - dstStart <int32u> (server)
  - dstEnd <int32u> (server)
  - dstShift <int32s> (server)
  - standardTime <int32u> (server)
  - localTime <int32u> (server)
  - lastSetTime <utc_time> (server)
  - validUntilTime <utc_time> (server)
- responseCode

zclip.clusters.WindowCovering

var windowCoveringCluster = zcl.clusters.WindowCovering({
  ip: <deviceIp>,
  endpoint: <clusterEndpoint>
});

windowCovering.bind

windowCoveringCluster.bind(args, callback);

args
- uid
- ip
- port
- endpoint
callback
- err
- response
- responseCode

windowCovering.read

windowCoveringCluster.read(args, callback);

args - None
callback
- err
- response
  - windowCoveringType <enum8> (server)
  - physicalClosedLimitLift <int16u> (server)
  - physicalClosedLimitTilt <int16u> (server)
  - currentPositionLift <int16u> (server)
  - currentPositionTilt <int16u> (server)
  - numberOfActuationsLift <int16u> (server)
  - numberOfActuationsTilt <int16u> (server)
  - configStatus <bitmap8> (server)
  - currentPositionLiftPercentage <int8u> (server)
  - currentPositionTiltPercentage <int8u> (server)
  - installedOpenLimitLift <int16u> (server)
  - installedClosedLimitLift <int16u> (server)
  - installedOpenLimitTilt <int16u> (server)
  - installedClosedLimitTilt <int16u> (server)
  - velocityLift <int16u> (server)
  - accelerationTimeLift <int16u> (server)
  - decelerationTimeLift <int16u> (server)
  - mode <bitmap8> (server)
  - intermediateSetpointsLift <octet_string> (server)
  - intermediateSetpointsTilt <octet_string> (server)
- responseCode

windowCovering.windowCoveringUpOpen

windowCovering.windowCoveringUpOpen(args, callback);

args - None
callback
- err
- response
- responseCode

windowCovering.windowCoveringDownClose

windowCovering.windowCoveringDownClose(args, callback);

args - None
callback
- err
- response
- responseCode

windowCovering.windowCoveringStop

windowCovering.windowCoveringStop(args, callback);

args - None
callback
- err
- response
- responseCode

windowCovering.windowCoveringGoToLiftValue

windowCovering.windowCoveringGoToLiftValue(args, callback);

args
- liftValue <int16u>
callback
- err
- response
- responseCode

windowCovering.windowCoveringGoToLiftPercentage

windowCovering.windowCoveringGoToLiftPercentage(args, callback);

args
- percentageLiftValue <int8u>
callback
- err
- response
- responseCode

windowCovering.windowCoveringGoToTiltValue

windowCovering.windowCoveringGoToTiltValue(args, callback);

args
- tiltValue <int16u>
callback
- err
- response
- responseCode

windowCovering.windowCoveringGoToTiltPercentage

windowCovering.windowCoveringGoToTiltPercentage(args, callback);

args
- percentageTiltValue <int8u>
callback
- err
- response
- responseCode

zclip.discover

zclip.discover(args, callback);

args
- uid
- clusterId
- clusterSide
callback
- err
- response - Array
  - uid
  - ip
  - name
  - cluster
  - clusterSide
  - page
  - count
- responseCode

zclip.RD

var rd = zcl.RD({
  ip: rdIp,
  port: rdPort
});

rd.lookup

rd.lookup(args, callback);

args
- uid
- clusterId
- clusterSide
callback
- err
- response - Array
  - uid
  - ip
  - name
  - cluster
  - clusterSide
  - page
  - count
- responseCode

Supported clusters

Alarms
ApplianceControl
ApplianceEventsAndAlert
ApplianceIdentification
ApplianceStatistics
BallastConfiguration
Basic
BinaryInputBasic
ColorControl
Commissioning
DehumidificationControl
DeviceTemperatureConfiguration
Diagnostics
DoorLock
ElectricalMeasurement
FanControl
FlowMeasurement
Groups
IasAce
IasWd
IasZone
Identify
IlluminanceLevelSensing
IlluminanceMeasurement
LevelControl
MeterIdentification
OccupancySensing
OnOff
OnOffSwitchConfiguration
OverTheAirBootloading
PollControl
PowerConfiguration
PowerProfile
PressureMeasurement
PumpConfigurationAndControl
RelativeHumidityMeasurement
RssiLocation
Scenes
ShadeConfiguration
TemperatureMeasurement
Thermostat
ThermostatUserInterfaceConfiguration
Time
WindowCovering

Run the tests

npm test

Support

community.silabs.com or silabs.com/support

Name		Name	Last commit message	Last commit date
Latest commit History 164 Commits
examples		examples
lib		lib
polyfills		polyfills
test		test
util		util
.gitignore		.gitignore
README.md		README.md
README.md.handlebars		README.md.handlebars
clusterMetaData.json		clusterMetaData.json
deviceMetaData.json		deviceMetaData.json
index.js		index.js
package.json		package.json

HarryMorris/zclip.js

Folders and files

Latest commit

History

Repository files navigation

ZCLIP.js

Installation

Examples

API

zclip.clusters.Alarms

alarms.bind

alarms.read

alarms.alarm

alarms.getAlarmResponse

alarms.getAlarm

alarms.resetAlarmLog

zclip.clusters.ApplianceControl

applianceControl.bind

applianceControl.read

applianceControl.signalStateResponse

applianceControl.signalStateNotification

applianceControl.writeFunctions

applianceControl.overloadPauseResume

applianceControl.overloadPause

applianceControl.overloadWarning

zclip.clusters.ApplianceEventsAndAlert

applianceEventsAndAlert.bind

applianceEventsAndAlert.read

applianceEventsAndAlert.getAlertsResponse

applianceEventsAndAlert.alertsNotification

applianceEventsAndAlert.eventsNotification

zclip.clusters.ApplianceIdentification

applianceIdentification.bind

applianceIdentification.read

zclip.clusters.ApplianceStatistics

applianceStatistics.bind

applianceStatistics.read

applianceStatistics.logRequest

applianceStatistics.logQueueRequest

applianceStatistics.logQueueResponse

applianceStatistics.statisticsAvailable

zclip.clusters.BallastConfiguration

ballastConfiguration.bind

ballastConfiguration.read

zclip.clusters.Basic

basic.bind

basic.read

basic.resetToFactoryDefaults

zclip.clusters.BinaryInputBasic

binaryInputBasic.bind

binaryInputBasic.read

zclip.clusters.ColorControl

colorControl.bind

colorControl.read

colorControl.moveToColorTemperature

colorControl.moveHue

colorControl.stepHue

colorControl.moveToSaturation

colorControl.moveSaturation

colorControl.stepSaturation

colorControl.moveToHueAndSaturation

colorControl.moveToColor

colorControl.moveColor

colorControl.stepColor

zclip.clusters.Commissioning

commissioning.bind

commissioning.read

commissioning.restartDeviceResponse

commissioning.saveStartupParametersResponse

commissioning.restoreStartupParametersResponse

commissioning.resetStartupParametersResponse

zclip.clusters.DehumidificationControl

dehumidificationControl.bind

dehumidificationControl.read

zclip.clusters.DeviceTemperatureConfiguration

deviceTemperatureConfiguration.bind

deviceTemperatureConfiguration.read

zclip.clusters.Diagnostics

diagnostics.bind

diagnostics.read