daikin-local-control 0.4.0 → 0.5.0

package/src/codecs/airbase/state.ts

@@ -0,0 +1,223 @@
+import type {
+  DaikinControl,
+  DaikinSensors,
+  DaikinState,
+  FanSpeed,
+  OperatingMode,
+  SwingMode,
+} from "../../models/state.js";
+import {
+  AIRBASE_FAN_SPEED_CODES,
+  AIRBASE_NO_SETPOINT,
+  AIRBASE_OPERATING_MODE_CODES,
+  AIRBASE_SWING_MODE_CODES,
+} from "./tables.js";
+
+// Maps between `DaikinState` and an Airbase adapter's `control_info` fields,
+// and reads `DaikinSensors` from its `get_sensor_info`.
+//
+// The unit remembers a setpoint, a fan and a direction for cool and for heat
+// alone: `dt2`, `dfr2`, `dfd2`, `auto2` and `airside2` for cool, and the same
+// fields ending in 1 for heat. Auto, fan and dehumidify run on one of the
+// two, the one `bk_auto` names.
+
+const OPERATING_MODES_BY_CODE: Record<string, OperatingMode> =
+  Object.fromEntries(
+    Object.entries(AIRBASE_OPERATING_MODE_CODES).map(([mode, code]) => [
+      code,
+      mode as OperatingMode,
+    ]),
+  );
+
+const FAN_SPEEDS_BY_CODE: Record<string, FanSpeed> = Object.fromEntries(
+  Object.entries(AIRBASE_FAN_SPEED_CODES).map(([speed, code]) => [
+    code,
+    speed as FanSpeed,
+  ]),
+);
+
+const SWING_MODES_BY_CODE: Record<string, SwingMode> = Object.fromEntries(
+  Object.entries(AIRBASE_SWING_MODE_CODES).map(([swing, code]) => [
+    code,
+    swing as SwingMode,
+  ]),
+);
+
+const ON = "1";
+const OFF = "0";
+// What airside runs the fan at.
+const AIRSIDE_FAN_SPEED = AIRBASE_FAN_SPEED_CODES.level1;
+
+/** Turns a `get_control_info` reply into a `DaikinState`. A `mode` or `f_rate`
+ * outside the model reads as `auto`, and an `f_dir` outside it as `off`. It
+ * reports no humidity setting, louver position or special mode: an Airbase
+ * unit is not known to have any. */
+export function parseAirbaseState(fields: Record<string, string>): DaikinState {
+  return {
+    power: fields.pow === ON,
+    mode: OPERATING_MODES_BY_CODE[fields.mode ?? ""] ?? "auto",
+    targetTemperatureInC: parseNumeric(fields.stemp),
+    targetHumidity: null,
+    fanSpeed: FAN_SPEEDS_BY_CODE[fields.f_rate ?? ""] ?? "auto",
+    swingMode: SWING_MODES_BY_CODE[fields.f_dir ?? ""] ?? "off",
+    verticalPosition: null,
+    horizontalPosition: null,
+    specialModes: [],
+  };
+}
+
+export function parseAirbaseSensors(
+  fields: Record<string, string>,
+): DaikinSensors {
+  return {
+    indoorTemperatureInC: parseNumeric(fields.htemp),
+    outdoorTemperatureInC: parseNumeric(fields.otemp),
+    indoorHumidityInPercent: parseNumeric(fields.hhum),
+  };
+}
+
+/** Whether fan auto is on in a `get_control_info` reply: the unit then picks
+ * the fan speed itself, up to the one that is set. */
+export function parseAirbaseFanAuto(fields: Record<string, string>): boolean {
+  return fields.f_auto === ON;
+}
+
+/** Whether airside is on in a `get_control_info` reply. */
+export function parseAirbaseAirside(fields: Record<string, string>): boolean {
+  return fields.f_airside === ON;
+}
+
+/** Turns `current`, the `get_control_info` reply, and a control into the
+ * `set_control_info` query: power, mode, setpoint, humidity, fan speed, fan
+ * auto, airside and direction, every time. When the mode changes, the
+ * setpoint, the fan and the direction come from what the unit remembers for
+ * cool or for heat. It drops a `targetTemperatureInC` in fan and dehumidify,
+ * every `targetHumidity` and louver position, and sends `shum` back as the
+ * unit holds it. A `fanSpeed` switches airside off and keeps fan auto. */
+export function applyAirbaseControl(
+  current: Record<string, string>,
+  control: DaikinControl,
+): Record<string, string> {
+  return buildControl(current, control, {});
+}
+
+/** Turns `current`, the `get_control_info` reply, into the `set_control_info`
+ * query that switches fan auto on or off. It switches airside off, and keeps
+ * the fan speed. */
+export function applyAirbaseFanAuto(
+  current: Record<string, string>,
+  enabled: boolean,
+): Record<string, string> {
+  return buildControl(current, {}, { auto: enabled });
+}
+
+/** Turns `current`, the `get_control_info` reply, into the `set_control_info`
+ * query that switches airside on or off. Switching it on switches fan auto
+ * off and sets the lowest fan speed, which airside runs at. */
+export function applyAirbaseAirside(
+  current: Record<string, string>,
+  enabled: boolean,
+): Record<string, string> {
+  return buildControl(current, {}, { airside: enabled });
+}
+
+function buildControl(
+  current: Record<string, string>,
+  control: DaikinControl,
+  fan: { auto?: boolean; airside?: boolean },
+): Record<string, string> {
+  const { cool, heat, fan: fanMode, dehumidify } = AIRBASE_OPERATING_MODE_CODES;
+  // A mode outside the model is sent back as it came.
+  const currentMode = current.mode ?? "";
+  const mode =
+    control.mode === undefined
+      ? currentMode
+      : AIRBASE_OPERATING_MODE_CODES[control.mode];
+  const modeChanged = mode !== currentMode;
+
+  // A change to cool or to heat makes that mode the one the others run on.
+  const backing =
+    modeChanged && (mode === cool || mode === heat) ? mode : current.bk_auto;
+  // Which of the two memories applies: heat's, or cool's for anything else.
+  const memory = (backing || mode) === heat ? heat : cool;
+  const remembered = (field: string, memoryPrefix: string, fallback: string) =>
+    (modeChanged ? current[`${memoryPrefix}${memory}`] : undefined) ||
+    current[field] ||
+    fallback;
+
+  const power = control.power ?? current.pow === ON;
+  const next: Record<string, string> = { pow: power ? ON : OFF, mode };
+  if (backing) {
+    next.bk_auto = backing;
+  }
+
+  next.stemp =
+    mode === dehumidify
+      ? AIRBASE_NO_SETPOINT
+      : control.targetTemperatureInC != null && mode !== fanMode
+        ? control.targetTemperatureInC.toFixed(1)
+        : remembered("stemp", "dt", AIRBASE_NO_SETPOINT);
+  // Each mode's setpoint is written to its own memory as well, and auto's to
+  // the memory of the mode it runs on.
+  const setpointMemory =
+    mode === cool || mode === heat || mode === fanMode || mode === dehumidify
+      ? mode
+      : mode === AIRBASE_OPERATING_MODE_CODES.auto && backing
+        ? memory
+        : undefined;
+  if (setpointMemory !== undefined) {
+    next[`dt${setpointMemory}`] = next.stemp;
+  }
+  next.shum = current.shum || AIRBASE_NO_SETPOINT;
+
+  next.f_rate =
+    control.fanSpeed === undefined
+      ? remembered("f_rate", "dfr", AIRBASE_FAN_SPEED_CODES.auto)
+      : AIRBASE_FAN_SPEED_CODES[control.fanSpeed];
+  next.f_auto = remembered("f_auto", "auto", OFF);
+  next.f_airside = remembered("f_airside", "airside", OFF);
+  const fanChanged = control.fanSpeed !== undefined || fan.auto !== undefined;
+  if (fan.auto !== undefined) {
+    next.f_auto = fan.auto ? ON : OFF;
+  }
+  if (fanChanged) {
+    next.f_airside = OFF;
+  }
+  if (fan.airside !== undefined) {
+    next.f_airside = fan.airside ? ON : OFF;
+  }
+  if (fan.airside) {
+    next.f_rate = AIRSIDE_FAN_SPEED;
+  }
+  // Airside and fan auto are never on together.
+  if (next.f_airside === ON) {
+    next.f_auto = OFF;
+  }
+  // A change to the fan is written to the memory as well.
+  if (fanChanged) {
+    next[`dfr${memory}`] = next.f_rate;
+    next[`auto${memory}`] = next.f_auto;
+  }
+  if (fanChanged || fan.airside !== undefined) {
+    next[`airside${memory}`] = next.f_airside;
+  }
+
+  next.f_dir =
+    control.swingMode === undefined
+      ? remembered("f_dir", "dfd", AIRBASE_SWING_MODE_CODES.off)
+      : AIRBASE_SWING_MODE_CODES[control.swingMode];
+  if (control.swingMode !== undefined) {
+    next[`dfd${memory}`] = next.f_dir;
+  }
+  return next;
+}
+
+function parseNumeric(value: string | undefined): number | null {
+  if (value === undefined || value === "") {
+    return null;
+  }
+  const parsed = Number(value);
+  // A reading the unit lacks is "-", and a mode without a setpoint holds
+  // "--" or a letter, none of which is a number.
+  return Number.isFinite(parsed) ? parsed : null;
+}

