src/charging-station/ocpp/1.6/OCPP16RequestService.ts

   1 import { ACElectricUtils, DCElectricUtils } from '../../../utils/ElectricUtils';
   2 import { AuthorizeRequest, OCPP16AuthorizeResponse, OCPP16StartTransactionResponse, OCPP16StopTransactionReason, OCPP16StopTransactionResponse, StartTransactionRequest, StopTransactionRequest } from '../../../types/ocpp/1.6/Transaction';
   3 import { CurrentType, Voltage } from '../../../types/ChargingStationTemplate';
   4 import { HeartbeatRequest, OCPP16BootNotificationRequest, OCPP16IncomingRequestCommand, OCPP16RequestCommand, StatusNotificationRequest } from '../../../types/ocpp/1.6/Requests';
   5 import { MeterValueUnit, MeterValuesRequest, OCPP16MeterValue, OCPP16MeterValueMeasurand, OCPP16MeterValuePhase } from '../../../types/ocpp/1.6/MeterValues';
   6
   7 import Constants from '../../../utils/Constants';
   8 import MeasurandPerPhaseSampledValueTemplates from '../../../types/MeasurandPerPhaseSampledValueTemplates';
   9 import MeasurandValues from '../../../types/MeasurandValues';
  10 import { MessageType } from '../../../types/ocpp/MessageType';
  11 import { OCPP16BootNotificationResponse } from '../../../types/ocpp/1.6/Responses';
  12 import { OCPP16ChargePointErrorCode } from '../../../types/ocpp/1.6/ChargePointErrorCode';
  13 import { OCPP16ChargePointStatus } from '../../../types/ocpp/1.6/ChargePointStatus';
  14 import { OCPP16ServiceUtils } from './OCPP16ServiceUtils';
  15 import OCPPError from '../../OcppError';
  16 import OCPPRequestService from '../OCPPRequestService';
  17 import Utils from '../../../utils/Utils';
  18 import logger from '../../../utils/Logger';
  19
  20 export default class OCPP16RequestService extends OCPPRequestService {
  21   public async sendHeartbeat(): Promise<void> {
  22     try {
  23       const payload: HeartbeatRequest = {};
  24       await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, OCPP16RequestCommand.HEARTBEAT);
  25     } catch (error) {
  26       this.handleRequestError(OCPP16RequestCommand.HEARTBEAT, error);
  27     }
  28   }
  29
  30   public async sendBootNotification(chargePointModel: string, chargePointVendor: string, chargeBoxSerialNumber?: string, firmwareVersion?: string,
  31       chargePointSerialNumber?: string, iccid?: string, imsi?: string, meterSerialNumber?: string, meterType?: string): Promise<OCPP16BootNotificationResponse> {
  32     try {
  33       const payload: OCPP16BootNotificationRequest = {
  34         chargePointModel,
  35         chargePointVendor,
  36         ...!Utils.isUndefined(chargeBoxSerialNumber) && { chargeBoxSerialNumber },
  37         ...!Utils.isUndefined(chargePointSerialNumber) && { chargePointSerialNumber },
  38         ...!Utils.isUndefined(firmwareVersion) && { firmwareVersion },
  39         ...!Utils.isUndefined(iccid) && { iccid },
  40         ...!Utils.isUndefined(imsi) && { imsi },
  41         ...!Utils.isUndefined(meterSerialNumber) && { meterSerialNumber },
  42         ...!Utils.isUndefined(meterType) && { meterType }
  43       };
  44       return await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, OCPP16RequestCommand.BOOT_NOTIFICATION) as OCPP16BootNotificationResponse;
  45     } catch (error) {
  46       this.handleRequestError(OCPP16RequestCommand.BOOT_NOTIFICATION, error);
  47     }
  48   }
  49
  50   public async sendStatusNotification(connectorId: number, status: OCPP16ChargePointStatus,
  51       errorCode: OCPP16ChargePointErrorCode = OCPP16ChargePointErrorCode.NO_ERROR): Promise<void> {
  52     try {
  53       const payload: StatusNotificationRequest = {
  54         connectorId,
  55         errorCode,
  56         status,
  57       };
  58       await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, OCPP16RequestCommand.STATUS_NOTIFICATION);
  59     } catch (error) {
  60       this.handleRequestError(OCPP16RequestCommand.STATUS_NOTIFICATION, error);
  61     }
  62   }
  63
  64   public async sendAuthorize(connectorId: number, idTag?: string): Promise<OCPP16AuthorizeResponse> {
  65     try {
  66       const payload: AuthorizeRequest = {
  67         ...!Utils.isUndefined(idTag) ? { idTag } : { idTag: Constants.TRANSACTION_DEFAULT_IDTAG },
  68       };
  69       this.chargingStation.getConnector(connectorId).authorizeIdTag = idTag;
  70       return await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, OCPP16RequestCommand.AUTHORIZE) as OCPP16AuthorizeResponse;
  71     } catch (error) {
  72       this.handleRequestError(OCPP16RequestCommand.AUTHORIZE, error);
  73     }
  74   }
  75
  76   public async sendStartTransaction(connectorId: number, idTag?: string): Promise<OCPP16StartTransactionResponse> {
  77     try {
  78       const payload: StartTransactionRequest = {
  79         connectorId,
  80         ...!Utils.isUndefined(idTag) ? { idTag } : { idTag: Constants.TRANSACTION_DEFAULT_IDTAG },
  81         meterStart: this.chargingStation.getEnergyActiveImportRegisterByConnectorId(connectorId),
  82         timestamp: new Date().toISOString(),
  83       };
  84       return await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, OCPP16RequestCommand.START_TRANSACTION) as OCPP16StartTransactionResponse;
  85     } catch (error) {
  86       this.handleRequestError(OCPP16RequestCommand.START_TRANSACTION, error);
  87     }
  88   }
  89
  90   public async sendStopTransaction(transactionId: number, meterStop: number, idTag?: string,
  91       reason: OCPP16StopTransactionReason = OCPP16StopTransactionReason.NONE): Promise<OCPP16StopTransactionResponse> {
  92     try {
  93       let connectorId: number;
  94       for (const connector in this.chargingStation.connectors) {
  95         if (Utils.convertToInt(connector) > 0 && this.chargingStation.getConnector(Utils.convertToInt(connector))?.transactionId === transactionId) {
  96           connectorId = Utils.convertToInt(connector);
  97           break;
  98         }
  99       }
 100       const transactionEndMeterValue = OCPP16ServiceUtils.buildTransactionEndMeterValue(this.chargingStation, connectorId, meterStop);
 101       // FIXME: should be a callback, each OCPP commands implementation must do only one job
 102       (this.chargingStation.getBeginEndMeterValues() && !this.chargingStation.getOutOfOrderEndMeterValues())
 103         && await this.sendTransactionEndMeterValues(connectorId, transactionId, transactionEndMeterValue);
 104       const payload: StopTransactionRequest = {
 105         transactionId,
 106         ...!Utils.isUndefined(idTag) && { idTag },
 107         meterStop,
 108         timestamp: new Date().toISOString(),
 109         ...reason && { reason },
 110         ...this.chargingStation.getTransactionDataMeterValues() && { transactionData: OCPP16ServiceUtils.buildTransactionDataMeterValues(this.chargingStation.getConnector(connectorId).transactionBeginMeterValue, transactionEndMeterValue) },
 111       };
 112       return await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, OCPP16RequestCommand.STOP_TRANSACTION) as OCPP16StartTransactionResponse;
 113     } catch (error) {
 114       this.handleRequestError(OCPP16RequestCommand.STOP_TRANSACTION, error);
 115     }
 116   }
 117
 118   // eslint-disable-next-line consistent-this
 119   public async sendMeterValues(connectorId: number, transactionId: number, interval: number, self: OCPPRequestService, debug = false): Promise<void> {
 120     try {
 121       const meterValue: OCPP16MeterValue = {
 122         timestamp: new Date().toISOString(),
 123         sampledValue: [],
 124       };
 125       const connector = self.chargingStation.getConnector(connectorId);
 126       // SoC measurand
 127       const socSampledValueTemplate = self.chargingStation.getSampledValueTemplate(connectorId, OCPP16MeterValueMeasurand.STATE_OF_CHARGE);
 128       if (socSampledValueTemplate) {
 129         meterValue.sampledValue.push(OCPP16ServiceUtils.buildSampledValue(socSampledValueTemplate, Utils.getRandomInt(100)));
 130         const sampledValuesIndex = meterValue.sampledValue.length - 1;
 131         if (Utils.convertToInt(meterValue.sampledValue[sampledValuesIndex].value) > 100 || debug) {
 132           logger.error(`${self.chargingStation.logPrefix()} MeterValues measurand ${meterValue.sampledValue[sampledValuesIndex].measurand ?? OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${meterValue.sampledValue[sampledValuesIndex].value}/100`);
 133         }
 134       }
 135       // Voltage measurand
 136       const voltageSampledValueTemplate = self.chargingStation.getSampledValueTemplate(connectorId, OCPP16MeterValueMeasurand.VOLTAGE);
 137       if (voltageSampledValueTemplate) {
 138         const voltageSampledValueTemplateValue = voltageSampledValueTemplate.value ? parseInt(voltageSampledValueTemplate.value) : self.chargingStation.getVoltageOut();
 139         const fluctuationPercent = voltageSampledValueTemplate.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT;
 140         const voltageMeasurandValue = Utils.getRandomFloatFluctuatedRounded(voltageSampledValueTemplateValue, fluctuationPercent);
 141         if (self.chargingStation.getNumberOfPhases() !== 3 || (self.chargingStation.getNumberOfPhases() === 3 && self.chargingStation.getMainVoltageMeterValues())) {
 142           meterValue.sampledValue.push(OCPP16ServiceUtils.buildSampledValue(voltageSampledValueTemplate, voltageMeasurandValue));
 143         }
 144         for (let phase = 1; self.chargingStation.getNumberOfPhases() === 3 && phase <= self.chargingStation.getNumberOfPhases(); phase++) {
 145           const phaseLineToNeutralValue = `L${phase}-N`;
 146           const voltagePhaseLineToNeutralSampledValueTemplate = self.chargingStation.getSampledValueTemplate(connectorId, OCPP16MeterValueMeasurand.VOLTAGE,
 147             phaseLineToNeutralValue as OCPP16MeterValuePhase);
 148           let voltagePhaseLineToNeutralMeasurandValue: number;
 149           if (voltagePhaseLineToNeutralSampledValueTemplate) {
 150             const voltagePhaseLineToNeutralSampledValueTemplateValue = voltagePhaseLineToNeutralSampledValueTemplate.value ? parseInt(voltagePhaseLineToNeutralSampledValueTemplate.value) : self.chargingStation.getVoltageOut();
 151             const fluctuationPhaseToNeutralPercent = voltagePhaseLineToNeutralSampledValueTemplate.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT;
 152             voltagePhaseLineToNeutralMeasurandValue = Utils.getRandomFloatFluctuatedRounded(voltagePhaseLineToNeutralSampledValueTemplateValue, fluctuationPhaseToNeutralPercent);
 153           }
 154           meterValue.sampledValue.push(OCPP16ServiceUtils.buildSampledValue(voltagePhaseLineToNeutralSampledValueTemplate ?? voltageSampledValueTemplate,
 155             voltagePhaseLineToNeutralMeasurandValue ?? voltageMeasurandValue, null, phaseLineToNeutralValue as OCPP16MeterValuePhase));
 156           if (self.chargingStation.getPhaseLineToLineVoltageMeterValues()) {
 157             const phaseLineToLineValue = `L${phase}-L${(phase + 1) % self.chargingStation.getNumberOfPhases() !== 0 ? (phase + 1) % self.chargingStation.getNumberOfPhases() : self.chargingStation.getNumberOfPhases()}`;
 158             const voltagePhaseLineToLineSampledValueTemplate = self.chargingStation.getSampledValueTemplate(connectorId, OCPP16MeterValueMeasurand.VOLTAGE, phaseLineToLineValue as OCPP16MeterValuePhase);
 159             let voltagePhaseLineToLineMeasurandValue: number;
 160             if (voltagePhaseLineToLineSampledValueTemplate) {
 161               const voltagePhaseLineToLineSampledValueTemplateValue = voltagePhaseLineToLineSampledValueTemplate.value ? parseInt(voltagePhaseLineToLineSampledValueTemplate.value) : Voltage.VOLTAGE_400;
 162               const fluctuationPhaseLineToLinePercent = voltagePhaseLineToLineSampledValueTemplate.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT;
 163               voltagePhaseLineToLineMeasurandValue = Utils.getRandomFloatFluctuatedRounded(voltagePhaseLineToLineSampledValueTemplateValue, fluctuationPhaseLineToLinePercent);
 164             }
 165             const defaultVoltagePhaseLineToLineMeasurandValue = Utils.getRandomFloatFluctuatedRounded(Voltage.VOLTAGE_400, fluctuationPercent);
 166             meterValue.sampledValue.push(OCPP16ServiceUtils.buildSampledValue(voltagePhaseLineToLineSampledValueTemplate ?? voltageSampledValueTemplate,
 167               voltagePhaseLineToLineMeasurandValue ?? defaultVoltagePhaseLineToLineMeasurandValue, null, phaseLineToLineValue as OCPP16MeterValuePhase));
 168           }
 169         }
 170       }
 171       // Power.Active.Import measurand
 172       const powerSampledValueTemplate = self.chargingStation.getSampledValueTemplate(connectorId, OCPP16MeterValueMeasurand.POWER_ACTIVE_IMPORT);
 173       let powerPerPhaseSampledValueTemplates: MeasurandPerPhaseSampledValueTemplates = {};
 174       if (self.chargingStation.getNumberOfPhases() === 3) {
 175         powerPerPhaseSampledValueTemplates = {
 176           L1: self.chargingStation.getSampledValueTemplate(connectorId, OCPP16MeterValueMeasurand.POWER_ACTIVE_IMPORT, OCPP16MeterValuePhase.L1_N),
 177           L2: self.chargingStation.getSampledValueTemplate(connectorId, OCPP16MeterValueMeasurand.POWER_ACTIVE_IMPORT, OCPP16MeterValuePhase.L2_N),
 178           L3: self.chargingStation.getSampledValueTemplate(connectorId, OCPP16MeterValueMeasurand.POWER_ACTIVE_IMPORT, OCPP16MeterValuePhase.L3_N),
 179         };
 180       }
 181       if (powerSampledValueTemplate) {
 182         OCPP16ServiceUtils.checkMeasurandPowerDivider(self.chargingStation, powerSampledValueTemplate.measurand);
 183         const errMsg = `${self.chargingStation.logPrefix()} MeterValues measurand ${powerSampledValueTemplate.measurand ?? OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: Unknown ${self.chargingStation.getCurrentOutType()} currentOutType in template file ${self.chargingStation.stationTemplateFile}, cannot calculate ${powerSampledValueTemplate.measurand ?? OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER} measurand value`;
 184         const powerMeasurandValues = {} as MeasurandValues;
 185         const unitDivider = powerSampledValueTemplate?.unit === MeterValueUnit.KILO_WATT ? 1000 : 1;
 186         const maxPower = Math.round(self.chargingStation.stationInfo.maxPower / self.chargingStation.stationInfo.powerDivider);
 187         const maxPowerPerPhase = Math.round((self.chargingStation.stationInfo.maxPower / self.chargingStation.stationInfo.powerDivider) / self.chargingStation.getNumberOfPhases());
 188         switch (self.chargingStation.getCurrentOutType()) {
 189           case CurrentType.AC:
 190             if (self.chargingStation.getNumberOfPhases() === 3) {
 191               const defaultFluctuatedPowerPerPhase = powerSampledValueTemplate.value
 192                 && Utils.getRandomFloatFluctuatedRounded(parseInt(powerSampledValueTemplate.value) / self.chargingStation.getNumberOfPhases(), powerSampledValueTemplate.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT);
 193               const phase1FluctuatedValue = powerPerPhaseSampledValueTemplates?.L1?.value
 194                 && Utils.getRandomFloatFluctuatedRounded(parseInt(powerPerPhaseSampledValueTemplates.L1.value), powerPerPhaseSampledValueTemplates.L1.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT);
 195               const phase2FluctuatedValue = powerPerPhaseSampledValueTemplates?.L2?.value
 196                 && Utils.getRandomFloatFluctuatedRounded(parseInt(powerPerPhaseSampledValueTemplates.L2.value), powerPerPhaseSampledValueTemplates.L2.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT);
 197               const phase3FluctuatedValue = powerPerPhaseSampledValueTemplates?.L3?.value
 198                 && Utils.getRandomFloatFluctuatedRounded(parseInt(powerPerPhaseSampledValueTemplates.L3.value), powerPerPhaseSampledValueTemplates.L3.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT);
 199               powerMeasurandValues.L1 = (phase1FluctuatedValue ?? defaultFluctuatedPowerPerPhase) ?? Utils.getRandomFloatRounded(maxPowerPerPhase / unitDivider);
 200               powerMeasurandValues.L2 = (phase2FluctuatedValue ?? defaultFluctuatedPowerPerPhase) ?? Utils.getRandomFloatRounded(maxPowerPerPhase / unitDivider);
 201               powerMeasurandValues.L3 = (phase3FluctuatedValue ?? defaultFluctuatedPowerPerPhase) ?? Utils.getRandomFloatRounded(maxPowerPerPhase / unitDivider);
 202             } else {
 203               powerMeasurandValues.L1 = powerSampledValueTemplate.value
 204                 ? Utils.getRandomFloatFluctuatedRounded(parseInt(powerSampledValueTemplate.value), powerSampledValueTemplate.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT)
 205                 : Utils.getRandomFloatRounded(maxPower / unitDivider);
 206               powerMeasurandValues.L2 = 0;
 207               powerMeasurandValues.L3 = 0;
 208             }
 209             powerMeasurandValues.allPhases = Utils.roundTo(powerMeasurandValues.L1 + powerMeasurandValues.L2 + powerMeasurandValues.L3, 2);
 210             break;
 211           case CurrentType.DC:
 212             powerMeasurandValues.allPhases = powerSampledValueTemplate.value
 213               ? Utils.getRandomFloatFluctuatedRounded(parseInt(powerSampledValueTemplate.value), powerSampledValueTemplate.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT)
 214               : Utils.getRandomFloatRounded(maxPower / unitDivider);
 215             break;
 216           default:
 217             logger.error(errMsg);
 218             throw Error(errMsg);
 219         }
 220         meterValue.sampledValue.push(OCPP16ServiceUtils.buildSampledValue(powerSampledValueTemplate, powerMeasurandValues.allPhases));
 221         const sampledValuesIndex = meterValue.sampledValue.length - 1;
 222         const maxPowerRounded = Utils.roundTo(maxPower / unitDivider, 2);
 223         if (Utils.convertToFloat(meterValue.sampledValue[sampledValuesIndex].value) > maxPowerRounded || debug) {
 224           logger.error(`${self.chargingStation.logPrefix()} MeterValues measurand ${meterValue.sampledValue[sampledValuesIndex].measurand ?? OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${meterValue.sampledValue[sampledValuesIndex].value}/${maxPowerRounded}`);
 225         }
 226         for (let phase = 1; self.chargingStation.getNumberOfPhases() === 3 && phase <= self.chargingStation.getNumberOfPhases(); phase++) {
 227           const phaseValue = `L${phase}-N`;
 228           meterValue.sampledValue.push(OCPP16ServiceUtils.buildSampledValue(powerPerPhaseSampledValueTemplates[`L${phase}`] ?? powerSampledValueTemplate, powerMeasurandValues[`L${phase}`], null,
 229             phaseValue as OCPP16MeterValuePhase));
 230           const sampledValuesPerPhaseIndex = meterValue.sampledValue.length - 1;
 231           const maxPowerPerPhaseRounded = Utils.roundTo(maxPowerPerPhase / unitDivider, 2);
 232           if (Utils.convertToFloat(meterValue.sampledValue[sampledValuesPerPhaseIndex].value) > maxPowerPerPhaseRounded || debug) {
 233             logger.error(`${self.chargingStation.logPrefix()} MeterValues measurand ${meterValue.sampledValue[sampledValuesPerPhaseIndex].measurand ?? OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: phase ${meterValue.sampledValue[sampledValuesPerPhaseIndex].phase}, connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${meterValue.sampledValue[sampledValuesPerPhaseIndex].value}/${maxPowerPerPhaseRounded}`);
 234           }
 235         }
 236       }
 237       // Current.Import measurand
 238       const currentSampledValueTemplate = self.chargingStation.getSampledValueTemplate(connectorId, OCPP16MeterValueMeasurand.CURRENT_IMPORT);
 239       let currentPerPhaseSampledValueTemplates: MeasurandPerPhaseSampledValueTemplates = {};
 240       if (self.chargingStation.getNumberOfPhases() === 3) {
 241         currentPerPhaseSampledValueTemplates = {
 242           L1: self.chargingStation.getSampledValueTemplate(connectorId, OCPP16MeterValueMeasurand.CURRENT_IMPORT, OCPP16MeterValuePhase.L1),
 243           L2: self.chargingStation.getSampledValueTemplate(connectorId, OCPP16MeterValueMeasurand.CURRENT_IMPORT, OCPP16MeterValuePhase.L2),
 244           L3: self.chargingStation.getSampledValueTemplate(connectorId, OCPP16MeterValueMeasurand.CURRENT_IMPORT, OCPP16MeterValuePhase.L3),
 245         };
 246       }
 247       if (currentSampledValueTemplate) {
 248         OCPP16ServiceUtils.checkMeasurandPowerDivider(self.chargingStation, currentSampledValueTemplate.measurand);
 249         const errMsg = `${self.chargingStation.logPrefix()} MeterValues measurand ${currentSampledValueTemplate.measurand ?? OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: Unknown ${self.chargingStation.getCurrentOutType()} currentOutType in template file ${self.chargingStation.stationTemplateFile}, cannot calculate ${currentSampledValueTemplate.measurand ?? OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER} measurand value`;
 250         const currentMeasurandValues: MeasurandValues = {} as MeasurandValues;
 251         let maxAmperage: number;
 252         switch (self.chargingStation.getCurrentOutType()) {
 253           case CurrentType.AC:
 254             maxAmperage = ACElectricUtils.amperagePerPhaseFromPower(self.chargingStation.getNumberOfPhases(), self.chargingStation.stationInfo.maxPower / self.chargingStation.stationInfo.powerDivider, self.chargingStation.getVoltageOut());
 255             if (self.chargingStation.getNumberOfPhases() === 3) {
 256               const defaultFluctuatedAmperagePerPhase = currentSampledValueTemplate.value
 257                 && Utils.getRandomFloatFluctuatedRounded(parseInt(currentSampledValueTemplate.value), currentSampledValueTemplate.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT);
 258               const phase1FluctuatedValue = currentPerPhaseSampledValueTemplates?.L1?.value
 259                 && Utils.getRandomFloatFluctuatedRounded(parseInt(currentPerPhaseSampledValueTemplates.L1.value), currentPerPhaseSampledValueTemplates.L1.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT);
 260               const phase2FluctuatedValue = currentPerPhaseSampledValueTemplates?.L2?.value
 261                 && Utils.getRandomFloatFluctuatedRounded(parseInt(currentPerPhaseSampledValueTemplates.L2.value), currentPerPhaseSampledValueTemplates.L2.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT);
 262               const phase3FluctuatedValue = currentPerPhaseSampledValueTemplates?.L3?.value
 263                 && Utils.getRandomFloatFluctuatedRounded(parseInt(currentPerPhaseSampledValueTemplates.L3.value), currentPerPhaseSampledValueTemplates.L3.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT);
 264               currentMeasurandValues.L1 = (phase1FluctuatedValue ?? defaultFluctuatedAmperagePerPhase) ?? Utils.getRandomFloatRounded(maxAmperage);
 265               currentMeasurandValues.L2 = (phase2FluctuatedValue ?? defaultFluctuatedAmperagePerPhase) ?? Utils.getRandomFloatRounded(maxAmperage);
 266               currentMeasurandValues.L3 = (phase3FluctuatedValue ?? defaultFluctuatedAmperagePerPhase) ?? Utils.getRandomFloatRounded(maxAmperage);
 267             } else {
 268               currentMeasurandValues.L1 = currentSampledValueTemplate.value
 269                 ? Utils.getRandomFloatFluctuatedRounded(parseInt(currentSampledValueTemplate.value), currentSampledValueTemplate.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT)
 270                 : Utils.getRandomFloatRounded(maxAmperage);
 271               currentMeasurandValues.L2 = 0;
 272               currentMeasurandValues.L3 = 0;
 273             }
 274             currentMeasurandValues.allPhases = Utils.roundTo((currentMeasurandValues.L1 + currentMeasurandValues.L2 + currentMeasurandValues.L3) / self.chargingStation.getNumberOfPhases(), 2);
 275             break;
 276           case CurrentType.DC:
 277             maxAmperage = DCElectricUtils.amperage(self.chargingStation.stationInfo.maxPower / self.chargingStation.stationInfo.powerDivider, self.chargingStation.getVoltageOut());
 278             currentMeasurandValues.allPhases = currentSampledValueTemplate.value
 279               ? Utils.getRandomFloatFluctuatedRounded(parseInt(currentSampledValueTemplate.value), currentSampledValueTemplate.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT)
 280               : Utils.getRandomFloatRounded(maxAmperage);
 281             break;
 282           default:
 283             logger.error(errMsg);
 284             throw Error(errMsg);
 285         }
 286         meterValue.sampledValue.push(OCPP16ServiceUtils.buildSampledValue(currentSampledValueTemplate, currentMeasurandValues.allPhases));
 287         const sampledValuesIndex = meterValue.sampledValue.length - 1;
 288         if (Utils.convertToFloat(meterValue.sampledValue[sampledValuesIndex].value) > maxAmperage || debug) {
 289           logger.error(`${self.chargingStation.logPrefix()} MeterValues measurand ${meterValue.sampledValue[sampledValuesIndex].measurand ?? OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${meterValue.sampledValue[sampledValuesIndex].value}/${maxAmperage}`);
 290         }
 291         for (let phase = 1; self.chargingStation.getNumberOfPhases() === 3 && phase <= self.chargingStation.getNumberOfPhases(); phase++) {
 292           const phaseValue = `L${phase}`;
 293           meterValue.sampledValue.push(OCPP16ServiceUtils.buildSampledValue(currentPerPhaseSampledValueTemplates[phaseValue] ?? currentSampledValueTemplate,
 294             currentMeasurandValues[phaseValue], null, phaseValue as OCPP16MeterValuePhase));
 295           const sampledValuesPerPhaseIndex = meterValue.sampledValue.length - 1;
 296           if (Utils.convertToFloat(meterValue.sampledValue[sampledValuesPerPhaseIndex].value) > maxAmperage || debug) {
 297             logger.error(`${self.chargingStation.logPrefix()} MeterValues measurand ${meterValue.sampledValue[sampledValuesPerPhaseIndex].measurand ?? OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: phase ${meterValue.sampledValue[sampledValuesPerPhaseIndex].phase}, connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${meterValue.sampledValue[sampledValuesPerPhaseIndex].value}/${maxAmperage}`);
 298           }
 299         }
 300       }
 301       // Energy.Active.Import.Register measurand (default)
 302       const energySampledValueTemplate = self.chargingStation.getSampledValueTemplate(connectorId);
 303       if (energySampledValueTemplate) {
 304         OCPP16ServiceUtils.checkMeasurandPowerDivider(self.chargingStation, energySampledValueTemplate.measurand);
 305         const unitDivider = energySampledValueTemplate?.unit === MeterValueUnit.KILO_WATT_HOUR ? 1000 : 1;
 306         const energyMeasurandValue = energySampledValueTemplate.value
 307           // Cumulate the fluctuated value around the static one
 308           ? Utils.getRandomFloatFluctuatedRounded(parseInt(energySampledValueTemplate.value), energySampledValueTemplate.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT)
 309           : Utils.getRandomInt(self.chargingStation.stationInfo.maxPower / (self.chargingStation.stationInfo.powerDivider * 3600000) * interval);
 310         // Persist previous value on connector
 311         if (connector && !Utils.isNullOrUndefined(connector.energyActiveImportRegisterValue) && connector.energyActiveImportRegisterValue >= 0 &&
 312             !Utils.isNullOrUndefined(connector.transactionEnergyActiveImportRegisterValue) && connector.transactionEnergyActiveImportRegisterValue >= 0) {
 313           connector.energyActiveImportRegisterValue += energyMeasurandValue;
 314           connector.transactionEnergyActiveImportRegisterValue += energyMeasurandValue;
 315         } else {
 316           connector.energyActiveImportRegisterValue = 0;
 317           connector.transactionEnergyActiveImportRegisterValue = 0;
 318         }
 319         meterValue.sampledValue.push(OCPP16ServiceUtils.buildSampledValue(energySampledValueTemplate,
 320           Utils.roundTo(self.chargingStation.getEnergyActiveImportRegisterByTransactionId(transactionId) / unitDivider, 4)));
 321         const sampledValuesIndex = meterValue.sampledValue.length - 1;
 322         const maxEnergy = Math.round(self.chargingStation.stationInfo.maxPower * 3600 / (self.chargingStation.stationInfo.powerDivider * interval));
 323         const maxEnergyRounded = Utils.roundTo(maxEnergy / unitDivider, 4);
 324         if (Utils.convertToFloat(meterValue.sampledValue[sampledValuesIndex].value) > maxEnergyRounded || debug) {
 325           logger.error(`${self.chargingStation.logPrefix()} MeterValues measurand ${meterValue.sampledValue[sampledValuesIndex].measurand ?? OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${meterValue.sampledValue[sampledValuesIndex].value}/${maxEnergyRounded}`);
 326         }
 327       }
 328       const payload: MeterValuesRequest = {
 329         connectorId,
 330         transactionId,
 331         meterValue,
 332       };
 333       await self.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, OCPP16RequestCommand.METER_VALUES);
 334     } catch (error) {
 335       self.handleRequestError(OCPP16RequestCommand.METER_VALUES, error);
 336     }
 337   }
 338
 339   public async sendTransactionBeginMeterValues(connectorId: number, transactionId: number, beginMeterValue: OCPP16MeterValue): Promise<void> {
 340     const payload: MeterValuesRequest = {
 341       connectorId,
 342       transactionId,
 343       meterValue: beginMeterValue,
 344     };
 345     await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, OCPP16RequestCommand.METER_VALUES);
 346   }
 347
 348   public async sendTransactionEndMeterValues(connectorId: number, transactionId: number, endMeterValue: OCPP16MeterValue): Promise<void> {
 349     const payload: MeterValuesRequest = {
 350       connectorId,
 351       transactionId,
 352       meterValue: endMeterValue,
 353     };
 354     await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, OCPP16RequestCommand.METER_VALUES);
 355   }
 356
 357   public async sendError(messageId: string, error: OCPPError, commandName: OCPP16RequestCommand | OCPP16IncomingRequestCommand): Promise<unknown> {
 358     // Send error
 359     return this.sendMessage(messageId, error, MessageType.CALL_ERROR_MESSAGE, commandName);
 360   }
 361 }