src/charging-station/ChargingStation.ts

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