package/src/codecs/airbase/tables.ts

@@ -0,0 +1,32 @@
+import type { FanSpeed, OperatingMode, SwingMode } from "../../models/state.js";
+
+// The codes an Airbase adapter holds each value of a model as. It numbers
+// the modes and the fan speeds differently from a classic adapter.
+
+export const AIRBASE_OPERATING_MODE_CODES: Record<OperatingMode, string> = {
+  fan: "0",
+  heat: "1",
+  cool: "2",
+  auto: "3",
+  dehumidify: "7",
+};
+
+export const AIRBASE_FAN_SPEED_CODES: Record<FanSpeed, string> = {
+  auto: "0",
+  silent: "B",
+  level1: "1",
+  level2: "2",
+  level3: "3",
+  level4: "4",
+  level5: "5",
+};
+
+export const AIRBASE_SWING_MODE_CODES: Record<SwingMode, string> = {
+  off: "0",
+  vertical: "1",
+  horizontal: "2",
+  both: "3",
+};
+
+/** What `stemp` holds in a mode without a setpoint, such as dehumidify. */
+export const AIRBASE_NO_SETPOINT = "--";

package/src/codecs/airbase/zone.ts

@@ -0,0 +1,62 @@
+import type { DaikinZone } from "../../models/zone.js";
+import { decodeClassicText } from "../classic/keyValue.js";
+import { parseAirbaseZoneCount } from "./capabilities.js";
+
+// `get_zone_setting` answers the zones as lists joined by `;`, form-encoded:
+// their names in `zone_name`, and 1 or 0 for each in `zone_onoff`.
+const SEPARATOR = ";";
+// A unit that sets a temperature for each zone answers these two as well, and
+// takes them back with every write.
+const ZONE_TEMPERATURE_FIELDS = ["lztemp_c", "lztemp_h"];
+
+function decodeList(value: string | undefined): string[] {
+  return value === undefined || value === ""
+    ? []
+    : decodeClassicText(value).split(SEPARATOR);
+}
+
+/** Turns a `get_zone_setting` reply into the unit's zones, the first
+ * `en_zone` of them. `capabilityFields` is the field map of
+ * `mergeAirbaseCapabilityFields`. */
+export function parseAirbaseZones(
+  zoneSetting: Record<string, string>,
+  capabilityFields: Record<string, string>,
+): DaikinZone[] {
+  const flags = decodeList(zoneSetting.zone_onoff);
+  return decodeList(zoneSetting.zone_name)
+    .slice(0, parseAirbaseZoneCount(capabilityFields))
+    .map((name, index) => ({
+      name: name.trim(),
+      enabled: flags[index] === "1",
+    }));
+}
+
+/** Turns `current`, the `get_zone_setting` reply, into the `set_zone_setting`
+ * query that opens or closes the zone at `index`, counted from 0. Every name
+ * goes back as the unit holds it, with each zone's temperatures where the
+ * unit has them. It throws an `Error` for an index the unit has no zone
+ * at. */
+export function applyAirbaseZone(
+  current: Record<string, string>,
+  capabilityFields: Record<string, string>,
+  index: number,
+  enabled: boolean,
+): Record<string, string> {
+  const zoneCount = parseAirbaseZones(current, capabilityFields).length;
+  if (!Number.isInteger(index) || index < 0 || index >= zoneCount) {
+    throw new Error(`The unit has no zone ${index}: it has ${zoneCount}`);
+  }
+  const flags = decodeList(current.zone_onoff);
+  flags[index] = enabled ? "1" : "0";
+  const query: Record<string, string> = {
+    zone_name: decodeList(current.zone_name).join(SEPARATOR),
+    zone_onoff: flags.join(SEPARATOR),
+  };
+  for (const field of ZONE_TEMPERATURE_FIELDS) {
+    const value = current[field];
+    if (value !== undefined) {
+      query[field] = decodeClassicText(value);
+    }
+  }
+  return query;
+}

