src/charging-station/ChargingStation.ts

   1 // Partial Copyright Jerome Benoit. 2021. All Rights Reserved.
   2
   3 import { AvailabilityType, BootNotificationRequest, CachedRequest, IncomingRequest, IncomingRequestCommand, RequestCommand } from '../types/ocpp/Requests';
   4 import { BootNotificationResponse, RegistrationStatus } from '../types/ocpp/Responses';
   5 import ChargingStationConfiguration, { ConfigurationKey } from '../types/ChargingStationConfiguration';
   6 import ChargingStationTemplate, { CurrentType, PowerUnits, Voltage } from '../types/ChargingStationTemplate';
   7 import { ConnectorPhaseRotation, StandardParametersKey, SupportedFeatureProfiles } from '../types/ocpp/Configuration';
   8 import { ConnectorStatus, SampledValueTemplate } from '../types/Connectors';
   9 import { MeterValueMeasurand, MeterValuePhase } from '../types/ocpp/MeterValues';
  10 import { WSError, WebSocketCloseEventStatusCode } from '../types/WebSocket';
  11 import WebSocket, { ClientOptions, Data, OPEN } from 'ws';
  12
  13 import AutomaticTransactionGenerator from './AutomaticTransactionGenerator';
  14 import { ChargePointStatus } from '../types/ocpp/ChargePointStatus';
  15 import { ChargingProfile } from '../types/ocpp/ChargingProfile';
  16 import ChargingStationInfo from '../types/ChargingStationInfo';
  17 import { ClientRequestArgs } from 'http';
  18 import Configuration from '../utils/Configuration';
  19 import Constants from '../utils/Constants';
  20 import { ErrorType } from '../types/ocpp/ErrorType';
  21 import FileUtils from '../utils/FileUtils';
  22 import { MessageType } from '../types/ocpp/MessageType';
  23 import OCPP16IncomingRequestService from './ocpp/1.6/OCPP16IncomingRequestService';
  24 import OCPP16RequestService from './ocpp/1.6/OCPP16RequestService';
  25 import OCPP16ResponseService from './ocpp/1.6/OCPP16ResponseService';
  26 import OCPPError from './ocpp/OCPPError';
  27 import OCPPIncomingRequestService from './ocpp/OCPPIncomingRequestService';
  28 import OCPPRequestService from './ocpp/OCPPRequestService';
  29 import { OCPPVersion } from '../types/ocpp/OCPPVersion';
  30 import PerformanceStatistics from '../performance/PerformanceStatistics';
  31 import { StopTransactionReason } from '../types/ocpp/Transaction';
  32 import { URL } from 'url';
  33 import Utils from '../utils/Utils';
  34 import crypto from 'crypto';
  35 import fs from 'fs';
  36 import logger from '../utils/Logger';
  37 import path from 'path';
  38
  39 export default class ChargingStation {
  40   public readonly stationTemplateFile: string;
  41   public authorizedTags: string[];
  42   public stationInfo!: ChargingStationInfo;
  43   public readonly connectors: Map<number, ConnectorStatus>;
  44   public configuration!: ChargingStationConfiguration;
  45   public wsConnection!: WebSocket;
  46   public readonly requests: Map<string, CachedRequest>;
  47   public performanceStatistics!: PerformanceStatistics;
  48   public heartbeatSetInterval!: NodeJS.Timeout;
  49   public ocppRequestService!: OCPPRequestService;
  50   private readonly index: number;
  51   private bootNotificationRequest!: BootNotificationRequest;
  52   private bootNotificationResponse!: BootNotificationResponse | null;
  53   private connectorsConfigurationHash!: string;
  54   private ocppIncomingRequestService!: OCPPIncomingRequestService;
  55   private readonly messageBuffer: Set<string>;
  56   private wsConnectionUrl!: URL;
  57   private wsConnectionRestarted: boolean;
  58   private stopped: boolean;
  59   private autoReconnectRetryCount: number;
  60   private automaticTransactionGenerator!: AutomaticTransactionGenerator;
  61   private webSocketPingSetInterval!: NodeJS.Timeout;
  62
  63   constructor(index: number, stationTemplateFile: string) {
  64     this.index = index;
  65     this.stationTemplateFile = stationTemplateFile;
  66     this.connectors = new Map<number, ConnectorStatus>();
  67     this.initialize();
  68
  69     this.stopped = false;
  70     this.wsConnectionRestarted = false;
  71     this.autoReconnectRetryCount = 0;
  72
  73     this.requests = new Map<string, CachedRequest>();
  74     this.messageBuffer = new Set<string>();
  75
  76     this.authorizedTags = this.getAuthorizedTags();
  77   }
  78
  79   public logPrefix(): string {
  80     return Utils.logPrefix(` ${this.stationInfo.chargingStationId} |`);
  81   }
  82
  83   public getBootNotificationRequest(): BootNotificationRequest {
  84     return this.bootNotificationRequest;
  85   }
  86
  87   public getRandomIdTag(): string {
  88     const index = Math.floor(Utils.secureRandom() * this.authorizedTags.length);
  89     return this.authorizedTags[index];
  90   }
  91
  92   public hasAuthorizedTags(): boolean {
  93     return !Utils.isEmptyArray(this.authorizedTags);
  94   }
  95
  96   public getEnableStatistics(): boolean | undefined {
  97     return !Utils.isUndefined(this.stationInfo.enableStatistics) ? this.stationInfo.enableStatistics : true;
  98   }
  99
 100   public getMayAuthorizeAtRemoteStart(): boolean | undefined {
 101     return this.stationInfo.mayAuthorizeAtRemoteStart ?? true;
 102   }
 103
 104   public getNumberOfPhases(): number | undefined {
 105     switch (this.getCurrentOutType()) {
 106       case CurrentType.AC:
 107         return !Utils.isUndefined(this.stationInfo.numberOfPhases) ? this.stationInfo.numberOfPhases : 3;
 108       case CurrentType.DC:
 109         return 0;
 110     }
 111   }
 112
 113   public isWebSocketConnectionOpened(): boolean {
 114     return this.wsConnection?.readyState === OPEN;
 115   }
 116
 117   public isRegistered(): boolean {
 118     return this.bootNotificationResponse?.status === RegistrationStatus.ACCEPTED;
 119   }
 120
 121   public isChargingStationAvailable(): boolean {
 122     return this.getConnectorStatus(0).availability === AvailabilityType.OPERATIVE;
 123   }
 124
 125   public isConnectorAvailable(id: number): boolean {
 126     return this.getConnectorStatus(id).availability === AvailabilityType.OPERATIVE;
 127   }
 128
 129   public getNumberOfConnectors(): number {
 130     return this.connectors.get(0) ? this.connectors.size - 1 : this.connectors.size;
 131   }
 132
 133   public getConnectorStatus(id: number): ConnectorStatus {
 134     return this.connectors.get(id);
 135   }
 136
 137   public getCurrentOutType(): CurrentType | undefined {
 138     return this.stationInfo.currentOutType ?? CurrentType.AC;
 139   }
 140
 141   public getVoltageOut(): number | undefined {
 142     const errMsg = `${this.logPrefix()} Unknown ${this.getCurrentOutType()} currentOutType in template file ${this.stationTemplateFile}, cannot define default voltage out`;
 143     let defaultVoltageOut: number;
 144     switch (this.getCurrentOutType()) {
 145       case CurrentType.AC:
 146         defaultVoltageOut = Voltage.VOLTAGE_230;
 147         break;
 148       case CurrentType.DC:
 149         defaultVoltageOut = Voltage.VOLTAGE_400;
 150         break;
 151       default:
 152         logger.error(errMsg);
 153         throw new Error(errMsg);
 154     }
 155     return !Utils.isUndefined(this.stationInfo.voltageOut) ? this.stationInfo.voltageOut : defaultVoltageOut;
 156   }
 157
 158   public getTransactionIdTag(transactionId: number): string | undefined {
 159     for (const connectorId of this.connectors.keys()) {
 160       if (connectorId > 0 && this.getConnectorStatus(connectorId).transactionId === transactionId) {
 161         return this.getConnectorStatus(connectorId).transactionIdTag;
 162       }
 163     }
 164   }
 165
 166   public getOutOfOrderEndMeterValues(): boolean {
 167     return this.stationInfo.outOfOrderEndMeterValues ?? false;
 168   }
 169
 170   public getBeginEndMeterValues(): boolean {
 171     return this.stationInfo.beginEndMeterValues ?? false;
 172   }
 173
 174   public getMeteringPerTransaction(): boolean {
 175     return this.stationInfo.meteringPerTransaction ?? true;
 176   }
 177
 178   public getTransactionDataMeterValues(): boolean {
 179     return this.stationInfo.transactionDataMeterValues ?? false;
 180   }
 181
 182   public getMainVoltageMeterValues(): boolean {
 183     return this.stationInfo.mainVoltageMeterValues ?? true;
 184   }
 185
 186   public getPhaseLineToLineVoltageMeterValues(): boolean {
 187     return this.stationInfo.phaseLineToLineVoltageMeterValues ?? false;
 188   }
 189
 190   public getEnergyActiveImportRegisterByTransactionId(transactionId: number): number | undefined {
 191     if (this.getMeteringPerTransaction()) {
 192       for (const connectorId of this.connectors.keys()) {
 193         if (connectorId > 0 && this.getConnectorStatus(connectorId).transactionId === transactionId) {
 194           return this.getConnectorStatus(connectorId).transactionEnergyActiveImportRegisterValue;
 195         }
 196       }
 197     }
 198     for (const connectorId of this.connectors.keys()) {
 199       if (connectorId > 0 && this.getConnectorStatus(connectorId).transactionId === transactionId) {
 200         return this.getConnectorStatus(connectorId).energyActiveImportRegisterValue;
 201       }
 202     }
 203   }
 204
 205   public getEnergyActiveImportRegisterByConnectorId(connectorId: number): number | undefined {
 206     if (this.getMeteringPerTransaction()) {
 207       return this.getConnectorStatus(connectorId).transactionEnergyActiveImportRegisterValue;
 208     }
 209     return this.getConnectorStatus(connectorId).energyActiveImportRegisterValue;
 210   }
 211
 212   public getAuthorizeRemoteTxRequests(): boolean {
 213     const authorizeRemoteTxRequests = this.getConfigurationKey(StandardParametersKey.AuthorizeRemoteTxRequests);
 214     return authorizeRemoteTxRequests ? Utils.convertToBoolean(authorizeRemoteTxRequests.value) : false;
 215   }
 216
 217   public getLocalAuthListEnabled(): boolean {
 218     const localAuthListEnabled = this.getConfigurationKey(StandardParametersKey.LocalAuthListEnabled);
 219     return localAuthListEnabled ? Utils.convertToBoolean(localAuthListEnabled.value) : false;
 220   }
 221
 222   public restartWebSocketPing(): void {
 223     // Stop WebSocket ping
 224     this.stopWebSocketPing();
 225     // Start WebSocket ping
 226     this.startWebSocketPing();
 227   }
 228
 229   public getSampledValueTemplate(connectorId: number, measurand: MeterValueMeasurand = MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER,
 230       phase?: MeterValuePhase): SampledValueTemplate | undefined {
 231     if (!Constants.SUPPORTED_MEASURANDS.includes(measurand)) {
 232       logger.warn(`${this.logPrefix()} Trying to get unsupported MeterValues measurand '${measurand}' ${phase ? `on phase ${phase} ` : ''}in template on connectorId ${connectorId}`);
 233       return;
 234     }
 235     if (measurand !== MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER && !this.getConfigurationKey(StandardParametersKey.MeterValuesSampledData).value.includes(measurand)) {
 236       logger.debug(`${this.logPrefix()} Trying to get MeterValues measurand '${measurand}' ${phase ? `on phase ${phase} ` : ''}in template on connectorId ${connectorId} not found in '${StandardParametersKey.MeterValuesSampledData}' OCPP parameter`);
 237       return;
 238     }
 239     const sampledValueTemplates: SampledValueTemplate[] = this.getConnectorStatus(connectorId).MeterValues;
 240     for (let index = 0; !Utils.isEmptyArray(sampledValueTemplates) && index < sampledValueTemplates.length; index++) {
 241       if (!Constants.SUPPORTED_MEASURANDS.includes(sampledValueTemplates[index]?.measurand ?? MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER)) {
 242         logger.warn(`${this.logPrefix()} Unsupported MeterValues measurand '${measurand}' ${phase ? `on phase ${phase} ` : ''}in template on connectorId ${connectorId}`);
 243       } else if (phase && sampledValueTemplates[index]?.phase === phase && sampledValueTemplates[index]?.measurand === measurand
 244         && this.getConfigurationKey(StandardParametersKey.MeterValuesSampledData).value.includes(measurand)) {
 245         return sampledValueTemplates[index];
 246       } else if (!phase && !sampledValueTemplates[index].phase && sampledValueTemplates[index]?.measurand === measurand
 247         && this.getConfigurationKey(StandardParametersKey.MeterValuesSampledData).value.includes(measurand)) {
 248         return sampledValueTemplates[index];
 249       } else if (measurand === MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER
 250         && (!sampledValueTemplates[index].measurand || sampledValueTemplates[index].measurand === measurand)) {
 251         return sampledValueTemplates[index];
 252       }
 253     }
 254     if (measurand === MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER) {
 255       const errorMsg = `${this.logPrefix()} Missing MeterValues for default measurand '${measurand}' in template on connectorId ${connectorId}`;
 256       logger.error(errorMsg);
 257       throw new Error(errorMsg);
 258     }
 259     logger.debug(`${this.logPrefix()} No MeterValues for measurand '${measurand}' ${phase ? `on phase ${phase} ` : ''}in template on connectorId ${connectorId}`);
 260   }
 261
 262   public getAutomaticTransactionGeneratorRequireAuthorize(): boolean {
 263     return this.stationInfo.AutomaticTransactionGenerator.requireAuthorize ?? true;
 264   }
 265
 266   public startHeartbeat(): void {
 267     if (this.getHeartbeatInterval() && this.getHeartbeatInterval() > 0 && !this.heartbeatSetInterval) {
 268       // eslint-disable-next-line @typescript-eslint/no-misused-promises
 269       this.heartbeatSetInterval = setInterval(async (): Promise<void> => {
 270         await this.ocppRequestService.sendHeartbeat();
 271       }, this.getHeartbeatInterval());
 272       logger.info(this.logPrefix() + ' Heartbeat started every ' + Utils.formatDurationMilliSeconds(this.getHeartbeatInterval()));
 273     } else if (this.heartbeatSetInterval) {
 274       logger.info(this.logPrefix() + ' Heartbeat already started every ' + Utils.formatDurationMilliSeconds(this.getHeartbeatInterval()));
 275     } else {
 276       logger.error(`${this.logPrefix()} Heartbeat interval set to ${this.getHeartbeatInterval() ? Utils.formatDurationMilliSeconds(this.getHeartbeatInterval()) : this.getHeartbeatInterval()}, not starting the heartbeat`);
 277     }
 278   }
 279
 280   public restartHeartbeat(): void {
 281     // Stop heartbeat
 282     this.stopHeartbeat();
 283     // Start heartbeat
 284     this.startHeartbeat();
 285   }
 286
 287   public startMeterValues(connectorId: number, interval: number): void {
 288     if (connectorId === 0) {
 289       logger.error(`${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId.toString()}`);
 290       return;
 291     }
 292     if (!this.getConnectorStatus(connectorId)) {
 293       logger.error(`${this.logPrefix()} Trying to start MeterValues on non existing connector Id ${connectorId.toString()}`);
 294       return;
 295     }
 296     if (!this.getConnectorStatus(connectorId)?.transactionStarted) {
 297       logger.error(`${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId} with no transaction started`);
 298       return;
 299     } else if (this.getConnectorStatus(connectorId)?.transactionStarted && !this.getConnectorStatus(connectorId)?.transactionId) {
 300       logger.error(`${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId} with no transaction id`);
 301       return;
 302     }
 303     if (interval > 0) {
 304       // eslint-disable-next-line @typescript-eslint/no-misused-promises
 305       this.getConnectorStatus(connectorId).transactionSetInterval = setInterval(async (): Promise<void> => {
 306         await this.ocppRequestService.sendMeterValues(connectorId, this.getConnectorStatus(connectorId).transactionId, interval);
 307       }, interval);
 308     } else {
 309       logger.error(`${this.logPrefix()} Charging station ${StandardParametersKey.MeterValueSampleInterval} configuration set to ${interval ? Utils.formatDurationMilliSeconds(interval) : interval}, not sending MeterValues`);
 310     }
 311   }
 312
 313   public start(): void {
 314     if (this.getEnableStatistics()) {
 315       this.performanceStatistics.start();
 316     }
 317     this.openWSConnection();
 318     // Monitor authorization file
 319     this.startAuthorizationFileMonitoring();
 320     // Monitor station template file
 321     this.startStationTemplateFileMonitoring();
 322     // Handle WebSocket message
 323     this.wsConnection.on('message', this.onMessage.bind(this));
 324     // Handle WebSocket error
 325     this.wsConnection.on('error', this.onError.bind(this));
 326     // Handle WebSocket close
 327     this.wsConnection.on('close', this.onClose.bind(this));
 328     // Handle WebSocket open
 329     this.wsConnection.on('open', this.onOpen.bind(this));
 330     // Handle WebSocket ping
 331     this.wsConnection.on('ping', this.onPing.bind(this));
 332     // Handle WebSocket pong
 333     this.wsConnection.on('pong', this.onPong.bind(this));
 334   }
 335
 336   public async stop(reason: StopTransactionReason = StopTransactionReason.NONE): Promise<void> {
 337     // Stop message sequence
 338     await this.stopMessageSequence(reason);
 339     for (const connectorId of this.connectors.keys()) {
 340       if (connectorId > 0) {
 341         await this.ocppRequestService.sendStatusNotification(connectorId, ChargePointStatus.UNAVAILABLE);
 342         this.getConnectorStatus(connectorId).status = ChargePointStatus.UNAVAILABLE;
 343       }
 344     }
 345     if (this.isWebSocketConnectionOpened()) {
 346       this.wsConnection.close();
 347     }
 348     if (this.getEnableStatistics()) {
 349       this.performanceStatistics.stop();
 350     }
 351     this.bootNotificationResponse = null;
 352     this.stopped = true;
 353   }
 354
 355   public getConfigurationKey(key: string | StandardParametersKey, caseInsensitive = false): ConfigurationKey | undefined {
 356     return this.configuration.configurationKey.find((configElement) => {
 357       if (caseInsensitive) {
 358         return configElement.key.toLowerCase() === key.toLowerCase();
 359       }
 360       return configElement.key === key;
 361     });
 362   }
 363
 364   public addConfigurationKey(key: string | StandardParametersKey, value: string, readonly = false, visible = true, reboot = false): void {
 365     const keyFound = this.getConfigurationKey(key);
 366     if (!keyFound) {
 367       this.configuration.configurationKey.push({
 368         key,
 369         readonly,
 370         value,
 371         visible,
 372         reboot,
 373       });
 374     } else {
 375       logger.error(`${this.logPrefix()} Trying to add an already existing configuration key: %j`, keyFound);
 376     }
 377   }
 378
 379   public setConfigurationKeyValue(key: string | StandardParametersKey, value: string): void {
 380     const keyFound = this.getConfigurationKey(key);
 381     if (keyFound) {
 382       const keyIndex = this.configuration.configurationKey.indexOf(keyFound);
 383       this.configuration.configurationKey[keyIndex].value = value;
 384     } else {
 385       logger.error(`${this.logPrefix()} Trying to set a value on a non existing configuration key: %j`, { key, value });
 386     }
 387   }
 388
 389   public setChargingProfile(connectorId: number, cp: ChargingProfile): void {
 390     let cpReplaced = false;
 391     if (!Utils.isEmptyArray(this.getConnectorStatus(connectorId).chargingProfiles)) {
 392       this.getConnectorStatus(connectorId).chargingProfiles?.forEach((chargingProfile: ChargingProfile, index: number) => {
 393         if (chargingProfile.chargingProfileId === cp.chargingProfileId
 394           || (chargingProfile.stackLevel === cp.stackLevel && chargingProfile.chargingProfilePurpose === cp.chargingProfilePurpose)) {
 395           this.getConnectorStatus(connectorId).chargingProfiles[index] = cp;
 396           cpReplaced = true;
 397         }
 398       });
 399     }
 400     !cpReplaced && this.getConnectorStatus(connectorId).chargingProfiles?.push(cp);
 401   }
 402
 403   public resetConnectorStatus(connectorId: number): void {
 404     this.getConnectorStatus(connectorId).idTagLocalAuthorized = false;
 405     this.getConnectorStatus(connectorId).idTagAuthorized = false;
 406     this.getConnectorStatus(connectorId).transactionRemoteStarted = false;
 407     this.getConnectorStatus(connectorId).transactionStarted = false;
 408     delete this.getConnectorStatus(connectorId).localAuthorizeIdTag;
 409     delete this.getConnectorStatus(connectorId).authorizeIdTag;
 410     delete this.getConnectorStatus(connectorId).transactionId;
 411     delete this.getConnectorStatus(connectorId).transactionIdTag;
 412     this.getConnectorStatus(connectorId).transactionEnergyActiveImportRegisterValue = 0;
 413     delete this.getConnectorStatus(connectorId).transactionBeginMeterValue;
 414     this.stopMeterValues(connectorId);
 415   }
 416
 417   public bufferMessage(message: string): void {
 418     this.messageBuffer.add(message);
 419   }
 420
 421   private flushMessageBuffer() {
 422     if (this.messageBuffer.size > 0) {
 423       this.messageBuffer.forEach((message) => {
 424         // TODO: evaluate the need to track performance
 425         this.wsConnection.send(message);
 426         this.messageBuffer.delete(message);
 427       });
 428     }
 429   }
 430
 431   private getChargingStationId(stationTemplate: ChargingStationTemplate): string {
 432     // In case of multiple instances: add instance index to charging station id
 433     const instanceIndex = process.env.CF_INSTANCE_INDEX ?? 0;
 434     const idSuffix = stationTemplate.nameSuffix ?? '';
 435     return stationTemplate.fixedName ? stationTemplate.baseName : stationTemplate.baseName + '-' + instanceIndex.toString() + ('000000000' + this.index.toString()).substr(('000000000' + this.index.toString()).length - 4) + idSuffix;
 436   }
 437
 438   private buildStationInfo(): ChargingStationInfo {
 439     let stationTemplateFromFile: ChargingStationTemplate;
 440     try {
 441       // Load template file
 442       const fileDescriptor = fs.openSync(this.stationTemplateFile, 'r');
 443       stationTemplateFromFile = JSON.parse(fs.readFileSync(fileDescriptor, 'utf8')) as ChargingStationTemplate;
 444       fs.closeSync(fileDescriptor);
 445     } catch (error) {
 446       FileUtils.handleFileException(this.logPrefix(), 'Template', this.stationTemplateFile, error);
 447     }
 448     const stationInfo: ChargingStationInfo = stationTemplateFromFile ?? {} as ChargingStationInfo;
 449     stationInfo.wsOptions = stationTemplateFromFile?.wsOptions ?? {};
 450     stationInfo.wsOptions.origin = stationTemplateFromFile?.wsOptions?.origin ?? 'http://localhost';
 451     stationInfo.wsOptions.handshakeTimeout = stationTemplateFromFile?.wsOptions?.handshakeTimeout ?? this.getConnectionTimeout() * 1000;
 452     if (!Utils.isEmptyArray(stationTemplateFromFile.power)) {
 453       stationTemplateFromFile.power = stationTemplateFromFile.power as number[];
 454       const powerArrayRandomIndex = Math.floor(Utils.secureRandom() * stationTemplateFromFile.power.length);
 455       stationInfo.maxPower = stationTemplateFromFile.powerUnit === PowerUnits.KILO_WATT
 456         ? stationTemplateFromFile.power[powerArrayRandomIndex] * 1000
 457         : stationTemplateFromFile.power[powerArrayRandomIndex];
 458     } else {
 459       stationTemplateFromFile.power = stationTemplateFromFile.power as number;
 460       stationInfo.maxPower = stationTemplateFromFile.powerUnit === PowerUnits.KILO_WATT
 461         ? stationTemplateFromFile.power * 1000
 462         : stationTemplateFromFile.power;
 463     }
 464     delete stationInfo.power;
 465     delete stationInfo.powerUnit;
 466     stationInfo.chargingStationId = this.getChargingStationId(stationTemplateFromFile);
 467     stationInfo.resetTime = stationTemplateFromFile.resetTime ? stationTemplateFromFile.resetTime * 1000 : Constants.CHARGING_STATION_DEFAULT_RESET_TIME;
 468     return stationInfo;
 469   }
 470
 471   private getOCPPVersion(): OCPPVersion {
 472     return this.stationInfo.ocppVersion ? this.stationInfo.ocppVersion : OCPPVersion.VERSION_16;
 473   }
 474
 475   private handleUnsupportedVersion(version: OCPPVersion) {
 476     const errMsg = `${this.logPrefix()} Unsupported protocol version '${version}' configured in template file ${this.stationTemplateFile}`;
 477     logger.error(errMsg);
 478     throw new Error(errMsg);
 479   }
 480
 481   private initialize(): void {
 482     this.stationInfo = this.buildStationInfo();
 483     this.bootNotificationRequest = {
 484       chargePointModel: this.stationInfo.chargePointModel,
 485       chargePointVendor: this.stationInfo.chargePointVendor,
 486       ...!Utils.isUndefined(this.stationInfo.chargeBoxSerialNumberPrefix) && { chargeBoxSerialNumber: this.stationInfo.chargeBoxSerialNumberPrefix },
 487       ...!Utils.isUndefined(this.stationInfo.firmwareVersion) && { firmwareVersion: this.stationInfo.firmwareVersion },
 488     };
 489     this.configuration = this.getTemplateChargingStationConfiguration();
 490     this.wsConnectionUrl = new URL(this.getSupervisionURL().href + '/' + this.stationInfo.chargingStationId);
 491     // Build connectors if needed
 492     const maxConnectors = this.getMaxNumberOfConnectors();
 493     if (maxConnectors <= 0) {
 494       logger.warn(`${this.logPrefix()} Charging station template ${this.stationTemplateFile} with ${maxConnectors} connectors`);
 495     }
 496     const templateMaxConnectors = this.getTemplateMaxNumberOfConnectors();
 497     if (templateMaxConnectors <= 0) {
 498       logger.warn(`${this.logPrefix()} Charging station template ${this.stationTemplateFile} with no connector configuration`);
 499     }
 500     if (!this.stationInfo.Connectors[0]) {
 501       logger.warn(`${this.logPrefix()} Charging station template ${this.stationTemplateFile} with no connector Id 0 configuration`);
 502     }
 503     // Sanity check
 504     if (maxConnectors > (this.stationInfo.Connectors[0] ? templateMaxConnectors - 1 : templateMaxConnectors) && !this.stationInfo.randomConnectors) {
 505       logger.warn(`${this.logPrefix()} Number of connectors exceeds the number of connector configurations in template ${this.stationTemplateFile}, forcing random connector configurations affectation`);
 506       this.stationInfo.randomConnectors = true;
 507     }
 508     const connectorsConfigHash = crypto.createHash('sha256').update(JSON.stringify(this.stationInfo.Connectors) + maxConnectors.toString()).digest('hex');
 509     const connectorsConfigChanged = this.connectors?.size !== 0 && this.connectorsConfigurationHash !== connectorsConfigHash;
 510     if (this.connectors?.size === 0 || connectorsConfigChanged) {
 511       connectorsConfigChanged && (this.connectors.clear());
 512       this.connectorsConfigurationHash = connectorsConfigHash;
 513       // Add connector Id 0
 514       let lastConnector = '0';
 515       for (lastConnector in this.stationInfo.Connectors) {
 516         const lastConnectorId = Utils.convertToInt(lastConnector);
 517         if (lastConnectorId === 0 && this.getUseConnectorId0() && this.stationInfo.Connectors[lastConnector]) {
 518           this.connectors.set(lastConnectorId, Utils.cloneObject<ConnectorStatus>(this.stationInfo.Connectors[lastConnector]));
 519           this.getConnectorStatus(lastConnectorId).availability = AvailabilityType.OPERATIVE;
 520           if (Utils.isUndefined(this.getConnectorStatus(lastConnectorId)?.chargingProfiles)) {
 521             this.getConnectorStatus(lastConnectorId).chargingProfiles = [];
 522           }
 523         }
 524       }
 525       // Generate all connectors
 526       if ((this.stationInfo.Connectors[0] ? templateMaxConnectors - 1 : templateMaxConnectors) > 0) {
 527         for (let index = 1; index <= maxConnectors; index++) {
 528           const randConnectorId = this.stationInfo.randomConnectors ? Utils.getRandomInteger(Utils.convertToInt(lastConnector), 1) : index;
 529           this.connectors.set(index, Utils.cloneObject<ConnectorStatus>(this.stationInfo.Connectors[randConnectorId]));
 530           this.getConnectorStatus(index).availability = AvailabilityType.OPERATIVE;
 531           if (Utils.isUndefined(this.getConnectorStatus(index)?.chargingProfiles)) {
 532             this.getConnectorStatus(index).chargingProfiles = [];
 533           }
 534         }
 535       }
 536     }
 537     // Avoid duplication of connectors related information
 538     delete this.stationInfo.Connectors;
 539     // Initialize transaction attributes on connectors
 540     for (const connectorId of this.connectors.keys()) {
 541       if (connectorId > 0 && !this.getConnectorStatus(connectorId)?.transactionStarted) {
 542         this.initializeConnectorStatus(connectorId);
 543       }
 544     }
 545     switch (this.getOCPPVersion()) {
 546       case OCPPVersion.VERSION_16:
 547         this.ocppIncomingRequestService = new OCPP16IncomingRequestService(this);
 548         this.ocppRequestService = new OCPP16RequestService(this, new OCPP16ResponseService(this));
 549         break;
 550       default:
 551         this.handleUnsupportedVersion(this.getOCPPVersion());
 552         break;
 553     }
 554     // OCPP parameters
 555     this.initOCPPParameters();
 556     if (this.stationInfo.autoRegister) {
 557       this.bootNotificationResponse = {
 558         currentTime: new Date().toISOString(),
 559         interval: this.getHeartbeatInterval() / 1000,
 560         status: RegistrationStatus.ACCEPTED
 561       };
 562     }
 563     this.stationInfo.powerDivider = this.getPowerDivider();
 564     if (this.getEnableStatistics()) {
 565       this.performanceStatistics = new PerformanceStatistics(this.stationInfo.chargingStationId, this.wsConnectionUrl);
 566     }
 567   }
 568
 569   private initOCPPParameters(): void {
 570     if (!this.getConfigurationKey(StandardParametersKey.SupportedFeatureProfiles)) {
 571       this.addConfigurationKey(StandardParametersKey.SupportedFeatureProfiles, `${SupportedFeatureProfiles.Core},${SupportedFeatureProfiles.Local_Auth_List_Management},${SupportedFeatureProfiles.Smart_Charging}`);
 572     }
 573     this.addConfigurationKey(StandardParametersKey.NumberOfConnectors, this.getNumberOfConnectors().toString(), true);
 574     if (!this.getConfigurationKey(StandardParametersKey.MeterValuesSampledData)) {
 575       this.addConfigurationKey(StandardParametersKey.MeterValuesSampledData, MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER);
 576     }
 577     if (!this.getConfigurationKey(StandardParametersKey.ConnectorPhaseRotation)) {
 578       const connectorPhaseRotation = [];
 579       for (const connectorId of this.connectors.keys()) {
 580         // AC/DC
 581         if (connectorId === 0 && this.getNumberOfPhases() === 0) {
 582           connectorPhaseRotation.push(`${connectorId}.${ConnectorPhaseRotation.RST}`);
 583         } else if (connectorId > 0 && this.getNumberOfPhases() === 0) {
 584           connectorPhaseRotation.push(`${connectorId}.${ConnectorPhaseRotation.NotApplicable}`);
 585         // AC
 586         } else if (connectorId > 0 && this.getNumberOfPhases() === 1) {
 587           connectorPhaseRotation.push(`${connectorId}.${ConnectorPhaseRotation.NotApplicable}`);
 588         } else if (connectorId > 0 && this.getNumberOfPhases() === 3) {
 589           connectorPhaseRotation.push(`${connectorId}.${ConnectorPhaseRotation.RST}`);
 590         }
 591       }
 592       this.addConfigurationKey(StandardParametersKey.ConnectorPhaseRotation, connectorPhaseRotation.toString());
 593     }
 594     if (!this.getConfigurationKey(StandardParametersKey.AuthorizeRemoteTxRequests)) {
 595       this.addConfigurationKey(StandardParametersKey.AuthorizeRemoteTxRequests, 'true');
 596     }
 597     if (!this.getConfigurationKey(StandardParametersKey.LocalAuthListEnabled)
 598       && this.getConfigurationKey(StandardParametersKey.SupportedFeatureProfiles).value.includes(SupportedFeatureProfiles.Local_Auth_List_Management)) {
 599       this.addConfigurationKey(StandardParametersKey.LocalAuthListEnabled, 'false');
 600     }
 601     if (!this.getConfigurationKey(StandardParametersKey.ConnectionTimeOut)) {
 602       this.addConfigurationKey(StandardParametersKey.ConnectionTimeOut, Constants.DEFAULT_CONNECTION_TIMEOUT.toString());
 603     }
 604   }
 605
 606   private async onOpen(): Promise<void> {
 607     logger.info(`${this.logPrefix()} Connected to OCPP server through ${this.wsConnectionUrl.toString()}`);
 608     if (!this.isRegistered()) {
 609       // Send BootNotification
 610       let registrationRetryCount = 0;
 611       do {
 612         this.bootNotificationResponse = await this.ocppRequestService.sendBootNotification(this.bootNotificationRequest.chargePointModel,
 613           this.bootNotificationRequest.chargePointVendor, this.bootNotificationRequest.chargeBoxSerialNumber, this.bootNotificationRequest.firmwareVersion);
 614         if (!this.isRegistered()) {
 615           registrationRetryCount++;
 616           await Utils.sleep(this.bootNotificationResponse?.interval ? this.bootNotificationResponse.interval * 1000 : Constants.OCPP_DEFAULT_BOOT_NOTIFICATION_INTERVAL);
 617         }
 618       } while (!this.isRegistered() && (registrationRetryCount <= this.getRegistrationMaxRetries() || this.getRegistrationMaxRetries() === -1));
 619     }
 620     if (this.isRegistered()) {
 621       await this.startMessageSequence();
 622       this.stopped && (this.stopped = false);
 623       if (this.wsConnectionRestarted && this.isWebSocketConnectionOpened()) {
 624         this.flushMessageBuffer();
 625       }
 626     } else {
 627       logger.error(`${this.logPrefix()} Registration failure: max retries reached (${this.getRegistrationMaxRetries()}) or retry disabled (${this.getRegistrationMaxRetries()})`);
 628     }
 629     this.autoReconnectRetryCount = 0;
 630     this.wsConnectionRestarted = false;
 631   }
 632
 633   private async onClose(code: number, reason: string): Promise<void> {
 634     switch (code) {
 635       // Normal close
 636       case WebSocketCloseEventStatusCode.CLOSE_NORMAL:
 637       case WebSocketCloseEventStatusCode.CLOSE_NO_STATUS:
 638         logger.info(`${this.logPrefix()} WebSocket normally closed with status '${Utils.getWebSocketCloseEventStatusString(code)}' and reason '${reason}'`);
 639         this.autoReconnectRetryCount = 0;
 640         break;
 641       // Abnormal close
 642       default:
 643         logger.error(`${this.logPrefix()} WebSocket abnormally closed with status '${Utils.getWebSocketCloseEventStatusString(code)}' and reason '${reason}'`);
 644         await this.reconnect(code);
 645         break;
 646     }
 647   }
 648
 649   private async onMessage(data: Data): Promise<void> {
 650     let [messageType, messageId, commandName, commandPayload, errorDetails]: IncomingRequest = [0, '', '' as IncomingRequestCommand, {}, {}];
 651     let responseCallback: (payload: Record<string, unknown> | string, requestPayload: Record<string, unknown>) => void;
 652     let rejectCallback: (error: OCPPError, requestStatistic?: boolean) => void;
 653     let requestCommandName: RequestCommand | IncomingRequestCommand;
 654     let requestPayload: Record<string, unknown>;
 655     let cachedRequest: CachedRequest;
 656     let errMsg: string;
 657     try {
 658       const request = JSON.parse(data.toString()) as IncomingRequest;
 659       if (Utils.isIterable(request)) {
 660         // Parse the message
 661         [messageType, messageId, commandName, commandPayload, errorDetails] = request;
 662       } else {
 663         throw new OCPPError(ErrorType.PROTOCOL_ERROR, 'Incoming request is not iterable', commandName);
 664       }
 665       // Check the Type of message
 666       switch (messageType) {
 667         // Incoming Message
 668         case MessageType.CALL_MESSAGE:
 669           if (this.getEnableStatistics()) {
 670             this.performanceStatistics.addRequestStatistic(commandName, messageType);
 671           }
 672           // Process the call
 673           await this.ocppIncomingRequestService.handleRequest(messageId, commandName, commandPayload);
 674           break;
 675         // Outcome Message
 676         case MessageType.CALL_RESULT_MESSAGE:
 677           // Respond
 678           cachedRequest = this.requests.get(messageId);
 679           if (Utils.isIterable(cachedRequest)) {
 680             [responseCallback, , , requestPayload] = cachedRequest;
 681           } else {
 682             throw new OCPPError(ErrorType.PROTOCOL_ERROR, `Cached request for message id ${messageId} response is not iterable`, commandName);
 683           }
 684           if (!responseCallback) {
 685             // Error
 686             throw new OCPPError(ErrorType.INTERNAL_ERROR, `Response for unknown message id ${messageId}`, commandName);
 687           }
 688           responseCallback(commandName, requestPayload);
 689           break;
 690         // Error Message
 691         case MessageType.CALL_ERROR_MESSAGE:
 692           cachedRequest = this.requests.get(messageId);
 693           if (Utils.isIterable(cachedRequest)) {
 694             [, rejectCallback, requestCommandName] = cachedRequest;
 695           } else {
 696             throw new OCPPError(ErrorType.PROTOCOL_ERROR, `Cached request for message id ${messageId} error response is not iterable`);
 697           }
 698           if (!rejectCallback) {
 699             // Error
 700             throw new OCPPError(ErrorType.INTERNAL_ERROR, `Error response for unknown message id ${messageId}`, requestCommandName);
 701           }
 702           rejectCallback(new OCPPError(commandName, commandPayload.toString(), requestCommandName, errorDetails));
 703           break;
 704         // Error
 705         default:
 706           errMsg = `${this.logPrefix()} Wrong message type ${messageType}`;
 707           logger.error(errMsg);
 708           throw new OCPPError(ErrorType.PROTOCOL_ERROR, errMsg);
 709       }
 710     } catch (error) {
 711       // Log
 712       logger.error('%s Incoming OCPP message %j matching cached request %j processing error %j', this.logPrefix(), data.toString(), this.requests.get(messageId), error);
 713       // Send error
 714       messageType === MessageType.CALL_MESSAGE && await this.ocppRequestService.sendError(messageId, error, commandName);
 715     }
 716   }
 717
 718   private onPing(): void {
 719     logger.debug(this.logPrefix() + ' Received a WS ping (rfc6455) from the server');
 720   }
 721
 722   private onPong(): void {
 723     logger.debug(this.logPrefix() + ' Received a WS pong (rfc6455) from the server');
 724   }
 725
 726   private async onError(error: WSError): Promise<void> {
 727     logger.error(this.logPrefix() + ' WebSocket error: %j', error);
 728     // switch (error.code) {
 729     //   case 'ECONNREFUSED':
 730     //     await this.reconnect(error);
 731     //     break;
 732     // }
 733   }
 734
 735   private getTemplateChargingStationConfiguration(): ChargingStationConfiguration {
 736     return this.stationInfo.Configuration ?? {} as ChargingStationConfiguration;
 737   }
 738
 739   private getAuthorizationFile(): string | undefined {
 740     return this.stationInfo.authorizationFile && path.join(path.resolve(__dirname, '../'), 'assets', path.basename(this.stationInfo.authorizationFile));
 741   }
 742
 743   private getAuthorizedTags(): string[] {
 744     let authorizedTags: string[] = [];
 745     const authorizationFile = this.getAuthorizationFile();
 746     if (authorizationFile) {
 747       try {
 748         // Load authorization file
 749         const fileDescriptor = fs.openSync(authorizationFile, 'r');
 750         authorizedTags = JSON.parse(fs.readFileSync(fileDescriptor, 'utf8')) as string[];
 751         fs.closeSync(fileDescriptor);
 752       } catch (error) {
 753         FileUtils.handleFileException(this.logPrefix(), 'Authorization', authorizationFile, error);
 754       }
 755     } else {
 756       logger.info(this.logPrefix() + ' No authorization file given in template file ' + this.stationTemplateFile);
 757     }
 758     return authorizedTags;
 759   }
 760
 761   private getUseConnectorId0(): boolean | undefined {
 762     return !Utils.isUndefined(this.stationInfo.useConnectorId0) ? this.stationInfo.useConnectorId0 : true;
 763   }
 764
 765   private getNumberOfRunningTransactions(): number {
 766     let trxCount = 0;
 767     for (const connectorId of this.connectors.keys()) {
 768       if (connectorId > 0 && this.getConnectorStatus(connectorId)?.transactionStarted) {
 769         trxCount++;
 770       }
 771     }
 772     return trxCount;
 773   }
 774
 775   // 0 for disabling
 776   private getConnectionTimeout(): number | undefined {
 777     if (this.getConfigurationKey(StandardParametersKey.ConnectionTimeOut)) {
 778       return parseInt(this.getConfigurationKey(StandardParametersKey.ConnectionTimeOut).value) ?? Constants.DEFAULT_CONNECTION_TIMEOUT;
 779     }
 780     return Constants.DEFAULT_CONNECTION_TIMEOUT;
 781   }
 782
 783   // -1 for unlimited, 0 for disabling
 784   private getAutoReconnectMaxRetries(): number | undefined {
 785     if (!Utils.isUndefined(this.stationInfo.autoReconnectMaxRetries)) {
 786       return this.stationInfo.autoReconnectMaxRetries;
 787     }
 788     if (!Utils.isUndefined(Configuration.getAutoReconnectMaxRetries())) {
 789       return Configuration.getAutoReconnectMaxRetries();
 790     }
 791     return -1;
 792   }
 793
 794   // 0 for disabling
 795   private getRegistrationMaxRetries(): number | undefined {
 796     if (!Utils.isUndefined(this.stationInfo.registrationMaxRetries)) {
 797       return this.stationInfo.registrationMaxRetries;
 798     }
 799     return -1;
 800   }
 801
 802   private getPowerDivider(): number {
 803     let powerDivider = this.getNumberOfConnectors();
 804     if (this.stationInfo.powerSharedByConnectors) {
 805       powerDivider = this.getNumberOfRunningTransactions();
 806     }
 807     return powerDivider;
 808   }
 809
 810   private getTemplateMaxNumberOfConnectors(): number {
 811     return Object.keys(this.stationInfo.Connectors).length;
 812   }
 813
 814   private getMaxNumberOfConnectors(): number {
 815     let maxConnectors = 0;
 816     if (!Utils.isEmptyArray(this.stationInfo.numberOfConnectors)) {
 817       const numberOfConnectors = this.stationInfo.numberOfConnectors as number[];
 818       // Distribute evenly the number of connectors
 819       maxConnectors = numberOfConnectors[(this.index - 1) % numberOfConnectors.length];
 820     } else if (!Utils.isUndefined(this.stationInfo.numberOfConnectors)) {
 821       maxConnectors = this.stationInfo.numberOfConnectors as number;
 822     } else {
 823       maxConnectors = this.stationInfo.Connectors[0] ? this.getTemplateMaxNumberOfConnectors() - 1 : this.getTemplateMaxNumberOfConnectors();
 824     }
 825     return maxConnectors;
 826   }
 827
 828   private async startMessageSequence(): Promise<void> {
 829     // Start WebSocket ping
 830     this.startWebSocketPing();
 831     // Start heartbeat
 832     this.startHeartbeat();
 833     // Initialize connectors status
 834     for (const connectorId of this.connectors.keys()) {
 835       if (connectorId === 0) {
 836         continue;
 837       } else if (!this.stopped && !this.getConnectorStatus(connectorId)?.status && this.getConnectorStatus(connectorId)?.bootStatus) {
 838         // Send status in template at startup
 839         await this.ocppRequestService.sendStatusNotification(connectorId, this.getConnectorStatus(connectorId).bootStatus);
 840         this.getConnectorStatus(connectorId).status = this.getConnectorStatus(connectorId).bootStatus;
 841       } else if (this.stopped && this.getConnectorStatus(connectorId)?.status && this.getConnectorStatus(connectorId)?.bootStatus) {
 842         // Send status in template after reset
 843         await this.ocppRequestService.sendStatusNotification(connectorId, this.getConnectorStatus(connectorId).bootStatus);
 844         this.getConnectorStatus(connectorId).status = this.getConnectorStatus(connectorId).bootStatus;
 845       } else if (!this.stopped && this.getConnectorStatus(connectorId)?.status) {
 846         // Send previous status at template reload
 847         await this.ocppRequestService.sendStatusNotification(connectorId, this.getConnectorStatus(connectorId).status);
 848       } else {
 849         // Send default status
 850         await this.ocppRequestService.sendStatusNotification(connectorId, ChargePointStatus.AVAILABLE);
 851         this.getConnectorStatus(connectorId).status = ChargePointStatus.AVAILABLE;
 852       }
 853     }
 854     // Start the ATG
 855     this.startAutomaticTransactionGenerator();
 856   }
 857
 858   private startAutomaticTransactionGenerator() {
 859     if (this.stationInfo.AutomaticTransactionGenerator.enable) {
 860       if (!this.automaticTransactionGenerator) {
 861         this.automaticTransactionGenerator = new AutomaticTransactionGenerator(this);
 862       }
 863       if (!this.automaticTransactionGenerator.started) {
 864         this.automaticTransactionGenerator.start();
 865       }
 866     }
 867   }
 868
 869   private async stopMessageSequence(reason: StopTransactionReason = StopTransactionReason.NONE): Promise<void> {
 870     // Stop WebSocket ping
 871     this.stopWebSocketPing();
 872     // Stop heartbeat
 873     this.stopHeartbeat();
 874     // Stop the ATG
 875     if (this.stationInfo.AutomaticTransactionGenerator.enable &&
 876       this.automaticTransactionGenerator &&
 877       this.automaticTransactionGenerator.started) {
 878       this.automaticTransactionGenerator.stop();
 879     } else {
 880       for (const connectorId of this.connectors.keys()) {
 881         if (connectorId > 0 && this.getConnectorStatus(connectorId)?.transactionStarted) {
 882           const transactionId = this.getConnectorStatus(connectorId).transactionId;
 883           await this.ocppRequestService.sendStopTransaction(transactionId, this.getEnergyActiveImportRegisterByTransactionId(transactionId),
 884             this.getTransactionIdTag(transactionId), reason);
 885         }
 886       }
 887     }
 888   }
 889
 890   private startWebSocketPing(): void {
 891     const webSocketPingInterval: number = this.getConfigurationKey(StandardParametersKey.WebSocketPingInterval)
 892       ? Utils.convertToInt(this.getConfigurationKey(StandardParametersKey.WebSocketPingInterval).value)
 893       : 0;
 894     if (webSocketPingInterval > 0 && !this.webSocketPingSetInterval) {
 895       this.webSocketPingSetInterval = setInterval(() => {
 896         if (this.isWebSocketConnectionOpened()) {
 897           this.wsConnection.ping((): void => { /* This is intentional */ });
 898         }
 899       }, webSocketPingInterval * 1000);
 900       logger.info(this.logPrefix() + ' WebSocket ping started every ' + Utils.formatDurationSeconds(webSocketPingInterval));
 901     } else if (this.webSocketPingSetInterval) {
 902       logger.info(this.logPrefix() + ' WebSocket ping every ' + Utils.formatDurationSeconds(webSocketPingInterval) + ' already started');
 903     } else {
 904       logger.error(`${this.logPrefix()} WebSocket ping interval set to ${webSocketPingInterval ? Utils.formatDurationSeconds(webSocketPingInterval) : webSocketPingInterval}, not starting the WebSocket ping`);
 905     }
 906   }
 907
 908   private stopWebSocketPing(): void {
 909     if (this.webSocketPingSetInterval) {
 910       clearInterval(this.webSocketPingSetInterval);
 911     }
 912   }
 913
 914   private getSupervisionURL(): URL {
 915     const supervisionUrls = Utils.cloneObject<string | string[]>(this.stationInfo.supervisionURL ? this.stationInfo.supervisionURL : Configuration.getSupervisionURLs());
 916     let indexUrl = 0;
 917     if (!Utils.isEmptyArray(supervisionUrls)) {
 918       if (Configuration.getDistributeStationsToTenantsEqually()) {
 919         indexUrl = this.index % supervisionUrls.length;
 920       } else {
 921         // Get a random url
 922         indexUrl = Math.floor(Utils.secureRandom() * supervisionUrls.length);
 923       }
 924       return new URL(supervisionUrls[indexUrl]);
 925     }
 926     return new URL(supervisionUrls as string);
 927   }
 928
 929   private getHeartbeatInterval(): number | undefined {
 930     const HeartbeatInterval = this.getConfigurationKey(StandardParametersKey.HeartbeatInterval);
 931     if (HeartbeatInterval) {
 932       return Utils.convertToInt(HeartbeatInterval.value) * 1000;
 933     }
 934     const HeartBeatInterval = this.getConfigurationKey(StandardParametersKey.HeartBeatInterval);
 935     if (HeartBeatInterval) {
 936       return Utils.convertToInt(HeartBeatInterval.value) * 1000;
 937     }
 938     !this.stationInfo.autoRegister && logger.warn(`${this.logPrefix()} Heartbeat interval configuration key not set, using default value: ${Constants.DEFAULT_HEARTBEAT_INTERVAL}`);
 939     return Constants.DEFAULT_HEARTBEAT_INTERVAL;
 940   }
 941
 942   private stopHeartbeat(): void {
 943     if (this.heartbeatSetInterval) {
 944       clearInterval(this.heartbeatSetInterval);
 945     }
 946   }
 947
 948   private openWSConnection(options: ClientOptions & ClientRequestArgs = this.stationInfo.wsOptions, forceCloseOpened = false): void {
 949     if (!Utils.isNullOrUndefined(this.stationInfo.supervisionUser) && !Utils.isNullOrUndefined(this.stationInfo.supervisionPassword)) {
 950       options.auth = `${this.stationInfo.supervisionUser}:${this.stationInfo.supervisionPassword}`;
 951     }
 952     if (this.isWebSocketConnectionOpened() && forceCloseOpened) {
 953       this.wsConnection.close();
 954     }
 955     let protocol;
 956     switch (this.getOCPPVersion()) {
 957       case OCPPVersion.VERSION_16:
 958         protocol = 'ocpp' + OCPPVersion.VERSION_16;
 959         break;
 960       default:
 961         this.handleUnsupportedVersion(this.getOCPPVersion());
 962         break;
 963     }
 964     this.wsConnection = new WebSocket(this.wsConnectionUrl, protocol, options);
 965     logger.info(this.logPrefix() + ' Open OCPP connection to URL ' + this.wsConnectionUrl.toString());
 966   }
 967
 968   private stopMeterValues(connectorId: number) {
 969     if (this.getConnectorStatus(connectorId)?.transactionSetInterval) {
 970       clearInterval(this.getConnectorStatus(connectorId).transactionSetInterval);
 971     }
 972   }
 973
 974   private startAuthorizationFileMonitoring(): void {
 975     const authorizationFile = this.getAuthorizationFile();
 976     if (authorizationFile) {
 977       try {
 978         fs.watch(authorizationFile, (event, filename) => {
 979           if (filename && event === 'change') {
 980             try {
 981               logger.debug(this.logPrefix() + ' Authorization file ' + authorizationFile + ' have changed, reload');
 982               // Initialize authorizedTags
 983               this.authorizedTags = this.getAuthorizedTags();
 984             } catch (error) {
 985               logger.error(this.logPrefix() + ' Authorization file monitoring error: %j', error);
 986             }
 987           }
 988         });
 989       } catch (error) {
 990         FileUtils.handleFileException(this.logPrefix(), 'Authorization', authorizationFile, error);
 991       }
 992     } else {
 993       logger.info(this.logPrefix() + ' No authorization file given in template file ' + this.stationTemplateFile + '. Not monitoring changes');
 994     }
 995   }
 996
 997   private startStationTemplateFileMonitoring(): void {
 998     try {
 999       fs.watch(this.stationTemplateFile, (event, filename): void => {
1000         if (filename && event === 'change') {
1001           try {
1002             logger.debug(this.logPrefix() + ' Template file ' + this.stationTemplateFile + ' have changed, reload');
1003             // Initialize
1004             this.initialize();
1005             // Restart the ATG
1006             if (!this.stationInfo.AutomaticTransactionGenerator.enable &&
1007               this.automaticTransactionGenerator) {
1008               this.automaticTransactionGenerator.stop();
1009             }
1010             this.startAutomaticTransactionGenerator();
1011             if (this.getEnableStatistics()) {
1012               this.performanceStatistics.restart();
1013             } else {
1014               this.performanceStatistics.stop();
1015             }
1016             // FIXME?: restart heartbeat and WebSocket ping when their interval values have changed
1017           } catch (error) {
1018             logger.error(this.logPrefix() + ' Charging station template file monitoring error: %j', error);
1019           }
1020         }
1021       });
1022     } catch (error) {
1023       FileUtils.handleFileException(this.logPrefix(), 'Template', this.stationTemplateFile, error);
1024     }
1025   }
1026
1027   private getReconnectExponentialDelay(): boolean | undefined {
1028     return !Utils.isUndefined(this.stationInfo.reconnectExponentialDelay) ? this.stationInfo.reconnectExponentialDelay : false;
1029   }
1030
1031   private async reconnect(code: number): Promise<void> {
1032     // Stop WebSocket ping
1033     this.stopWebSocketPing();
1034     // Stop heartbeat
1035     this.stopHeartbeat();
1036     // Stop the ATG if needed
1037     if (this.stationInfo.AutomaticTransactionGenerator.enable &&
1038       this.stationInfo.AutomaticTransactionGenerator.stopOnConnectionFailure &&
1039       this.automaticTransactionGenerator &&
1040       this.automaticTransactionGenerator.started) {
1041       this.automaticTransactionGenerator.stop();
1042     }
1043     if (this.autoReconnectRetryCount < this.getAutoReconnectMaxRetries() || this.getAutoReconnectMaxRetries() === -1) {
1044       this.autoReconnectRetryCount++;
1045       const reconnectDelay = (this.getReconnectExponentialDelay() ? Utils.exponentialDelay(this.autoReconnectRetryCount) : this.getConnectionTimeout() * 1000);
1046       const reconnectTimeout = (reconnectDelay - 100) > 0 ? reconnectDelay : 0;
1047       logger.error(`${this.logPrefix()} WebSocket: connection retry in ${Utils.roundTo(reconnectDelay, 2)}ms, timeout ${reconnectTimeout}ms`);
1048       await Utils.sleep(reconnectDelay);
1049       logger.error(this.logPrefix() + ' WebSocket: reconnecting try #' + this.autoReconnectRetryCount.toString());
1050       this.openWSConnection({ ...this.stationInfo.wsOptions, handshakeTimeout: reconnectTimeout }, true);
1051       this.wsConnectionRestarted = true;
1052     } else if (this.getAutoReconnectMaxRetries() !== -1) {
1053       logger.error(`${this.logPrefix()} WebSocket reconnect failure: max retries reached (${this.autoReconnectRetryCount}) or retry disabled (${this.getAutoReconnectMaxRetries()})`);
1054     }
1055   }
1056
1057   private initializeConnectorStatus(connectorId: number): void {
1058     this.getConnectorStatus(connectorId).idTagLocalAuthorized = false;
1059     this.getConnectorStatus(connectorId).idTagAuthorized = false;
1060     this.getConnectorStatus(connectorId).transactionRemoteStarted = false;
1061     this.getConnectorStatus(connectorId).transactionStarted = false;
1062     this.getConnectorStatus(connectorId).energyActiveImportRegisterValue = 0;
1063     this.getConnectorStatus(connectorId).transactionEnergyActiveImportRegisterValue = 0;
1064   }
1065 }
1066