iobroker.anthbot 0.0.4 → 0.0.5

package/README.md

@@ -14,11 +14,48 @@
 
 Connect with Anthbot devices such as their robot mowers.
 
+### Monitoring
+
+Battery level is reported in the `elec` state. 
+
+View a device's status in the `mode` state (charging, mowing, standby, etc).
+
+The last status message & it's severity (event, error, etc) are shown in the `last_code`, `last_code_text` and `last_code_type` states. For users looking for more history, the `code_list` state holds a JSON array with the a larger number of messages.
+
+The rest of the states should be self explanatory.
+
+### Commands
+
+`stop_all_tasks` equates to hiting 'Stop' in the Anthbot app.
+
+`charge_start` equates to the 'Recharge' icon in the Anthbot app.
+
+`mow_start` equates to start when in 'Full maps' mode.
+
+`custom_area_mow_start` equates to custom area (aka 'Zones') mode. For this to work a valid list of area IDs must already be set in the `area_list` state. Area IDs are not the same as names the Anthbot app shows. Valid area IDs can be found in the `map.custom_areas.raw` state (this will be improved later).
+
+Ie. to start mowing one or more zones:
+
+- Set the `area_list` state to an array of IDs. Eg: `[102, 117]`
+- Trigger the `custom_area_mow_start` state.
+
+`ridable_mow_start` equates to edge mowing mode. As with `custom_area_mow_start`, set the `area_list` with a valid list of ridable areas (aka. edge) IDs. Valid ridable area IDs can be found in the `map.ridable_areas.raw` state.
+
+### Map & area (aka. zone) editing
+
+With `area_set` it is possible to edit one or more areas. Take the JSON representation from a desired entry from the `map.custom_areas.raw_list`, modify it as required and save this the `area_set` state as a JSON array.
+
+Note that when using `area_set` it is not necessary to define all parameters and only those provided will be changed. Eg: `[{"mow_head":10,"id":117}]` will change the angle of mowing in area 117 to 10 degrees and leave the other parameters as is.
+
 ## Changelog
 <!--
     Placeholder for the next version (at the beginning of the line):
     ### **WORK IN PROGRESS**
 -->
+### 0.0.5 (2026-05-20)
+ - (raintonr) Added brief usage tips in readme
+ - (raintonr) Added active_area, code_list & map states and ridable_mow_start command
+
 ### 0.0.4 (2026-05-18)
 - (copilot) Adapter requires node.js >= 22 now
 - (copilot) Adapter requires admin >= 7.7.22 now

package/io-package.json