package/src/codecs/classic/tables.ts

@@ -105,6 +105,9 @@ export const CLASSIC_SPECIAL_MODE_BITS: Record<SpecialMode, number> = {
   streamer: 4,
 };
 
+/** `type` in a discovery reply from an air conditioner's classic adapter. */
+export const CLASSIC_ADAPTER_TYPE = "aircon";
+
 /** `type` in `get_model_info` on a unit that only cools. */
 export const CLASSIC_COOLING_ONLY_TYPE = "C";
 

package/src/codecs/device.ts

@@ -1,12 +1,28 @@
 import type { DaikinDevice, DaikinDeviceInfo } from "../models/device.js";
 import { decodeClassicText } from "./classic/keyValue.js";
-import { DSIOT_ADAPTER_TYPE } from "./dsiot/tables.js";
+import { CLASSIC_ADAPTER_TYPE } from "./classic/tables.js";
+import {
+  DSIOT_ADAPTER_TYPE,
+  DSIOT_AIR_CLEANER_DEVICES,
+} from "./dsiot/tables.js";
 
 const MARVELL_ADP_KIND = "3";
 
+/** Whether a `basic_info` reply comes from the adapter of an air conditioner:
+ * `type=aircon`, or `type=GPF` with a `cdev` that is not an air cleaner's. The
+ * adapter of another appliance answers the discovery probe as well, such as
+ * an air cleaner (`type=cleaner`) or a water heater (`type=Water Heater`). */
+export function isAirConditioner(basicInfo: Record<string, string>): boolean {
+  if (basicInfo.type === DSIOT_ADAPTER_TYPE) {
+    return !DSIOT_AIR_CLEANER_DEVICES.includes(basicInfo.cdev ?? "");
+  }
+  return basicInfo.type === CLASSIC_ADAPTER_TYPE;
+}
+
 /** Turns a `basic_info` reply into a `DaikinDevice`: `type=GPF` marks a DSIOT
  * adapter, and `api_port`, when present, is the HTTP port and is appended to
- * `host`, the address the reply came from. */
+ * `host`, the address the reply came from. It reads any reply as an air
+ * conditioner's: check the reply with `isAirConditioner` first. */
 export function parseDevice(
   host: string,
   basicInfo: Record<string, string>,

package/src/codecs/dsiot/tables.ts

@@ -40,6 +40,10 @@ export const DSIOT_TARGETS = {
 /** `type` in a discovery reply from a DSIOT adapter. */
 export const DSIOT_ADAPTER_TYPE = "GPF";
 
+/** `cdev` in a discovery reply from a DSIOT adapter whose unit is an air
+ * cleaner. */
+export const DSIOT_AIR_CLEANER_DEVICES: readonly string[] = ["1D", "CJ"];
+
 /** Dotted paths into the `adp_i` and `adp_d` trees. The MAC address and the
  * version hold the value a classic adapter sends in `basic_info`, and the
  * name is plain text, where a classic adapter form-encodes it. */

package/src/discovery.ts

@@ -1,53 +1,82 @@
-import { createSocket } from "node:dgram";
+import { createSocket, type Socket } from "node:dgram";
+import { once } from "node:events";
+import { isAirbaseAdapter } from "./clients/airbase.js";
 import {
   isClassicOk,
   parseClassicKeyValue,
 } from "./codecs/classic/keyValue.js";
-import { parseDevice } from "./codecs/device.js";
+import { isAirConditioner, parseDevice } from "./codecs/device.js";
 import type { DaikinDevice } from "./models/device.js";
+import { DaikinTransport } from "./transport.js";
 
 // The UDP discovery probe: broadcast this to :30050, listen for `basic_info`
 // replies.
 const DISCOVERY_PROBE = "DAIKIN_UDP/common/basic_info";
-const DISCOVERY_SEND_PORT = 30000;
 const DISCOVERY_LISTEN_PORT = 30050;
+// An adapter answers the port a probe came from. The probe leaves from the
+// first of these ports that is free: see DESIGN.md#discovery.
+const FIRST_DISCOVERY_SEND_PORT = 30000;
+const LAST_DISCOVERY_SEND_PORT = 30050;
 
 const DEFAULT_DISCOVERY_TIMEOUT_IN_MS = 3_000;
 const BROADCAST_ADDRESS = "255.255.255.255";
 // UDP drops packets, so the probe goes out 10 times, 200 ms apart.
 const PROBE_COUNT = 10;
 const PROBE_INTERVAL_IN_MS = 200;
+// How long each of the HTTP requests that tell an Airbase adapter from a
+// classic one may take. An adapter that takes longer is reported as classic,
+// so this only bounds how long after `timeoutInMs` a discovery resolves.
+const IDENTIFY_TIMEOUT_IN_MS = 3_000;
 
 export interface DiscoverDevicesOptions {
   /** How long to listen for replies, in milliseconds. Defaults to 3000. */
   timeoutInMs?: number;
 }
 
-/** Finds the adapters on the LAN: broadcasts `DAIKIN_UDP/common/basic_info` to
- * UDP port 30050 and collects the `basic_info` replies, which carry the same
- * `key=value` payload as the HTTP `/common/basic_info`. Classic and DSIOT
- * adapters both answer, and `parseDevice` picks the protocol from the reply.
- * Anything on the LAN can send to the port it listens on, so it ignores a
- * datagram whose `ret` is not `OK`.
+/** Finds the air conditioners' adapters on the LAN: broadcasts
+ * `DAIKIN_UDP/common/basic_info` to UDP port 30050 and collects the
+ * `basic_info` replies, which carry the same `key=value` payload as the HTTP
+ * `/common/basic_info`. Classic and DSIOT adapters both answer, and
+ * `parseDevice` picks the protocol from the reply. Anything on the LAN can
+ * send to the port it listens on, so it ignores a datagram whose `ret` is not
+ * `OK`. The adapter of another appliance answers the probe as well, such as an
+ * air cleaner's, so it ignores a reply `isAirConditioner` does not pass.
  *
- * It resolves once `timeoutInMs` has passed, never earlier, with one device
- * for each `host` that replied: the address a reply came from, with the port
- * the reply announces. It binds UDP port 30000, and rejects with the socket's
- * error when the socket fails. */
+ * An Airbase adapter replies as a classic adapter does, so it sends each
+ * adapter that replies as one an HTTP request, or two, to tell which it is:
+ * an Airbase adapter answers HTTP 404 at `/common/basic_info` and `ret=OK`
+ * at `/skyfi/common/basic_info`. An adapter that does not answer in 3000 ms
+ * is reported as classic. An Airbase adapter takes no registration and no
+ * local password, so its device requires neither, whatever its reply says.
+ *
+ * It resolves once `timeoutInMs` has passed and each of those requests has
+ * finished, never earlier, with one device for each `host` that replied: the
+ * address a reply came from, with the port the reply announces. It binds the
+ * first free UDP port from 30000 to 30050, and rejects with the socket's
+ * error when none is free or the socket fails. */
 export async function discoverDevices(
   options: DiscoverDevicesOptions = {},
 ): Promise<DaikinDevice[]> {
-  const socket = createSocket({ type: "udp4", reuseAddr: true });
-  const devices = new Map<string, DaikinDevice>();
+  const socket = await bindFirstFreePort();
+  const devices = new Map<string, Promise<DaikinDevice>>();
 
   return new Promise((resolve, reject) => {
     let probesSent = 0;
-    let probeTimer: NodeJS.Timeout | undefined;
+
+    const probe = Buffer.from(DISCOVERY_PROBE, "utf8");
+    const sendProbe = () => {
+      socket.send(probe, DISCOVERY_LISTEN_PORT, BROADCAST_ADDRESS);
+      probesSent += 1;
+      if (probesSent >= PROBE_COUNT) {
+        clearInterval(probeTimer);
+      }
+    };
+    const probeTimer = setInterval(sendProbe, PROBE_INTERVAL_IN_MS);
 
     const listenTimer = setTimeout(() => {
       clearInterval(probeTimer);
       socket.close();
-      resolve([...devices.values()]);
+      resolve(Promise.all(devices.values()));
     }, options.timeoutInMs ?? DEFAULT_DISCOVERY_TIMEOUT_IN_MS);
 
     socket.on("error", (error) => {
@@ -60,7 +89,7 @@ export async function discoverDevices(
 
     socket.on("message", (message, remote) => {
       const fields = parseClassicKeyValue(message.toString("utf8"));
-      if (!isClassicOk(fields)) {
+      if (!isClassicOk(fields) || !isAirConditioner(fields)) {
         return;
       }
       // An adapter answers each of the probes, so the first reply from a
@@ -68,22 +97,62 @@ export async function discoverDevices(
       // are, differ by the port they announce.
       const device = parseDevice(remote.address, fields);
       if (!devices.has(device.host)) {
-        devices.set(device.host, device);
+        devices.set(device.host, identifyProtocol(device));
       }
     });
 
-    socket.bind(DISCOVERY_SEND_PORT, () => {
-      socket.setBroadcast(true);
-      const probe = Buffer.from(DISCOVERY_PROBE, "utf8");
-      const sendProbe = () => {
-        socket.send(probe, DISCOVERY_LISTEN_PORT, BROADCAST_ADDRESS);
-        probesSent += 1;
-        if (probesSent >= PROBE_COUNT) {
-          clearInterval(probeTimer);
-        }
-      };
-      sendProbe();
-      probeTimer = setInterval(sendProbe, PROBE_INTERVAL_IN_MS);
-    });
+    socket.setBroadcast(true);
+    sendProbe();
   });
 }
+
+// A reply does not say whether a classic adapter is an Airbase adapter, so
+// the adapter is asked over HTTP.
+async function identifyProtocol(device: DaikinDevice): Promise<DaikinDevice> {
+  if (device.protocol !== "classic") {
+    return device;
+  }
+  const transport = new DaikinTransport({
+    host: device.host,
+    usesHttps: device.usesHttps,
+    timeoutInMs: IDENTIFY_TIMEOUT_IN_MS,
+  });
+  try {
+    // `parseDevice` read the reply as a classic adapter's, which may require
+    // registration or a local password. An Airbase adapter takes neither.
+    // `usesHttps` stays: the adapter has just answered over that scheme.
+    return (await isAirbaseAdapter(transport))
+      ? {
+          ...device,
+          protocol: "airbase",
+          requiresRegistration: false,
+          requiresLocalPassword: false,
+        }
+      : device;
+  } finally {
+    await transport.close();
+  }
+}
+
+// Binds without `reuseAddr`: with it, a second socket binds a port that is
+// held, and each reply then reaches one of the two alone.
+async function bindFirstFreePort(): Promise<Socket> {
+  for (let port = FIRST_DISCOVERY_SEND_PORT; ; port += 1) {
+    const socket = createSocket("udp4");
+    try {
+      socket.bind(port);
+      // `once` rejects when the socket emits `error` first, as it does for a
+      // port that is held.
+      await once(socket, "listening");
+      return socket;
+    } catch (error) {
+      socket.close();
+      if (
+        (error as NodeJS.ErrnoException).code !== "EADDRINUSE" ||
+        port === LAST_DISCOVERY_SEND_PORT
+      ) {
+        throw error;
+      }
+    }
+  }
+}

package/src/factory.ts

@@ -3,6 +3,7 @@ import {
   type DaikinAuthentication,
   DsiotLocalPasswordAuthentication,
 } from "./authentication.js";
+import { AirbaseDaikinClient } from "./clients/airbase.js";
 import { ClassicDaikinClient } from "./clients/classic.js";
 import type { DaikinClient } from "./clients/client.js";
 import { DsiotDaikinClient } from "./clients/dsiot.js";
@@ -16,9 +17,11 @@ import {
 export interface CreateDaikinClientOptions {
   /** The terminal uuid, sent as `X-Daikin-uuid`: 32 lowercase hexadecimal
    * digits, a UUID without its dashes. Generate one and reuse it: an adapter
-   * that requires registration remembers it. */
+   * that requires registration remembers it. An Airbase adapter takes none,
+   * so it is neither checked nor sent to one. */
   terminalUuid: string;
-  /** The child lock code, for a device whose `requiresLocalPassword` is true. */
+  /** The child lock code, for a device whose `requiresLocalPassword` is true.
+   * It is not sent to an Airbase adapter, which takes none. */
   localPassword?: string;
   /** How long, in milliseconds, a request waits for the adapter. Defaults to
    * 10000: see `DaikinTransportOptions.timeoutInMs`. */
@@ -39,9 +42,10 @@ export interface CreateDaikinClientOptions {
 }
 
 /** Builds the client for a device: a `DsiotDaikinClient` when
- * `device.protocol` is `dsiot`, a `ClassicDaikinClient` otherwise. The client
- * sends over HTTPS when `device.usesHttps` is set, and sends the local
- * password when `options.localPassword` is given. It throws an `Error` when
+ * `device.protocol` is `dsiot`, an `AirbaseDaikinClient` when it is
+ * `airbase`, and a `ClassicDaikinClient` otherwise. The client sends over
+ * HTTPS when `device.usesHttps` is set, and sends the local password when
+ * `options.localPassword` is given. It throws an `Error` when
  * `options.terminalUuid` is not in the form
  * `CreateDaikinClientOptions.terminalUuid` describes. Call `close` on the
  * client when done with the unit. */
@@ -49,6 +53,18 @@ export function createDaikinClient(
   device: DaikinDevice,
   options: CreateDaikinClientOptions,
 ): DaikinClient {
+  if (device.protocol === "airbase") {
+    return new AirbaseDaikinClient(
+      new DaikinTransport({
+        host: device.host,
+        usesHttps: device.usesHttps,
+        timeoutInMs: options.timeoutInMs,
+        tls: options.tls,
+      }),
+      options.retry,
+      options.maxStateAgeForSetStateInMs,
+    );
+  }
   const transport = new DaikinTransport({
     host: device.host,
     usesHttps: device.usesHttps,

package/src/index.ts

@@ -1,7 +1,12 @@
 export type { DaikinAuthentication } from "./authentication.js";
+export { AirbaseDaikinClient } from "./clients/airbase.js";
 export * from "./clients/classic.js";
 export * from "./clients/client.js";
 export * from "./clients/dsiot.js";
+export * from "./codecs/airbase/capabilities.js";
+export * from "./codecs/airbase/state.js";
+export * from "./codecs/airbase/tables.js";
+export * from "./codecs/airbase/zone.js";
 export * from "./codecs/classic/capabilities.js";
 export * from "./codecs/classic/extendedControl.js";
 export * from "./codecs/classic/keyValue.js";
@@ -21,4 +26,5 @@ export * from "./models/capabilities.js";
 export * from "./models/device.js";
 export * from "./models/extendedControl.js";
 export * from "./models/state.js";
+export * from "./models/zone.js";
 export * from "./transport.js";

package/src/models/device.ts

@@ -1,8 +1,9 @@
-export const DAIKIN_PROTOCOLS = ["classic", "dsiot"] as const;
+export const DAIKIN_PROTOCOLS = ["classic", "dsiot", "airbase"] as const;
 
 /** The wire protocol an adapter speaks, and the only difference between
  * adapters that takes a separate `DaikinClient` implementation: `classic` for
- * a CGI adapter such as the BRP069 or BRP072, `dsiot` for a BRP084. */
+ * a CGI adapter such as the BRP069 or BRP072, `dsiot` for a BRP084, and
+ * `airbase` for the BRP15B61 of a ducted unit. */
 export type DaikinProtocol = (typeof DAIKIN_PROTOCOLS)[number];
 
 /** What an adapter reports to identify itself. `discoverDevices` fills it into

package/src/models/zone.ts

@@ -0,0 +1,8 @@
+/** One zone of a ducted unit on an Airbase adapter: a damper that opens or
+ * closes the air to part of the building. */
+export interface DaikinZone {
+  /** The name the zone was given, without the spaces around it. */
+  name: string;
+  /** Whether the zone is open. */
+  enabled: boolean;
+}