src/charging-station/ChargingStation.ts

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