@@ -1,8 +1,21 @@
 {
   "common": {
     "name": "anthbot",
-    "version": "0.0.4",
+    "version": "0.0.5",
     "news": {
+      "0.0.5": {
+        "en": "Added brief usage tips in readme\nAdded active_area, code_list & map states and ridable_mow_start command",
+        "de": "Kurze Nutzungstipps in readme hinzugefügt\nActive area, code list & map Zustände und ridable mow start Befehl hinzugefügt",
+        "ru": "Добавлены краткие советы по использованию в Readme\nДобавлено состояние active area, code list & map и команда ridable mow start",
+        "pt": "Adicionado breves dicas de uso no readme\nAdicionado ative  area, code  list & map states and ridable  mow  start command",
+        "nl": "Korte gebruik tips toegevoegd in readme\nActive area, code list & map states en ridable mow start commando toegevoegd",
+        "fr": "Ajout de brèves conseils d'utilisation dans readme\nAjout de la commande active area, code list & map et ridable mow start",
+        "it": "Aggiunto breve utilizzo suggerimenti in readme\nAggiunto active area, code list & mappa stati e comando ridable mow start",
+        "es": "Consejos de uso breves adicionales en el readme\nAñadido active area, code list & map states and ridable mow start command",
+        "pl": "Dodano krótkie wskazówki użycia w readme\nDodano active _ area, code _ list & map states oraz polecenie ridable _ mow _ start",
+        "uk": "Додайте поради щодо короткого використання в читме\nДодано активний area, code list & map States і ridable mow start команди",
+        "zh-cn": "在readme中添加简短的使用提示\n添加活动区域、 代码列表状态和可清除的  mow  start 命令"
+      },
       "0.0.4": {
         "en": "Adapter requires node.js >= 22 now\nAdapter requires admin >= 7.7.22 now\nHandle temporary IoT access tokens (#9)",
         "de": "Adapter benötigt node.js >= 22 jetzt\nAdapter benötigt admin >= 7.7.22 jetzt\nHandle temporäre IoT-Zugriffstoken (#9)",

package/lib/anthbotApi.js

@@ -138,7 +138,6 @@ class AnthbotCloudApiClient {
      * @param {string} username - Username
      * @param {string} password - Password
      * @param {number} areaCode - Country/region code
-     * @returns {Promise<string>} Bearer token
      */
     async asyncLogin(username, password, areaCode) {
         const url = `https://${this.endpointHost}/api/v1/login`;
@@ -187,16 +186,48 @@ class AnthbotCloudApiClient {
         const bearerToken = `Bearer ${accessToken}`;
         this.bearerToken = bearerToken;
         this.authHeaders['Authorization'] = bearerToken;
-        return bearerToken;
     }
 
     /**
-     * Make sure we have valid bearerToken
+     * Fetch JSON and resolve the service-level payload data.
+     *
+     * @param {string} url URL to fetch from
+     * @param {RequestInit} [options] Request options (method, headers, body, etc.)
+     * @returns {Promise<any>} Payload data from the response
      */
-    checkToken() {
-        if (!this.bearerToken) {
-            throw new Error('Bearer token not configured');
+    async fetchPayloadData(url, options = {}) {
+        // GET is default
+        if (!options.method) {
+            options.method = 'GET';
+        }
+
+        // Always add our auth headers
+        options.headers = { ...this.authHeaders, ...options.headers };
+
+        // Check headers given (or added above) have the Authorization (sic.)
+        if (!Object.prototype.hasOwnProperty.call(options.headers, 'Authorization')) {
+            throw new Error('Missing Authorization header');
+        }
+
+        const response = await this.fetch(url, options);
+        if (response.status !== 200) {
+            const body = await response.text();
+            throw new Error(`Request to ${url} failed (${response.status}): ${body.slice(0, 300)}`);
+        }
+
+        let payload;
+        try {
+            payload = /** @type {{code: number, data?: any}} */ (await response.json());
+        } catch {
+            throw new Error(`Invalid JSON response from ${url}`);
         }
+
+        if (typeof payload !== 'object' || payload === null) {
+            throw new Error(`Invalid API payload from ${url}`);
+        } else if (payload.code !== 0) {
+            throw new Error(`API returned code=${payload.code} from ${url}`);
+        }
+        return payload.data;
     }
 
     /**
@@ -205,19 +236,9 @@ class AnthbotCloudApiClient {
      * @returns {Promise<{alias: string, sn: string}[]>} - List of devices
      */
     async asyncGetBoundDevices() {
-        this.checkToken();
-
         const url = `https://${this.endpointHost}/api/v1/device/bind/list`;
-        const response = await this.fetch(url, {
-            method: 'GET',
-            headers: this.authHeaders,
-        });
 
-        if (response.status !== 200) {
-            throw new Error(`Request to ${url} failed, response ${response.status}`);
-        }
-
-        return /** @type {{data?: any}} */ (await response.json()).data;
+        return /** @type {{alias: string, sn: string}[]} */ (await this.fetchPayloadData(url));
     }
 
     /**
@@ -230,21 +251,10 @@ class AnthbotCloudApiClient {
      * @returns {Promise<unknown>} Latest messages
      */
     async asyncGetCodeList(serialNumber, pageNum = 1, pageSize = 1) {
-        this.checkToken();
-
         // TODO: allow language other than English?
         const url = `https://${this.endpointHost}/api/v1/device/v2/code/list?sn=${serialNumber}&pagenum=${pageNum}&pagesize=${pageSize}&language=English`;
 
-        const response = await this.fetch(url, {
-            method: 'GET',
-            headers: this.authHeaders,
-        });
-
-        if (response.status !== 200) {
-            throw new Error(`Request to ${url} failed, response ${response.status}`);
-        }
-
-        return /** @type {{data?: any}} */ (await response.json())?.data?.data;
+        return /** @type {unknown} */ ((await this.fetchPayloadData(url))?.data);
     }
 
     /**
@@ -270,8 +280,6 @@ class AnthbotCloudApiClient {
      * @returns {Promise<string>} - URL for the requested file
      */
     async asyncGetPresignedUrl(serialNumber, filename, category, sub_category) {
-        this.checkToken();
-
         const params = new URLSearchParams({
             filename,
             sn: serialNumber,
@@ -280,16 +288,8 @@ class AnthbotCloudApiClient {
             verification_token: this.buildVerificationToken(serialNumber),
         });
         const url = `https://${this.endpointHost}/api/v1/device/v2/presigned_url?${params}`;
-        const response = await this.fetch(url, {
-            method: 'GET',
-            headers: this.authHeaders,
-        });
 
-        if (response.status !== 200) {
-            throw new Error(`Request to ${url} failed, response ${response.status}`);
-        }
-
-        return /** @type {{data?: any}} */ (await response.json()).data?.presigned_url;
+        return /** @type {string} */ ((await this.fetchPayloadData(url))?.presigned_url);
     }
 
     /**
@@ -394,35 +394,10 @@ class AnthbotCloudApiClient {
             this.verboseLogger(`Cache miss - fetching device region for ${serialNumber}`);
         }
 
-        this.checkToken();
-
         const url = `https://${this.endpointHost}/api/v1/device/v2/region`;
         const params = new URLSearchParams({ sn: serialNumber });
-        const response = await this.fetch(`${url}?${params}`, {
-            method: 'GET',
-            headers: this.authHeaders,
-        });
-
-        if (response.status !== 200) {
-            const body = await response.text();
-            throw new Error(`Device region failed (${response.status}): ${body.slice(0, 300)}`);
-        }
+        const data = await this.fetchPayloadData(`${url}?${params}`);
 
-        let payload;
-        try {
-            payload = /** @type {{code: number, data?: any}} */ (await response.json());
-        } catch {
-            throw new Error('Invalid JSON response from device region');
-        }
-
-        if (typeof payload !== 'object' || payload === null) {
-            throw new Error('Invalid device region payload type');
-        }
-        if (payload.code !== 0) {
-            throw new Error(`Device region returned code=${payload.code}`);
-        }
-
-        const data = payload.data;
         if (typeof data !== 'object' || data === null) {
             throw new Error('Device region payload missing data object');
         }
@@ -450,39 +425,17 @@ class AnthbotCloudApiClient {
      * @returns {Promise<object>} - IoT credentials and expiration
      */
     async asyncGetDeviceIotCredentials(serialNumber) {
-        this.checkToken();
-
         const params = {
             sn: serialNumber,
             verification_token: this.buildVerificationToken(serialNumber),
         };
 
-        const response = await this.fetch(`https://${this.endpointHost}/api/v1/device/v2/iot/sts/arn`, {
+        const data = await this.fetchPayloadData(`https://${this.endpointHost}/api/v1/device/v2/iot/sts/arn`, {
             method: 'POST',
-            headers: { ...this.authHeaders, 'content-type': 'application/json' },
+            headers: { 'content-type': 'application/json' },
             body: JSON.stringify(params),
         });
 
-        if (response.status !== 200) {
-            const body = await response.text();
-            throw new Error(`IoT credentials failed (${response.status}): ${body.slice(0, 300)}`);
-        }
-
-        let payload;
-        try {
-            payload = /** @type {{code: number, data?: any}} */ (await response.json());
-        } catch {
-            throw new Error('Invalid JSON response from IoT credentials');
-        }
-
-        if (typeof payload !== 'object' || payload === null) {
-            throw new Error('Invalid IoT credentials payload type');
-        }
-        if (payload.code !== 0) {
-            throw new Error(`IoT credentials returned code=${payload.code}`);
-        }
-
-        const data = payload.data;
         if (typeof data !== 'object' || data === null) {
             throw new Error('IoT credentials payload missing data object');
         }
@@ -544,7 +497,7 @@ class AnthbotCloudApiClient {
      * Get shadow reported state
      *
      * @param {string} serialNumber - Device serial number
-     * @returns {Promise<unknown>} - Reported state
+     * @returns {Promise<any>} - Reported state
      */
     async asyncGetShadowReportedState(serialNumber) {
         await this.checkShadowClient(serialNumber);

package/main.js

@@ -103,7 +103,7 @@ class Anthbot extends utils.Adapter {
                                     }
                                 }
 
-                                // Overlay elements from the state onto existing zones so user only has to set
+                                // Overlay elements from the state onto existing custom areas so user only has to set
                                 // the items they are changing and rest will be preserved.
 
                                 // Variable named to match asyncSendServiceCommand data
@@ -112,7 +112,7 @@ class Anthbot extends utils.Adapter {
                                 if (!custom_areas) {
                                     this.log.error(`Bad area data in ${id}`);
                                 } else {
-                                    // Write the given area (zone) data
+                                    // Write the given custom area data
                                     this.log.info(`${device.alias}: area_set ${JSON.stringify(customAreas)}`);
                                     await this.client.asyncSendServiceCommand(serialNumber, 'area_set', {
                                         custom_areas,
@@ -125,74 +125,62 @@ class Anthbot extends utils.Adapter {
                             }
 
                             case 'custom_area_mow_start': {
-                                // Get/check command zone_list
-                                // This could be done in one shot, but get the state first for debug logging
-                                const command_zone_list_state = await this.getStateAsync(
-                                    `${device.sn}.command.zone_list`,
-                                );
-                                this.log.debug(
-                                    `Current command.zone_list state: ${JSON.stringify(command_zone_list_state)}`,
-                                );
-
-                                let command_zone_list;
-                                if (typeof command_zone_list_state?.val !== 'string') {
-                                    this.log.error('Command zone list for ${serialNumber} is not a string');
-                                } else {
-                                    try {
-                                        command_zone_list = JSON.parse(command_zone_list_state.val);
-                                    } catch (error) {
-                                        this.log.error(
-                                            `Failed to parse command zone list for ${serialNumber}: ${error.message}`,
-                                        );
-                                    }
+                                const goodAreaList = await this.isGoodAreaList(device, `map.custom_areas.raw`);
+                                if (goodAreaList) {
+                                    this.log.info(
+                                        `${device.alias}: custom_area_mow_start ${JSON.stringify(goodAreaList)}`,
+                                    );
+                                    await this.client.asyncSendServiceCommand(serialNumber, 'custom_area_mow_start', {
+                                        id: goodAreaList,
+                                    });
+                                    ackState = true;
                                 }
+                                break;
+                            }
 
-                                if (Array.isArray(command_zone_list) && command_zone_list.length > 0) {
-                                    if (!this.isGoodZoneList(device, command_zone_list)) {
-                                        this.log.error(
-                                            'Cannot start custom_area_mow_start due to invalid command.zone_list',
-                                        );
-                                    } else {
-                                        this.log.info(
-                                            `${device.alias}: custom_area_mow_start ${JSON.stringify(command_zone_list)}`,
-                                        );
-                                        await this.client.asyncSendServiceCommand(
-                                            serialNumber,
-                                            'custom_area_mow_start',
-                                            {
-                                                id: command_zone_list,
-                                            },
-                                        );
-                                        ackState = true;
-                                    }
+                            case 'ridable_mow_start': {
+                                const goodAreaList = await this.isGoodAreaList(device, `map.ridable_areas.raw`);
+                                if (goodAreaList) {
+                                    this.log.info(`${device.alias}: ridable_mow_start ${JSON.stringify(goodAreaList)}`);
+                                    await this.client.asyncSendServiceCommand(serialNumber, 'ridable_mow_start', {
+                                        id: goodAreaList,
+                                    });
+                                    ackState = true;
                                 }
                                 break;
                             }
 
-                            case 'zone_list': {
-                                let zoneList;
+                            case 'area_list': {
+                                let areaList;
                                 // This will affect the next start command only.
                                 if (typeof state?.val === 'string' && state.val !== '') {
                                     // Some kind of non-blank value given
                                     try {
-                                        zoneList = JSON.parse(state.val);
+                                        areaList = JSON.parse(state.val);
                                     } catch (error) {
-                                        this.log.error(`Failed to parse zone list for ${id}: ${error.message}`);
+                                        this.log.error(`Failed to parse area list for ${id}: ${error.message}`);
                                     }
 
-                                    // Make sure all IDs in list are valid
-                                    if (!this.isGoodZoneList(device, zoneList)) {
+                                    // Make sure this is a list & is of valid custom or ridable area IDs
+                                    if (
+                                        !areaList ||
+                                        !Array.isArray(areaList) ||
+                                        !(
+                                            (await this.isGoodAreaList(device, 'map.custom_areas.raw', areaList)) ||
+                                            (await this.isGoodAreaList(device, 'map.ridable_areas.raw', areaList))
+                                        )
+                                    ) {
                                         // Set to null so we don't ack it
-                                        zoneList = null;
+                                        areaList = null;
                                     }
                                 } else {
                                     // No value given, so ack an empty list
-                                    zoneList = [];
+                                    areaList = [];
                                 }
 
                                 // Ack only if we now have a list
-                                if (Array.isArray(zoneList)) {
-                                    ackState = JSON.stringify(zoneList);
+                                if (Array.isArray(areaList)) {
+                                    ackState = JSON.stringify(areaList);
                                     // We don't need to sync after this as no command was actually sent yet
                                     doSync = false;
                                 }
@@ -318,16 +306,6 @@ class Anthbot extends utils.Adapter {
             // Wait a second for their backend
             await new Promise(resolve => this.setTimeout(resolve, 1000, null));
 
-            // TODO: figure out how to tell when map changes and reload periodically?
-            const deviceMapFiles = await this.client.asyncGetDeviceMap(device.sn);
-
-            const areaSetting = deviceMapFiles['area_setting.json'];
-            this.log.debug(`area_setting.json: ${JSON.stringify(areaSetting)}`);
-            this.setZoneInfo(device, areaSetting?.content?.custom_areas);
-
-            const timeSetting = deviceMapFiles['time_setting.json'];
-            this.log.debug(`time_setting.json: ${JSON.stringify(timeSetting)}`);
-
             await this.pollDevice(device);
             this.pollingInterval = this.setInterval(async () => {
                 this.pollDevice(device);
@@ -357,18 +335,24 @@ class Anthbot extends utils.Adapter {
     // Poll device
     async pollDevice(device) {
         if (this.checkClient()) {
+            // Map area ID for checking for changes
+            let area_id;
+
+            // Shadow state
             try {
                 const shadowState = await this.client.asyncGetShadowReportedState(device.sn);
                 this.log.debug(`Device shadow reported state:\n${JSON.stringify(shadowState)}`);
                 await this.setShadowState(device, shadowState);
+                area_id = shadowState.map.area_id;
             } catch (err) {
                 this.log.error(`Failed to fetch shadow state for device ${device.sn}: ${err.message}`);
                 // TODO: If something goes wrong here, might not be serious, maybe don't do a full reconnect?
                 this.retryConnection();
             }
 
+            // Code list
             try {
-                const codeList = await this.client.asyncGetCodeList(device.sn);
+                const codeList = await this.client.asyncGetCodeList(device.sn, 1, 20 /* TODO: make configurable? */);
                 this.log.debug(`Device code list:\n${JSON.stringify(codeList)}`);
                 await this.setCodeList(device, codeList);
             } catch (err) {
@@ -376,243 +360,150 @@ class Anthbot extends utils.Adapter {
                 // TODO: If something goes wrong here, might not be serious, maybe don't do a full reconnect?
                 this.retryConnection();
             }
-        }
-    }
 
-    // Create objects for device
-    async createDeviceObjects(device) {
-        await this.setObjectNotExistsAsync(device.sn, {
-            type: 'device',
-            common: {
-                name: device.alias,
-            },
-            native: {},
-        });
+            // Fetch map if changed
+            if (area_id != device.area_id) {
+                this.log.info(`Device map area_id change detected, fetching new map info`);
 
-        // Shadow properties...
-        await this.setObjectNotExistsAsync(`${device.sn}.elec`, {
-            type: 'state',
-            common: {
-                name: 'elec',
-                type: 'number',
-                unit: '%',
-                desc: 'Battery level',
-                role: 'level.battery',
-                read: true,
-                write: false,
-            },
-            native: {},
-        });
+                const deviceMapFiles = await this.client.asyncGetDeviceMap(device.sn);
 
-        await this.setObjectNotExistsAsync(`${device.sn}.mode`, {
-            type: 'state',
-            common: {
-                name: 'mode',
-                type: 'string',
-                role: 'text',
-                desc: 'Current mode',
-                read: true,
-                write: false,
-            },
-            native: {},
-        });
+                const areaSetting = deviceMapFiles['area_setting.json'];
+                this.log.debug(`area_setting.json: ${JSON.stringify(areaSetting)}`);
 
-        await this.setObjectNotExistsAsync(`${device.sn}.mowing_area`, {
-            type: 'state',
-            common: {
-                name: 'mowing_area',
-                type: 'number',
-                unit: 'm²',
-                desc: 'Current mowing area',
-                role: 'value',
-                read: true,
-                write: false,
-            },
-            native: {},
-        });
+                const custom_areas = areaSetting?.content?.custom_areas;
+                this.log.debug(`custom_areas: ${JSON.stringify(custom_areas)}`);
 
-        await this.setObjectNotExistsAsync(`${device.sn}.mowing_time`, {
-            type: 'state',
-            common: {
-                name: 'mowing_time',
-                type: 'number',
-                unit: 's',
-                role: 'time.span',
-                desc: 'Current mowing time',
-                read: true,
-                write: false,
-            },
-            native: {},
-        });
+                // Stash custom_areas in the passed device
+                device.customAreas = custom_areas;
 
-        await this.setObjectNotExistsAsync(`${device.sn}.rtk_moved`, {
-            type: 'state',
-            common: {
-                name: 'rtk_moved',
-                type: 'boolean',
-                role: 'sensor.motion',
-                desc: 'RTK movement detected',
-                read: true,
-                write: false,
-            },
-            native: {},
-        });
+                // And save the state
+                this.setStateChanged(`${device.sn}.map.custom_areas.raw`, {
+                    val: JSON.stringify(custom_areas),
+                    ack: true,
+                });
 
-        await this.setObjectNotExistsAsync(`${device.sn}.rtk_state`, {
-            type: 'state',
-            common: {
-                name: 'rtk_state',
-                type: 'boolean',
-                role: 'sensor',
-                desc: 'RTK state',
-                read: true,
-                write: false,
-            },
-            native: {},
-        });
+                // Save ridable areas state
+                this.setStateChanged(`${device.sn}.map.ridable_areas.raw`, {
+                    val: JSON.stringify(areaSetting?.content?.ridable_areas),
+                    ack: true,
+                });
 
-        // Code list (aka. messages)
-        await this.setObjectNotExistsAsync(`${device.sn}.last_code`, {
-            type: 'state',
-            common: {
-                name: 'last_code',
-                type: 'number',
-                desc: 'Last code',
-                role: 'value',
-                read: true,
-                write: false,
-            },
-            native: {},
-        });
+                // TODO: plan is to create a channel for each area and store info for them indivicually.
 
-        await this.setObjectNotExistsAsync(`${device.sn}.last_code_text`, {
-            type: 'state',
-            common: {
-                name: 'last_code_text',
-                type: 'string',
-                role: 'text',
-                desc: 'Last code text',
-                read: true,
-                write: false,
-            },
-            native: {},
-        });
+                const timeSetting = deviceMapFiles['time_setting.json'];
+                this.log.debug(`time_setting.json: ${JSON.stringify(timeSetting)}`);
 
-        await this.setObjectNotExistsAsync(`${device.sn}.last_code_type`, {
-            type: 'state',
-            common: {
-                name: 'last_code_type',
-                type: 'string',
-                role: 'text',
-                desc: 'Last code type (e.g. event, error, etc.)',
-                read: true,
-                write: false,
-            },
-            native: {},
-        });
+                // And remember which area_id we loaded last
+                device.area_id = area_id;
+            }
+        }
+    }
 
-        await this.setObjectNotExistsAsync(`${device.sn}.zone_info`, {
-            type: 'state',
+    // Create objects for device
+    async createDeviceObjects(device) {
+        await this.setObjectNotExistsAsync(device.sn, {
+            type: 'device',
             common: {
-                name: 'zone_info',
-                type: 'string',
-                role: 'json',
-                desc: 'JSON object with zone information',
-                read: true,
-                write: false,
+                name: device.alias,
             },
             native: {},
         });
 
-        // Command buttons
-        await this.setObjectNotExistsAsync(`${device.sn}.command.custom_area_mow_start`, {
-            type: 'state',
-            common: {
-                name: 'start',
-                type: 'boolean',
-                role: 'button.start',
-                desc: 'Start zone mowing',
-                read: false,
-                write: true,
-            },
-            native: {},
-        });
-        await this.setObjectNotExistsAsync(`${device.sn}.command.mow_start`, {
-            type: 'state',
-            common: {
-                name: 'start',
-                type: 'boolean',
-                role: 'button.start',
-                desc: 'Start global mowing',
-                read: false,
-                write: true,
-            },
-            native: {},
-        });
-        await this.setObjectNotExistsAsync(`${device.sn}.command.stop_all_tasks`, {
-            type: 'state',
-            common: {
-                name: 'stop',
-                type: 'boolean',
-                role: 'button.stop',
-                desc: 'Stop',
-                read: false,
-                write: true,
-            },
-            native: {},
-        });
-        await this.setObjectNotExistsAsync(`${device.sn}.command.mow_pause`, {
-            type: 'state',
-            common: {
-                name: 'pause',
-                type: 'boolean',
-                role: 'button.pause',
-                desc: 'Pause',
-                read: false,
-                write: true,
-            },
-            native: {},
-        });
-        await this.setObjectNotExistsAsync(`${device.sn}.command.charge_start`, {
-            type: 'state',
-            common: {
-                name: 'home',
-                type: 'boolean',
-                role: 'button',
-                desc: 'Return home/start charging',
-                read: false,
-                write: true,
-            },
-            native: {},
-        });
+        const channels = [
+            ['command', 'Commands'],
+            ['map', 'Map info'],
+            ['map.custom_areas', 'Custom areas, aka. Zones'],
+            ['map.ridable_areas', 'Ridable areas, aka. Edges'],
+        ];
+
+        for (const channel of channels) {
+            await this.setObjectNotExistsAsync(`${device.sn}.${channel[0]}`, {
+                type: 'channel',
+                common: {
+                    name: channel[0],
+                    desc: channel[1],
+                },
+                native: {},
+            });
+        }
 
-        // Zone list for relevant commands
-        await this.setObjectNotExistsAsync(`${device.sn}.command.zone_list`, {
-            type: 'state',
-            common: {
-                name: 'zone_list',
-                type: 'array',
-                role: 'info.ids',
-                desc: `Zone list for next command (array of zone IDs, e.g. '[101,120,132]')`,
-                read: false,
-                write: true,
-            },
-            native: {},
-        });
+        const readOnlyStates = [
+            // Shadow properties
+            ['active_area', 'array', 'info.ids', 'List of areas currently being mowed'],
+            ['elec', 'number', 'level.battery', 'Battery level', '%'],
+            ['mode', 'string', 'text', 'Current mode'],
+            ['mowing_area', 'number', 'value', 'Current mowing area', 'm²'],
+            ['mowing_time', 'number', 'time.span', 'Current mowing time', 's'],
+            ['rtk_moved', 'boolean', 'sensor.motion', 'RTK movement detected'],
+            ['rtk_state', 'boolean', 'sensor', 'RTK state'],
+
+            // Code list (aka. messages)
+            // Full list for 'power users'
+            ['code_list', 'string', 'json', 'JSON object with last page of codes'],
+            // Last code for simplcity
+            ['last_code', 'number', 'value', 'Last code'],
+            ['last_code_text', 'string', 'text', 'Last code text'],
+            ['last_code_type', 'string', 'text', 'Last code type (e.g. event, error, etc.)'],
+
+            // Maps
+            ['map.area_id', 'string', 'text', 'ID of current map area'],
+            ['map.map_area', 'number', 'value', 'Surface area of map', 'm²'],
+            ['map.custom_areas.raw', 'string', 'json', 'JSON object with custom area (aka. zone) information'],
+            ['map.ridable_areas.raw', 'string', 'json', 'JSON object with ridable area (aka. edge) information'],
+        ];
+
+        for (const state of readOnlyStates) {
+            const common = {
+                name: state[0],
+                type: state[1],
+                role: state[2],
+                desc: state[3],
+                read: true,
+                write: false,
+            };
+            if (state[4]) {
+                common.unit = state[4];
+            }
+            // @ts-expect-error as 'type' below as a plain string doesn't check against ioBroker.CommonType
+            await this.setObjectNotExistsAsync(`${device.sn}.${state[0]}`, {
+                type: 'state',
+                common,
+                native: {},
+            });
+        }
 
-        // For 'area_set'
-        await this.setObjectNotExistsAsync(`${device.sn}.command.area_set`, {
-            type: 'state',
-            common: {
-                name: 'area_set',
-                type: 'string',
-                role: 'json',
-                desc: 'JSON object with zone information to write',
+        const commandStates = [
+            // Command buttons
+            ['mow_start', 'boolean', 'button.start', 'Start global mowing'],
+            ['stop_all_tasks', 'boolean', 'button.stop', 'Stop'],
+            ['mow_pause', 'boolean', 'button.pause', 'Pause'],
+            ['charge_start', 'boolean', 'button', 'Return home/start charging'],
+            ['custom_area_mow_start', 'boolean', 'button.start', 'Start custom area (aka. zone) mowing'],
+            ['ridable_mow_start', 'boolean', 'button.start', 'Start ridable area (aka. edge) mowing'],
+
+            // Area list for relevant commands
+            ['area_list', 'string', 'info.ids', `Areas for next command (array of IDs, e.g. '[101,120,132]')`],
+
+            // For 'area_set'
+            ['area_set', 'string', 'json', 'JSON object with custom area (aka. zone) information to write'],
+        ];
+
+        for (const state of commandStates) {
+            const common = {
+                name: state[0],
+                type: state[1],
+                role: state[2],
+                desc: state[3],
                 read: false,
                 write: true,
-            },
-            native: {},
-        });
+            };
+            // @ts-expect-error as 'type' below as a plain string doesn't check against ioBroker.CommonType
+            await this.setObjectNotExistsAsync(`${device.sn}.command.${state[0]}`, {
+                type: 'state',
+                common,
+                native: {},
+            });
+        }
     }
 
     // Helper function to set shadow state values
@@ -623,15 +514,24 @@ class Anthbot extends utils.Adapter {
             this.setConnected(false);
         }
 
+        this.setStateChanged(`${device.sn}.active_area`, {
+            val: JSON.stringify(shadowState.active_area.id),
+            ack: true,
+        });
         this.setStateChanged(`${device.sn}.elec`, { val: shadowState.elec.value, ack: true });
         this.setStateChanged(`${device.sn}.mode`, { val: shadowState.mode.value, ack: true });
         this.setStateChanged(`${device.sn}.mowing_area`, { val: shadowState.mowing_area.value, ack: true });
         this.setStateChanged(`${device.sn}.mowing_time`, { val: shadowState.mowing_time.value, ack: true });
         this.setStateChanged(`${device.sn}.rtk_moved`, { val: shadowState.rtk.moved == 1, ack: true });
         this.setStateChanged(`${device.sn}.rtk_state`, { val: shadowState.rtk.state == 1, ack: true });
+
+        this.setStateChanged(`${device.sn}.map.area_id`, { val: shadowState.map.area_id, ack: true });
+        this.setStateChanged(`${device.sn}.map.map_area`, { val: shadowState.map.map_area, ack: true });
     }
 
     setCodeList(device, codeList) {
+        this.setStateChanged(`${device.sn}.code_list`, { val: JSON.stringify(codeList), ack: true });
+
         const lastCode = codeList[0];
         this.setStateChanged(`${device.sn}.last_code`, { val: lastCode.code, ack: true });
         this.setStateChanged(`${device.sn}.last_code_text`, { val: lastCode.event_message, ack: true });
@@ -647,7 +547,7 @@ class Anthbot extends utils.Adapter {
             for (const area of customAreas) {
                 let outArea;
 
-                const existingArea = device.zoneList.find(zone => zone.id === area.id);
+                const existingArea = device.customAreas.find(customArea => customArea.id === area.id);
                 if (existingArea) {
                     this.log.debug(`Found existing area ${area.id} for merge: ${JSON.stringify(existingArea)}`);
                     outArea = { ...existingArea, ...area };
@@ -697,42 +597,72 @@ class Anthbot extends utils.Adapter {
         return outputAreas;
     }
 
-    isGoodZoneList(device, zoneList) {
+    parseJsonList(jsonString) {
+        let out;
+        if (typeof jsonString !== 'string') {
+            this.log.error('JSON to parse is not a string');
+        } else {
+            try {
+                out = JSON.parse(jsonString);
+            } catch (error) {
+                this.log.error(`Failed to parse JSON list: ${error.message}`);
+            }
+        }
+
         // List to check must be an array
-        if (!Array.isArray(zoneList)) {
-            this.log.error(`Invalid zone list: not an array`);
+        if (!Array.isArray(out)) {
+            this.log.error(`Invalid JSON list: not an array`);
+            out = undefined;
+        }
+
+        // List to check must have at least one item
+        if (out && out.length < 1) {
+            this.log.error(`Invalid JSON list: array is empty`);
+            out = undefined;
+        }
+
+        return out;
+    }
+
+    /**
+     *
+     * @param {object} device Device object for the check or specific list
+     * @param {string} checkListStateId State ID holding raw JSON list to check against
+     * @param {array | null} passedToCheck Optional list to check instead of fetching from command state
+     * @returns {Promise<array | false>} List if good, false if not
+     */
+
+    async isGoodAreaList(device, checkListStateId, passedToCheck = null) {
+        const listToCheck = passedToCheck
+            ? passedToCheck
+            : this.parseJsonList((await this.getStateAsync(`${device.sn}.command.area_list`))?.val);
+
+        if (!listToCheck || !Array.isArray(listToCheck)) {
+            this.log.error('Area list to check is not valid');
             return false;
         }
 
-        // If we don't even have zones for our device any list is bad
-        if (!device.zoneList) {
-            this.log.error('Invalid zone list: device has no zone info');
+        // Get IDs to check against
+        const checkAreas = this.parseJsonList((await this.getStateAsync(`${device.sn}.${checkListStateId}`))?.val);
+        // If we don't even have custom areas for our device any list is bad
+        if (!checkAreas) {
+            this.log.error(`Area list invalid: no IDs to check against in ${checkListStateId}`);
             return false;
         }
 
-        // Each zone in array must be a known zone ID
-        checkZone: for (const zoneId of zoneList) {
-            for (const zone of device.zoneList) {
-                if (zone.id === zoneId) {
-                    continue checkZone;
+        // Each area in array must be a known custom area ID
+        checkArea: for (const areaToCheck of listToCheck) {
+            for (const checkArea of checkAreas) {
+                if (checkArea.id === areaToCheck) {
+                    continue checkArea;
                 }
             }
-            // If we didn't continue, then we didn't find the zoneId in our info list, so it's not good
-            this.log.error(`Invalid zone list: ${zoneId} not found in device info`);
+            // If we didn't continue, then we didn't find the area ID in our info list, so it's not good
+            this.log.warn(`Invalid custom area list: ${areaToCheck} not found in check list ${checkListStateId}`);
             return false;
         }
 
-        return true;
-    }
-
-    setZoneInfo(device, zoneInfo) {
-        this.log.debug(`zone_info for ${device.sn}: ${JSON.stringify(zoneInfo)}`);
-
-        // Stash in the passed device
-        device.zoneList = zoneInfo;
-
-        // And save the state
-        this.setStateChanged(`${device.sn}.zone_info`, { val: JSON.stringify(zoneInfo), ack: true });
+        return listToCheck;
     }
 
     subscribeToDevice(device) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.anthbot",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Connect with Anthbot devices such as their robot mowers",
   "author": "Robin Rainton <robin@rainton.com>",
   "contributors": [