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