iobroker.mg-saic 0.0.2 → 0.0.4

package/README.md

@@ -1,5 +1,8 @@
 # ioBroker MG/SAIC
 
+[![NPM version](https://img.shields.io/npm/v/iobroker.mg-saic.svg)](https://www.npmjs.com/package/iobroker.mg-saic)
+[![Downloads](https://img.shields.io/npm/dm/iobroker.mg-saic.svg)](https://www.npmjs.com/package/iobroker.mg-saic)
+
 <img src="MG.png" alt="MG" width="314">
 
 The adapter is intended for connecting MG and SAIC vehicles to ioBroker through the iSmart cloud service. It is not affiliated with or endorsed by MG, SAIC, or iSmart.
@@ -8,7 +11,9 @@ The adapter is intended for connecting MG and SAIC vehicles to ioBroker through
 
 ### Before you start
 
-- Node.js 22.19.0 or later is required.
+- Node.js 24.0.0 or later is required.
+- ioBroker js-controller 7.2.2 or later is required.
+- ioBroker Admin 8.2.0 or later is required.
 - Use an iSmart account that has access to the vehicle. A separate account shared with the vehicle is recommended to avoid interfering with the mobile app session.
 - Have the account password ready. The adapter stores it as a protected setting.
 - Select the region for the account. Available regions are European Union, China, Australia, Brazil, Israel, Turkey, Thailand, and Rest of World. India is not supported.
@@ -29,9 +34,28 @@ The adapter is intended for connecting MG and SAIC vehicles to ioBroker through
 
 ## Installation
 
-The adapter is not yet available in the ioBroker adapter catalog. It can be installed through the catalog after publication.
+The adapter is published on npm but has not yet been added to the ioBroker adapter catalog.
+
+## Support
+
+[![Donate](https://camo.githubusercontent.com/ef8c60305542390406855547e32850909812a73c4abada236de22a6dc88b313f/68747470733a2f2f7777772e70617970616c6f626a656374732e636f6d2f64655f44452f44452f692f62746e2f62746e5f646f6e61746543435f4c472e676966)](https://www.paypal.com/donate/?hosted_button_id=3RJQGSJNRSHUJ)
 
 ## Changelog
+### 0.0.4 (2026-10-24)
+
+- (Voodoo2man) Corrected GPS coordinates.
+- (Voodoo2man) Fixed incorrect datapoint values.
+- (Voodoo2man) Removed duplicate and irrelevant datapoints.
+- (Voodoo2man) Set min version of admin to 8.2.0, js-controller 7.2.2, node.js 24
+
+### 0.0.3 (2026-10-21)
+
+- (Voodoo2man) Improved release automation, updated Node.js release checks, and removed unpublished version metadata.
+- (Voodoo2man) Added charging data
+- (Voodoo2man) Fixed vehicle datapoint units and roles
+
+Older changelog entries are available in [CHANGELOG_OLD.md](CHANGELOG_OLD.md).
+
 ### 0.0.2 (2026-10-20)
 
 - (Voodoo2man) Added regional iSmart account setup, vehicle status, and supported remote controls.

package/build/main.js

@@ -26,8 +26,13 @@ var import_config = require("./config");
 var import_saic_client = require("./saic-client");
 var import_regions = require("./regions");
 var import_refresh_command = require("./refresh-command");
+var import_pending_setting_edits = require("./pending-setting-edits");
 var import_status_metadata = require("./status-metadata");
 var import_runtime_translations = require("./runtime-translations");
+const chargingGroups = [
+  { source: "chrgMgmtData", id: "session", name: "chargingManagement" },
+  { source: "rvsChargeStatus", id: "statistics", name: "chargeStatus" }
+];
 const vehicleCommands = [
   { id: "lock" },
   { id: "unlock" },
@@ -68,16 +73,16 @@ const settingGroups = {
   climateTemperature: "climate",
   chargeTargetSoc: "charging",
   chargingCurrentLimit: "charging",
-  chargingScheduleStart: "schedules",
-  chargingScheduleEnd: "schedules",
-  chargingScheduleMode: "schedules",
+  chargingScheduleStart: "charging",
+  chargingScheduleEnd: "charging",
+  chargingScheduleMode: "charging",
   batteryHeatingScheduleEnabled: "schedules",
   batteryHeatingScheduleStart: "schedules"
 };
 const actionGroups = {
   climateTemperatureApply: "climate",
   chargingSettingsApply: "charging",
-  chargingScheduleApply: "schedules",
+  chargingScheduleApply: "charging",
   batteryHeatingScheduleApply: "schedules"
 };
 function vehicleCommandPath(vin, id) {
@@ -93,6 +98,12 @@ const settingActions = [
   { id: "chargingScheduleApply" },
   { id: "batteryHeatingScheduleApply" }
 ];
+const settingInputsByAction = {
+  climateTemperatureApply: ["climateTemperature"],
+  chargingSettingsApply: ["chargeTargetSoc", "chargingCurrentLimit"],
+  chargingScheduleApply: ["chargingScheduleStart", "chargingScheduleEnd", "chargingScheduleMode"],
+  batteryHeatingScheduleApply: ["batteryHeatingScheduleEnabled", "batteryHeatingScheduleStart"]
+};
 const EXPOSE_SOURCE_STATUS_DATAPOINTS = false;
 class MgSaic extends utils.Adapter {
   constructor(options = {}) {
@@ -118,6 +129,9 @@ class MgSaic extends utils.Adapter {
   lastStatusTimes = /* @__PURE__ */ new Map();
   lastCanonicalStatusTimes = /* @__PURE__ */ new Map();
   vehicleCommandsInProgress = /* @__PURE__ */ new Set();
+  pendingSettingEdits = /* @__PURE__ */ new Map();
+  pendingSettingEditsWrite = Promise.resolve();
+  settingEditSequence = 0;
   async onReady() {
     var _a, _b, _c, _d, _e;
     if (this.stopping) {
@@ -128,6 +142,26 @@ class MgSaic extends utils.Adapter {
     await this.extendObjectAsync("info.backend", { common: { name: (0, import_runtime_translations.getRuntimeName)("backend") } });
     await this.extendObjectAsync("info.connection", { common: { name: (0, import_runtime_translations.getRuntimeName)("connection") } });
     await this.extendObjectAsync("info.lastError", { common: { name: (0, import_runtime_translations.getRuntimeName)("lastError") } });
+    await this.setObjectNotExistsAsync("internal", {
+      type: "channel",
+      common: { name: "Internal" },
+      native: {}
+    });
+    await this.setObjectNotExistsAsync("internal.pendingSettingEdits", {
+      type: "state",
+      common: { name: "Pending setting edits", type: "string", role: "json", read: true, write: false },
+      native: {}
+    });
+    await this.setObjectNotExistsAsync("commands", {
+      type: "channel",
+      common: { name: (0, import_runtime_translations.getRuntimeName)("commands") },
+      native: {}
+    });
+    await this.setObjectAsync("vehicles", {
+      type: "folder",
+      common: { name: "Vehicles" },
+      native: {}
+    });
     await this.setObjectNotExistsAsync("commands.refresh", {
       type: "state",
       common: {
@@ -216,6 +250,7 @@ class MgSaic extends utils.Adapter {
         }
         await this.delObjectAsync(`vehicles.${vehicle.vin}.canonicalStatus`, { recursive: true });
       }
+      await this.restorePendingSettingEdits();
       await this.setState("info.connection", true, true);
       this.log.info(`SAIC account authenticated; discovered ${this.vehicles.length} vehicle(s).`);
       if (this.vehicles.length === 0) {
@@ -287,6 +322,22 @@ class MgSaic extends utils.Adapter {
               break;
             }
           }
+          try {
+            const charging = await this.client.getVehicleChargingStatus(
+              this.loginOptions,
+              this.accessToken,
+              vehicle.vin,
+              this.abortController.signal
+            );
+            await this.createVehicleChargingObjects(vehicle.vin, charging);
+          } catch (error) {
+            if (this.stopping) {
+              break;
+            }
+            const details = error instanceof Error ? error.message : "Unknown charging data error";
+            statusErrors.push(`Charging data request failed for ${vehicle.vin}: ${details}`);
+            this.log.warn(`Could not retrieve charging data for vehicle ${vehicle.vin}: ${details}`);
+          }
           let status;
           try {
             this.log.debug(`Refreshing live status for ${vehicle.vin}`);
@@ -372,6 +423,33 @@ class MgSaic extends utils.Adapter {
             statusErrors.push(`Ignored older live status for ${vehicle.vin}`);
             continue;
           }
+          if (status.basicVehicleStatus.mileage === void 0) {
+            try {
+              const cachedStatus = await this.client.getCachedVehicleStatus(
+                this.loginOptions,
+                this.accessToken,
+                vehicle.vin,
+                this.abortController.signal
+              );
+              const cachedMileage = cachedStatus.basicVehicleStatus.mileage;
+              const mileage = (0, import_status_metadata.resolveOdometerValue)(void 0, cachedMileage);
+              if (mileage !== void 0) {
+                status = {
+                  ...status,
+                  basicVehicleStatus: { ...status.basicVehicleStatus, mileage }
+                };
+                this.log.debug(
+                  `Used cached odometer for ${vehicle.vin} because live status omitted mileage`
+                );
+              }
+            } catch (cacheError) {
+              if (this.stopping) {
+                break;
+              }
+              const details = cacheError instanceof Error ? cacheError.message : "Unknown cache error";
+              this.log.debug(`Could not retrieve cached odometer for ${vehicle.vin}: ${details}`);
+            }
+          }
           try {
             this.log.debug(
               `Received live status for ${vehicle.vin}: ${Object.keys(status.basicVehicleStatus).length} basic fields, statusTime ${(_a = status.statusTime) != null ? _a : "missing"}`
@@ -413,6 +491,7 @@ class MgSaic extends utils.Adapter {
     if (this.stopping) {
       return;
     }
+    const eventId = (0, import_refresh_command.normalizeStateChangeId)(id, this.namespace);
     if ((0, import_refresh_command.isRefreshCommand)(id, this.namespace, state)) {
       void this.setStateAsync("commands.refresh", { val: false, ack: true }).catch((error) => {
         const details = error instanceof Error ? error.message : "Unknown state error";
@@ -425,10 +504,10 @@ class MgSaic extends utils.Adapter {
       return;
     }
     const settingAction = settingActions.find(
-      ({ id: actionId }) => this.vehicles.some(({ vin }) => id === `${this.namespace}.${vehicleCommandPath(vin, actionId)}`)
+      ({ id: actionId }) => this.vehicles.some(({ vin }) => eventId === `${this.namespace}.${vehicleCommandPath(vin, actionId)}`)
     );
     const settingVehicle = this.vehicles.find(
-      ({ vin }) => settingAction && id === `${this.namespace}.${vehicleCommandPath(vin, settingAction.id)}`
+      ({ vin }) => settingAction && eventId === `${this.namespace}.${vehicleCommandPath(vin, settingAction.id)}`
     );
     if (settingAction && settingVehicle) {
       void this.executeVehicleSetting(settingVehicle.vin, settingAction.id);
@@ -436,17 +515,16 @@ class MgSaic extends utils.Adapter {
     }
     const settingInput = this.vehicles.flatMap(
       ({ vin }) => Object.keys(settingGroups).filter((stateId) => stateId !== "driverSeatHeatLevel" && stateId !== "passengerSeatHeatLevel").map((stateId) => ({ vin, stateId }))
-    ).find(({ vin, stateId }) => id === `${this.namespace}.${vehicleCommandPath(vin, stateId)}`);
+    ).find(({ vin, stateId }) => eventId === `${this.namespace}.${vehicleCommandPath(vin, stateId)}`);
     if (settingInput) {
-      void this.setStateAsync(vehicleCommandPath(settingInput.vin, settingInput.stateId), {
-        val: state.val,
-        ack: true
-      });
+      const stateId = vehicleCommandPath(settingInput.vin, settingInput.stateId);
+      this.pendingSettingEdits.set(stateId, ++this.settingEditSequence);
+      void this.acknowledgeSettingEdit(stateId, state.val);
       return;
     }
     const seatHeating = this.vehicles.flatMap(
       ({ vin }) => ["driverSeatHeatLevel", "passengerSeatHeatLevel"].map((stateId) => ({ vin, stateId }))
-    ).find(({ vin, stateId }) => id === `${this.namespace}.${vehicleCommandPath(vin, stateId)}`);
+    ).find(({ vin, stateId }) => eventId === `${this.namespace}.${vehicleCommandPath(vin, stateId)}`);
     if (seatHeating) {
       const seat = seatHeating.stateId === "driverSeatHeatLevel" ? "driver" : "passenger";
       void this.executeSeatHeating(seatHeating.vin, seat, state.val);
@@ -456,16 +534,51 @@ class MgSaic extends utils.Adapter {
       return;
     }
     const commandEntry = vehicleCommands.find(
-      ({ id: commandId }) => this.vehicles.some(({ vin }) => id === `${this.namespace}.${vehicleCommandPath(vin, commandId)}`)
+      ({ id: commandId }) => this.vehicles.some(({ vin }) => eventId === `${this.namespace}.${vehicleCommandPath(vin, commandId)}`)
     );
     const vehicle = this.vehicles.find(
-      ({ vin }) => commandEntry && id === `${this.namespace}.${vehicleCommandPath(vin, commandEntry.id)}`
+      ({ vin }) => commandEntry && eventId === `${this.namespace}.${vehicleCommandPath(vin, commandEntry.id)}`
     );
     if (!commandEntry || !vehicle) {
       return;
     }
     void this.executeVehicleCommand(vehicle.vin, commandEntry.id);
   }
+  async acknowledgeSettingEdit(stateId, value) {
+    try {
+      await this.persistPendingSettingEdits();
+      await this.setStateAsync(stateId, { val: value, ack: true });
+    } catch (error) {
+      const details = error instanceof Error ? error.message : "Unknown state error";
+      this.log.error(`Could not persist pending setting ${stateId}: ${details}`);
+    }
+  }
+  async persistPendingSettingEdits() {
+    const serialized = (0, import_pending_setting_edits.serializePendingSettingEdits)(this.pendingSettingEdits.keys());
+    const write = this.pendingSettingEditsWrite.catch(() => void 0).then(async () => {
+      await this.setStateAsync("internal.pendingSettingEdits", { val: serialized, ack: true });
+    });
+    this.pendingSettingEditsWrite = write;
+    await write;
+  }
+  async restorePendingSettingEdits() {
+    const validStateIds = new Set(
+      this.vehicles.flatMap(
+        ({ vin }) => Object.keys(settingGroups).filter((stateId) => stateId !== "driverSeatHeatLevel" && stateId !== "passengerSeatHeatLevel").map((stateId) => vehicleCommandPath(vin, stateId))
+      )
+    );
+    const savedState = await this.getStateAsync("internal.pendingSettingEdits");
+    for (const stateId of (0, import_pending_setting_edits.parsePendingSettingEdits)(savedState == null ? void 0 : savedState.val, validStateIds)) {
+      this.pendingSettingEdits.set(stateId, ++this.settingEditSequence);
+    }
+    for (const stateId of validStateIds) {
+      const currentState = await this.getStateAsync(stateId);
+      if (currentState && !currentState.ack && !this.pendingSettingEdits.has(stateId)) {
+        this.pendingSettingEdits.set(stateId, ++this.settingEditSequence);
+      }
+    }
+    await this.persistPendingSettingEdits();
+  }
   async executeSeatHeating(vin, seat, value) {
     const stateId = vehicleCommandPath(vin, `${seat}SeatHeatLevel`);
     if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > 3) {
@@ -508,6 +621,9 @@ class MgSaic extends utils.Adapter {
   }
   async executeVehicleSetting(vin, action) {
     const stateId = vehicleCommandPath(vin, action);
+    const editVersions = new Map(
+      settingInputsByAction[action].map((settingId) => vehicleCommandPath(vin, settingId)).filter((settingId) => this.pendingSettingEdits.has(settingId)).map((settingId) => [settingId, this.pendingSettingEdits.get(settingId)])
+    );
     if (this.vehicleCommandsInProgress.has(vin)) {
       await this.setStateAsync(stateId, { val: false, ack: true });
       this.log.warn(`Ignored ${action} for ${vin}: another vehicle command is still running`);
@@ -530,6 +646,26 @@ class MgSaic extends utils.Adapter {
         setting,
         this.abortController.signal
       );
+      const clearedEdits = [];
+      for (const [settingId, version] of editVersions) {
+        if (this.pendingSettingEdits.get(settingId) === version) {
+          this.pendingSettingEdits.delete(settingId);
+          clearedEdits.push([settingId, version]);
+        }
+      }
+      try {
+        await this.persistPendingSettingEdits();
+      } catch (error) {
+        for (const [settingId, version] of clearedEdits) {
+          if (!this.pendingSettingEdits.has(settingId)) {
+            this.pendingSettingEdits.set(settingId, version);
+          }
+        }
+        const details = error instanceof Error ? error.message : "Unknown state error";
+        this.log.warn(
+          `SAIC ${action} completed for ${vin}, but pending edits could not be persisted: ${details}`
+        );
+      }
       this.log.info(`SAIC ${action} completed for ${vin}`);
     } catch (error) {
       if (!this.stopping) {
@@ -628,6 +764,10 @@ class MgSaic extends utils.Adapter {
       return;
     }
     const statusId = `vehicles.${vin}.${channel}`;
+    for (const key of import_status_metadata.excludedVehicleStatusFields) {
+      const stateId = `${statusId}.${(0, import_status_metadata.getVehicleStatusGroup)(key)}.${key}`;
+      await this.delObjectAsync(stateId);
+    }
     await this.setObjectNotExistsAsync(statusId, {
       type: "channel",
       common: { name: (0, import_runtime_translations.getRuntimeName)(channelName) },
@@ -649,8 +789,29 @@ class MgSaic extends utils.Adapter {
       if (this.stopping) {
         return;
       }
+      if (import_status_metadata.excludedVehicleStatusFields.some((excludedKey) => excludedKey === key)) {
+        await this.delObjectAsync(`${statusId}.${(0, import_status_metadata.getVehicleStatusGroup)(key)}.${key}`);
+        continue;
+      }
       const group = (0, import_status_metadata.getVehicleStatusGroup)(key);
       const groupId = `${statusId}.${group}`;
+      const stateId = `${groupId}.${key}`;
+      if (value === void 0) {
+        if ((0, import_status_metadata.shouldDeleteUnavailableStatusValue)(key)) {
+          await this.delObjectAsync(stateId);
+        } else {
+          const previousState = await this.getStateAsync(stateId);
+          if ((previousState == null ? void 0 : previousState.val) === null) {
+            await this.delObjectAsync(stateId);
+          }
+        }
+        continue;
+      }
+      const normalizedValue = (0, import_status_metadata.normalizeVehicleStatusValue)(key, value);
+      if (normalizedValue === void 0) {
+        await this.delObjectAsync(stateId);
+        continue;
+      }
       await this.setObjectNotExistsAsync(groupId, {
         type: "channel",
         common: { name: (0, import_runtime_translations.getRuntimeName)(group) },
@@ -661,7 +822,6 @@ class MgSaic extends utils.Adapter {
         return;
       }
       const metadata = (0, import_status_metadata.getVehicleStatusMetadata)(key);
-      const stateId = `${groupId}.${key}`;
       const common = {
         name: metadata.name,
         type: metadata.type,
@@ -686,13 +846,107 @@ class MgSaic extends utils.Adapter {
       if (this.stopping) {
         return;
       }
-      await this.setStateAsync(stateId, { val: (0, import_status_metadata.normalizeVehicleStatusValue)(key, value), ack: true });
+      await this.setStateAsync(stateId, { val: normalizedValue, ack: true });
       if (this.stopping) {
         return;
       }
+      const seatSetting = key === "frontLeftSeatHeatLevel" ? "driverSeatHeatLevel" : key === "frontRightSeatHeatLevel" ? "passengerSeatHeatLevel" : void 0;
+      if (seatSetting && Number.isInteger(value) && value >= 0 && value <= 3) {
+        const settingId = vehicleCommandPath(vin, seatSetting);
+        const settingState = await this.getStateAsync(settingId);
+        if (!settingState || settingState.ack) {
+          await this.setStateAsync(settingId, { val: value, ack: true });
+        }
+      }
       await this.delObjectAsync(`${statusId}.${key}`);
     }
   }
+  async createVehicleChargingObjects(vin, charging) {
+    await this.ensureVehicleChargingGroups(vin);
+    const rootId = `vehicles.${vin}.status.charging`;
+    for (const { source, id } of chargingGroups) {
+      const groupId = `${rootId}.${id}`;
+      const excludedFields = id === "session" ? import_status_metadata.excludedChargingSessionFields : import_status_metadata.excludedChargingStatisticsFields;
+      for (const field of excludedFields) {
+        await this.delObjectAsync(`${groupId}.${field}`);
+      }
+      for (const [field, value] of Object.entries(charging[source])) {
+        if (this.stopping) {
+          return;
+        }
+        if (excludedFields.some((excludedField) => excludedField === field)) {
+          await this.delObjectAsync(`${groupId}.${field}`);
+          continue;
+        }
+        const stateId = `${groupId}.${field}`;
+        if (value === void 0) {
+          await this.delObjectAsync(stateId);
+          continue;
+        }
+        const metadata = (0, import_status_metadata.getChargingFieldMetadata)(field);
+        const common = {
+          name: (0, import_runtime_translations.getChargingFieldName)(field),
+          type: metadata.type === "boolean" ? "boolean" : typeof value === "string" ? "string" : "number",
+          role: typeof value === "string" ? "text" : metadata.role,
+          read: true,
+          write: false
+        };
+        if (metadata.unit) {
+          common.unit = metadata.unit;
+        }
+        await this.setObjectNotExistsAsync(stateId, { type: "state", common, native: {} });
+        await this.extendObjectAsync(stateId, { common });
+        await this.setStateAsync(stateId, {
+          val: (0, import_status_metadata.normalizeChargingValue)(field, value),
+          ack: true
+        });
+        if (field === "bmsOnBdChrgTrgtSOCDspCmd" && typeof value === "number" && value >= 1 && value <= 7) {
+          const targetSocId = vehicleCommandPath(vin, "chargeTargetSoc");
+          const targetSocState = await this.getStateAsync(targetSocId);
+          if ((0, import_status_metadata.shouldApplySettingFeedback)(targetSocState, this.pendingSettingEdits.has(targetSocId))) {
+            await this.setStateAsync(targetSocId, {
+              val: (0, import_status_metadata.normalizeChargingValue)(field, value),
+              ack: true
+            });
+          }
+        }
+      }
+    }
+    for (const [setting, value] of Object.entries((0, import_status_metadata.getChargingSettingFeedback)(charging.chrgMgmtData))) {
+      const stateId = vehicleCommandPath(vin, setting);
+      const state = await this.getStateAsync(stateId);
+      if ((0, import_status_metadata.shouldApplySettingFeedback)(state, this.pendingSettingEdits.has(stateId))) {
+        await this.setStateAsync(stateId, { val: value, ack: true });
+      }
+    }
+    await this.delObjectAsync(`vehicles.${vin}.charging`, { recursive: true });
+  }
+  async ensureVehicleChargingGroups(vin) {
+    const statusId = `vehicles.${vin}.status`;
+    const rootId = `${statusId}.charging`;
+    await this.setObjectNotExistsAsync(statusId, {
+      type: "channel",
+      common: { name: (0, import_runtime_translations.getRuntimeName)("currentStatus") },
+      native: {}
+    });
+    await this.setObjectNotExistsAsync(rootId, {
+      type: "channel",
+      common: { name: (0, import_runtime_translations.getRuntimeName)("commandGroup_charging") },
+      native: {}
+    });
+    await this.extendObjectAsync(rootId, { common: { name: (0, import_runtime_translations.getRuntimeName)("commandGroup_charging") } });
+    for (const { source, id, name } of chargingGroups) {
+      const groupId = `${rootId}.${id}`;
+      const groupName = (0, import_runtime_translations.getRuntimeName)(name);
+      await this.setObjectNotExistsAsync(groupId, {
+        type: "channel",
+        common: { name: groupName },
+        native: {}
+      });
+      await this.extendObjectAsync(groupId, { common: { name: groupName } });
+      await this.delObjectAsync(`${rootId}.${source}`, { recursive: true });
+    }
+  }
   async createCanonicalVehicleStatusObjects(vin, status, source) {
     if (this.stopping || !(0, import_saic_client.isVehicleStatusNotOlder)(status.statusTime, this.lastCanonicalStatusTimes.get(vin))) {
       return;
@@ -733,7 +987,7 @@ class MgSaic extends utils.Adapter {
     }
   }
   async createVehicleObjects(vehicle) {
-    var _a;
+    var _a, _b;
     if (this.stopping) {
       return;
     }
@@ -757,6 +1011,7 @@ class MgSaic extends utils.Adapter {
     if (this.stopping) {
       return;
     }
+    await this.ensureVehicleChargingGroups(vehicle.vin);
     const commandsId = `${deviceId}.commands`;
     await this.setObjectNotExistsAsync(commandsId, {
       type: "channel",
@@ -843,13 +1098,13 @@ class MgSaic extends utils.Adapter {
       {
         id: "chargingScheduleStart",
         type: "string",
-        role: "value.time",
+        role: "text",
         def: "00:00"
       },
       {
         id: "chargingScheduleEnd",
         type: "string",
-        role: "value.time",
+        role: "text",
         def: "06:00"
       },
       {
@@ -870,7 +1125,7 @@ class MgSaic extends utils.Adapter {
       {
         id: "batteryHeatingScheduleStart",
         type: "string",
-        role: "value.time",
+        role: "text",
         def: "00:00"
       }
     ];
@@ -879,6 +1134,7 @@ class MgSaic extends utils.Adapter {
       const legacyStateId = `${commandsId}.${setting.id}`;
       const stateObject = await this.getObjectAsync(stateId);
       const legacyState = await this.getStateAsync(legacyStateId);
+      const previousScheduleState = setting.id.startsWith("chargingSchedule") ? await this.getStateAsync(`${commandsId}.schedules.${setting.id}`) : null;
       await this.setObjectNotExistsAsync(stateId, {
         type: "state",
         common: {
@@ -898,7 +1154,10 @@ class MgSaic extends utils.Adapter {
       });
       const currentState = await this.getStateAsync(stateId);
       if (!currentState || currentState.val === null) {
-        await this.setStateAsync(stateId, { val: (_a = legacyState == null ? void 0 : legacyState.val) != null ? _a : setting.def, ack: true });
+        await this.setStateAsync(stateId, {
+          val: (_b = (_a = legacyState == null ? void 0 : legacyState.val) != null ? _a : previousScheduleState == null ? void 0 : previousScheduleState.val) != null ? _b : setting.def,
+          ack: true
+        });
       } else if (typeof currentState.val === "number" && (stateObject == null ? void 0 : stateObject.common.unit) !== setting.unit) {
         if (setting.id === "chargeTargetSoc" && currentState.val >= 1 && currentState.val <= 7) {
           await this.setStateAsync(stateId, { val: (currentState.val + 3) * 10, ack: true });
@@ -934,6 +1193,14 @@ class MgSaic extends utils.Adapter {
       await this.setStateAsync(actionId, { val: false, ack: true });
       await this.delObjectAsync(`${commandsId}.${action.id}`);
     }
+    for (const id of [
+      "chargingScheduleStart",
+      "chargingScheduleEnd",
+      "chargingScheduleMode",
+      "chargingScheduleApply"
+    ]) {
+      await this.delObjectAsync(`${commandsId}.schedules.${id}`);
+    }
     for (const command of vehicleCommands) {
       await this.delObjectAsync(`${commandsId}.${command.id}`);
     }