1 import { BootNotificationResponse
, RegistrationStatus
} from
'../types/ocpp/Responses';
2 import ChargingStationConfiguration
, { ConfigurationKey
} from
'../types/ChargingStationConfiguration';
3 import ChargingStationTemplate
, { CurrentOutType
, PowerUnits
, 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';
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';
32 import logger from
'../utils/Logger';
33 import path from
'path';
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
;
61 constructor(index
: number, stationTemplateFile
: string) {
63 this.stationTemplateFile
= stationTemplateFile
;
64 this.connectors
= {} as Connectors
;
67 this.hasStopped
= false;
68 this.hasSocketRestarted
= false;
69 this.autoReconnectRetryCount
= 0;
71 this.requests
= {} as Requests
;
72 this.messageQueue
= [] as string[];
74 this.authorizedTags
= this.getAuthorizedTags();
77 public logPrefix(): string {
78 return Utils
.logPrefix(` ${this.stationInfo.chargingStationId} |`);
81 public getRandomTagId(): string {
82 const index
= Math.floor(Math.random() * this.authorizedTags
.length
);
83 return this.authorizedTags
[index
];
86 public hasAuthorizedTags(): boolean {
87 return !Utils
.isEmptyArray(this.authorizedTags
);
90 public getEnableStatistics(): boolean | undefined {
91 return !Utils
.isUndefined(this.stationInfo
.enableStatistics
) ? this.stationInfo
.enableStatistics
: true;
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
:
103 public isWebSocketOpen(): boolean {
104 return this.wsConnection
?.readyState
=== WebSocket
.OPEN
;
107 public isRegistered(): boolean {
108 return this.bootNotificationResponse
?.status === RegistrationStatus
.ACCEPTED
;
111 public isChargingStationAvailable(): boolean {
112 return this.getConnector(0).availability
=== AvailabilityType
.OPERATIVE
;
115 public isConnectorAvailable(id
: number): boolean {
116 return this.getConnector(id
).availability
=== AvailabilityType
.OPERATIVE
;
119 public getConnector(id
: number): Connector
{
120 return this.connectors
[id
];
123 public getCurrentOutType(): CurrentOutType
| undefined {
124 return !Utils
.isUndefined(this.stationInfo
.currentOutType
) ? this.stationInfo
.currentOutType
: CurrentOutType
.AC
;
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
;
134 case CurrentOutType
.DC
:
135 defaultVoltageOut
= VoltageOut
.VOLTAGE_400
;
138 logger
.error(errMsg
);
141 return !Utils
.isUndefined(this.stationInfo
.voltageOut
) ? this.stationInfo
.voltageOut
: defaultVoltageOut
;
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
;
152 public getOutOfOrderEndMeterValues(): boolean {
153 return this.stationInfo
.outOfOrderEndMeterValues
?? false;
156 public getBeginEndMeterValues(): boolean {
157 return this.stationInfo
.beginEndMeterValues
?? false;
160 public getMeteringPerTransaction(): boolean {
161 return this.stationInfo
.meteringPerTransaction
?? true;
164 public getEnergyActiveImportRegisterByTransactionId(transactionId
: number): number | undefined {
165 if (this.getMeteringPerTransaction()) {
166 for (const connector
in this.connectors
) {
167 if (Utils
.convertToInt(connector
) > 0 && this.getConnector(Utils
.convertToInt(connector
)).transactionId
=== transactionId
) {
168 return this.getConnector(Utils
.convertToInt(connector
)).transactionEnergyActiveImportRegisterValue
;
172 for (const connector
in this.connectors
) {
173 if (Utils
.convertToInt(connector
) > 0 && this.getConnector(Utils
.convertToInt(connector
)).transactionId
=== transactionId
) {
174 return this.getConnector(Utils
.convertToInt(connector
)).energyActiveImportRegisterValue
;
179 public getEnergyActiveImportRegisterByConnectorId(connectorId
: number): number | undefined {
180 if (this.getMeteringPerTransaction()) {
181 return this.getConnector(connectorId
).transactionEnergyActiveImportRegisterValue
;
183 return this.getConnector(connectorId
).energyActiveImportRegisterValue
;
186 public getAuthorizeRemoteTxRequests(): boolean {
187 const authorizeRemoteTxRequests
= this.getConfigurationKey(StandardParametersKey
.AuthorizeRemoteTxRequests
);
188 return authorizeRemoteTxRequests
? Utils
.convertToBoolean(authorizeRemoteTxRequests
.value
) : false;
191 public getLocalAuthListEnabled(): boolean {
192 const localAuthListEnabled
= this.getConfigurationKey(StandardParametersKey
.LocalAuthListEnabled
);
193 return localAuthListEnabled
? Utils
.convertToBoolean(localAuthListEnabled
.value
) : false;
196 public restartWebSocketPing(): void {
197 // Stop WebSocket ping
198 this.stopWebSocketPing();
199 // Start WebSocket ping
200 this.startWebSocketPing();
203 public getAutomaticTransactionGeneratorRequireAuthorize(): boolean {
204 return this.stationInfo
.AutomaticTransactionGenerator
.requireAuthorize
?? true;
207 public startHeartbeat(): void {
208 if (this.getHeartbeatInterval() && this.getHeartbeatInterval() > 0 && !this.heartbeatSetInterval
) {
209 // eslint-disable-next-line @typescript-eslint/no-misused-promises
210 this.heartbeatSetInterval
= setInterval(async (): Promise
<void> => {
211 await this.ocppRequestService
.sendHeartbeat();
212 }, this.getHeartbeatInterval());
213 logger
.info(this.logPrefix() + ' Heartbeat started every ' + Utils
.milliSecondsToHHMMSS(this.getHeartbeatInterval()));
214 } else if (this.heartbeatSetInterval
) {
215 logger
.info(this.logPrefix() + ' Heartbeat already started every ' + Utils
.milliSecondsToHHMMSS(this.getHeartbeatInterval()));
217 logger
.error(`${this.logPrefix()} Heartbeat interval set to ${this.getHeartbeatInterval() ? Utils.milliSecondsToHHMMSS(this.getHeartbeatInterval()) : this.getHeartbeatInterval()}, not starting the heartbeat`);
221 public restartHeartbeat(): void {
223 this.stopHeartbeat();
225 this.startHeartbeat();
228 public startMeterValues(connectorId
: number, interval
: number): void {
229 if (connectorId
=== 0) {
230 logger
.error(`${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId.toString()}`);
233 if (!this.getConnector(connectorId
)) {
234 logger
.error(`${this.logPrefix()} Trying to start MeterValues on non existing connector Id ${connectorId.toString()}`);
237 if (!this.getConnector(connectorId
)?.transactionStarted
) {
238 logger
.error(`${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId} with no transaction started`);
240 } else if (this.getConnector(connectorId
)?.transactionStarted
&& !this.getConnector(connectorId
)?.transactionId
) {
241 logger
.error(`${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId} with no transaction id`);
245 // eslint-disable-next-line @typescript-eslint/no-misused-promises
246 this.getConnector(connectorId
).transactionSetInterval
= setInterval(async (): Promise
<void> => {
247 if (this.getEnableStatistics()) {
248 const sendMeterValues
= performance
.timerify(this.ocppRequestService
.sendMeterValues
);
249 this.performanceObserver
.observe({
250 entryTypes
: ['function'],
252 await sendMeterValues(connectorId
, this.getConnector(connectorId
).transactionId
, interval
, this.ocppRequestService
);
254 await this.ocppRequestService
.sendMeterValues(connectorId
, this.getConnector(connectorId
).transactionId
, interval
, this.ocppRequestService
);
258 logger
.error(`${this.logPrefix()} Charging station ${StandardParametersKey.MeterValueSampleInterval} configuration set to ${interval ? Utils.milliSecondsToHHMMSS(interval) : interval}, not sending MeterValues`);
262 public start(): void {
263 this.openWSConnection();
264 // Monitor authorization file
265 this.startAuthorizationFileMonitoring();
266 // Monitor station template file
267 this.startStationTemplateFileMonitoring();
268 // Handle Socket incoming messages
269 this.wsConnection
.on('message', this.onMessage
.bind(this));
270 // Handle Socket error
271 this.wsConnection
.on('error', this.onError
.bind(this));
272 // Handle Socket close
273 this.wsConnection
.on('close', this.onClose
.bind(this));
274 // Handle Socket opening connection
275 this.wsConnection
.on('open', this.onOpen
.bind(this));
276 // Handle Socket ping
277 this.wsConnection
.on('ping', this.onPing
.bind(this));
278 // Handle Socket pong
279 this.wsConnection
.on('pong', this.onPong
.bind(this));
282 public async stop(reason
: StopTransactionReason
= StopTransactionReason
.NONE
): Promise
<void> {
283 // Stop message sequence
284 await this.stopMessageSequence(reason
);
285 for (const connector
in this.connectors
) {
286 if (Utils
.convertToInt(connector
) > 0) {
287 await this.ocppRequestService
.sendStatusNotification(Utils
.convertToInt(connector
), ChargePointStatus
.UNAVAILABLE
);
288 this.getConnector(Utils
.convertToInt(connector
)).status = ChargePointStatus
.UNAVAILABLE
;
291 if (this.isWebSocketOpen()) {
292 this.wsConnection
.close();
294 this.bootNotificationResponse
= null;
295 this.hasStopped
= true;
298 public getConfigurationKey(key
: string | StandardParametersKey
, caseInsensitive
= false): ConfigurationKey
| undefined {
299 const configurationKey
: ConfigurationKey
| undefined = this.configuration
.configurationKey
.find((configElement
) => {
300 if (caseInsensitive
) {
301 return configElement
.key
.toLowerCase() === key
.toLowerCase();
303 return configElement
.key
=== key
;
305 return configurationKey
;
308 public addConfigurationKey(key
: string | StandardParametersKey
, value
: string, readonly = false, visible
= true, reboot
= false): void {
309 const keyFound
= this.getConfigurationKey(key
);
311 this.configuration
.configurationKey
.push({
319 logger
.error(`${this.logPrefix()} Trying to add an already existing configuration key: %j`, keyFound
);
323 public setConfigurationKeyValue(key
: string | StandardParametersKey
, value
: string): void {
324 const keyFound
= this.getConfigurationKey(key
);
326 const keyIndex
= this.configuration
.configurationKey
.indexOf(keyFound
);
327 this.configuration
.configurationKey
[keyIndex
].value
= value
;
329 logger
.error(`${this.logPrefix()} Trying to set a value on a non existing configuration key: %j`, { key
, value
});
333 public setChargingProfile(connectorId
: number, cp
: ChargingProfile
): boolean {
334 if (!Utils
.isEmptyArray(this.getConnector(connectorId
).chargingProfiles
)) {
335 this.getConnector(connectorId
).chargingProfiles
?.forEach((chargingProfile
: ChargingProfile
, index
: number) => {
336 if (chargingProfile
.chargingProfileId
=== cp
.chargingProfileId
337 || (chargingProfile
.stackLevel
=== cp
.stackLevel
&& chargingProfile
.chargingProfilePurpose
=== cp
.chargingProfilePurpose
)) {
338 this.getConnector(connectorId
).chargingProfiles
[index
] = cp
;
343 this.getConnector(connectorId
).chargingProfiles
?.push(cp
);
347 public resetTransactionOnConnector(connectorId
: number): void {
348 this.getConnector(connectorId
).transactionStarted
= false;
349 delete this.getConnector(connectorId
).transactionId
;
350 delete this.getConnector(connectorId
).idTag
;
351 this.getConnector(connectorId
).transactionEnergyActiveImportRegisterValue
= 0;
352 this.stopMeterValues(connectorId
);
355 public addToMessageQueue(message
: string): void {
357 // Handle dups in message queue
358 for (const bufferedMessage
of this.messageQueue
) {
359 // Message already in the queue
360 if (message
=== bufferedMessage
) {
367 this.messageQueue
.push(message
);
371 private flushMessageQueue() {
372 if (!Utils
.isEmptyArray(this.messageQueue
)) {
373 this.messageQueue
.forEach((message
, index
) => {
374 this.messageQueue
.splice(index
, 1);
375 this.wsConnection
.send(message
);
380 private getChargingStationId(stationTemplate
: ChargingStationTemplate
): string {
381 // In case of multiple instances: add instance index to charging station id
382 let instanceIndex
= process
.env
.CF_INSTANCE_INDEX
? process
.env
.CF_INSTANCE_INDEX
: 0;
383 instanceIndex
= instanceIndex
> 0 ? instanceIndex
: '';
384 const idSuffix
= stationTemplate
.nameSuffix
? stationTemplate
.nameSuffix
: '';
385 return stationTemplate
.fixedName
? stationTemplate
.baseName
: stationTemplate
.baseName
+ '-' + instanceIndex
.toString() + ('000000000' + this.index
.toString()).substr(('000000000' + this.index
.toString()).length
- 4) + idSuffix
;
388 private buildStationInfo(): ChargingStationInfo
{
389 let stationTemplateFromFile
: ChargingStationTemplate
;
391 // Load template file
392 const fileDescriptor
= fs
.openSync(this.stationTemplateFile
, 'r');
393 stationTemplateFromFile
= JSON
.parse(fs
.readFileSync(fileDescriptor
, 'utf8')) as ChargingStationTemplate
;
394 fs
.closeSync(fileDescriptor
);
396 FileUtils
.handleFileException(this.logPrefix(), 'Template', this.stationTemplateFile
, error
);
398 const stationInfo
: ChargingStationInfo
= stationTemplateFromFile
?? {} as ChargingStationInfo
;
399 if (!Utils
.isEmptyArray(stationTemplateFromFile
.power
)) {
400 stationTemplateFromFile
.power
= stationTemplateFromFile
.power
as number[];
401 const powerArrayRandomIndex
= Math.floor(Math.random() * stationTemplateFromFile
.power
.length
);
402 stationInfo
.maxPower
= stationTemplateFromFile
.powerUnit
=== PowerUnits
.KILO_WATT
403 ? stationTemplateFromFile
.power
[powerArrayRandomIndex
] * 1000
404 : stationTemplateFromFile
.power
[powerArrayRandomIndex
];
406 stationTemplateFromFile
.power
= stationTemplateFromFile
.power
as number;
407 stationInfo
.maxPower
= stationTemplateFromFile
.powerUnit
=== PowerUnits
.KILO_WATT
408 ? (stationTemplateFromFile
.power
) * 1000
409 : stationTemplateFromFile
.power
;
411 stationInfo
.chargingStationId
= this.getChargingStationId(stationTemplateFromFile
);
412 stationInfo
.resetTime
= stationTemplateFromFile
.resetTime
? stationTemplateFromFile
.resetTime
* 1000 : Constants
.CHARGING_STATION_DEFAULT_RESET_TIME
;
416 private getOCPPVersion(): OCPPVersion
{
417 return this.stationInfo
.ocppVersion
? this.stationInfo
.ocppVersion
: OCPPVersion
.VERSION_16
;
420 private handleUnsupportedVersion(version
: OCPPVersion
) {
421 const errMsg
= `${this.logPrefix()} Unsupported protocol version '${version}' configured in template file ${this.stationTemplateFile}`;
422 logger
.error(errMsg
);
423 throw new Error(errMsg
);
426 private initialize(): void {
427 this.stationInfo
= this.buildStationInfo();
428 this.bootNotificationRequest
= {
429 chargePointModel
: this.stationInfo
.chargePointModel
,
430 chargePointVendor
: this.stationInfo
.chargePointVendor
,
431 ...!Utils
.isUndefined(this.stationInfo
.chargeBoxSerialNumberPrefix
) && { chargeBoxSerialNumber
: this.stationInfo
.chargeBoxSerialNumberPrefix
},
432 ...!Utils
.isUndefined(this.stationInfo
.firmwareVersion
) && { firmwareVersion
: this.stationInfo
.firmwareVersion
},
434 this.configuration
= this.getTemplateChargingStationConfiguration();
435 this.supervisionUrl
= this.getSupervisionURL();
436 this.wsConnectionUrl
= this.supervisionUrl
+ '/' + this.stationInfo
.chargingStationId
;
437 // Build connectors if needed
438 const maxConnectors
= this.getMaxNumberOfConnectors();
439 if (maxConnectors
<= 0) {
440 logger
.warn(`${this.logPrefix()} Charging station template ${this.stationTemplateFile} with ${maxConnectors} connectors`);
442 const templateMaxConnectors
= this.getTemplateMaxNumberOfConnectors();
443 if (templateMaxConnectors
<= 0) {
444 logger
.warn(`${this.logPrefix()} Charging station template ${this.stationTemplateFile} with no connector configuration`);
446 if (!this.stationInfo
.Connectors
[0]) {
447 logger
.warn(`${this.logPrefix()} Charging station template ${this.stationTemplateFile} with no connector Id 0 configuration`);
450 if (maxConnectors
> (this.stationInfo
.Connectors
[0] ? templateMaxConnectors
- 1 : templateMaxConnectors
) && !this.stationInfo
.randomConnectors
) {
451 logger
.warn(`${this.logPrefix()} Number of connectors exceeds the number of connector configurations in template ${this.stationTemplateFile}, forcing random connector configurations affectation`);
452 this.stationInfo
.randomConnectors
= true;
454 const connectorsConfigHash
= crypto
.createHash('sha256').update(JSON
.stringify(this.stationInfo
.Connectors
) + maxConnectors
.toString()).digest('hex');
455 // FIXME: Handle shrinking the number of connectors
456 if (!this.connectors
|| (this.connectors
&& this.connectorsConfigurationHash
!== connectorsConfigHash
)) {
457 this.connectorsConfigurationHash
= connectorsConfigHash
;
458 // Add connector Id 0
459 let lastConnector
= '0';
460 for (lastConnector
in this.stationInfo
.Connectors
) {
461 if (Utils
.convertToInt(lastConnector
) === 0 && this.getUseConnectorId0() && this.stationInfo
.Connectors
[lastConnector
]) {
462 this.connectors
[lastConnector
] = Utils
.cloneObject
<Connector
>(this.stationInfo
.Connectors
[lastConnector
]);
463 this.connectors
[lastConnector
].availability
= AvailabilityType
.OPERATIVE
;
464 if (Utils
.isUndefined(this.connectors
[lastConnector
]?.chargingProfiles
)) {
465 this.connectors
[lastConnector
].chargingProfiles
= [];
469 // Generate all connectors
470 if ((this.stationInfo
.Connectors
[0] ? templateMaxConnectors
- 1 : templateMaxConnectors
) > 0) {
471 for (let index
= 1; index
<= maxConnectors
; index
++) {
472 const randConnectorID
= this.stationInfo
.randomConnectors
? Utils
.getRandomInt(Utils
.convertToInt(lastConnector
), 1) : index
;
473 this.connectors
[index
] = Utils
.cloneObject
<Connector
>(this.stationInfo
.Connectors
[randConnectorID
]);
474 this.connectors
[index
].availability
= AvailabilityType
.OPERATIVE
;
475 if (Utils
.isUndefined(this.connectors
[lastConnector
]?.chargingProfiles
)) {
476 this.connectors
[index
].chargingProfiles
= [];
481 // Avoid duplication of connectors related information
482 delete this.stationInfo
.Connectors
;
483 // Initialize transaction attributes on connectors
484 for (const connector
in this.connectors
) {
485 if (Utils
.convertToInt(connector
) > 0 && !this.getConnector(Utils
.convertToInt(connector
)).transactionStarted
) {
486 this.initTransactionAttributesOnConnector(Utils
.convertToInt(connector
));
489 switch (this.getOCPPVersion()) {
490 case OCPPVersion
.VERSION_16
:
491 this.ocppIncomingRequestService
= new OCPP16IncomingRequestService(this);
492 this.ocppRequestService
= new OCPP16RequestService(this, new OCPP16ResponseService(this));
495 this.handleUnsupportedVersion(this.getOCPPVersion());
499 this.addConfigurationKey(StandardParametersKey
.NumberOfConnectors
, this.getNumberOfConnectors().toString(), true);
500 if (!this.getConfigurationKey(StandardParametersKey
.MeterValuesSampledData
)) {
501 this.addConfigurationKey(StandardParametersKey
.MeterValuesSampledData
, MeterValueMeasurand
.ENERGY_ACTIVE_IMPORT_REGISTER
);
503 this.stationInfo
.powerDivider
= this.getPowerDivider();
504 if (this.getEnableStatistics()) {
505 this.performanceStatistics
= new PerformanceStatistics(this.stationInfo
.chargingStationId
);
506 this.performanceObserver
= new PerformanceObserver((list
) => {
507 const entry
= list
.getEntries()[0];
508 this.performanceStatistics
.logPerformance(entry
, Constants
.ENTITY_CHARGING_STATION
);
509 this.performanceObserver
.disconnect();
514 private async onOpen(): Promise
<void> {
515 logger
.info(`${this.logPrefix()} Is connected to server through ${this.wsConnectionUrl}`);
516 if (!this.isRegistered()) {
517 // Send BootNotification
518 let registrationRetryCount
= 0;
520 this.bootNotificationResponse
= await this.ocppRequestService
.sendBootNotification(this.bootNotificationRequest
.chargePointModel
,
521 this.bootNotificationRequest
.chargePointVendor
, this.bootNotificationRequest
.chargeBoxSerialNumber
, this.bootNotificationRequest
.firmwareVersion
);
522 if (!this.isRegistered()) {
523 registrationRetryCount
++;
524 await Utils
.sleep(this.bootNotificationResponse
?.interval
? this.bootNotificationResponse
.interval
* 1000 : Constants
.OCPP_DEFAULT_BOOT_NOTIFICATION_INTERVAL
);
526 } while (!this.isRegistered() && (registrationRetryCount
<= this.getRegistrationMaxRetries() || this.getRegistrationMaxRetries() === -1));
528 if (this.isRegistered()) {
529 await this.startMessageSequence();
530 this.hasStopped
&& (this.hasStopped
= false);
531 if (this.hasSocketRestarted
&& this.isWebSocketOpen()) {
532 this.flushMessageQueue();
535 logger
.error(`${this.logPrefix()} Registration failure: max retries reached (${this.getRegistrationMaxRetries()}) or retry disabled (${this.getRegistrationMaxRetries()})`);
537 this.autoReconnectRetryCount
= 0;
538 this.hasSocketRestarted
= false;
541 private async onClose(closeEvent
: any): Promise
<void> {
542 switch (closeEvent
) {
543 case WebSocketCloseEventStatusCode
.CLOSE_NORMAL
: // Normal close
544 case WebSocketCloseEventStatusCode
.CLOSE_NO_STATUS
:
545 logger
.info(`${this.logPrefix()} Socket normally closed with status '${Utils.getWebSocketCloseEventStatusString(closeEvent)}'`);
546 this.autoReconnectRetryCount
= 0;
548 default: // Abnormal close
549 logger
.error(`${this.logPrefix()} Socket abnormally closed with status '${Utils.getWebSocketCloseEventStatusString(closeEvent)}'`);
550 await this.reconnect(closeEvent
);
555 private async onMessage(messageEvent
: MessageEvent
): Promise
<void> {
556 let [messageType
, messageId
, commandName
, commandPayload
, errorDetails
]: IncomingRequest
= [0, '', '' as IncomingRequestCommand
, {}, {}];
557 let responseCallback
: (payload
: Record
<string, unknown
> | string, requestPayload
: Record
<string, unknown
>) => void;
558 let rejectCallback
: (error
: OCPPError
) => void;
559 let requestPayload
: Record
<string, unknown
>;
563 [messageType
, messageId
, commandName
, commandPayload
, errorDetails
] = JSON
.parse(messageEvent
.toString()) as IncomingRequest
;
564 // Check the Type of message
565 switch (messageType
) {
567 case MessageType
.CALL_MESSAGE
:
568 if (this.getEnableStatistics()) {
569 this.performanceStatistics
.addMessage(commandName
, messageType
);
572 await this.ocppIncomingRequestService
.handleRequest(messageId
, commandName
, commandPayload
);
575 case MessageType
.CALL_RESULT_MESSAGE
:
577 if (Utils
.isIterable(this.requests
[messageId
])) {
578 [responseCallback
, , requestPayload
] = this.requests
[messageId
];
580 throw new Error(`Response request for message id ${messageId} is not iterable`);
582 if (!responseCallback
) {
584 throw new Error(`Response request for unknown message id ${messageId}`);
586 delete this.requests
[messageId
];
587 responseCallback(commandName
, requestPayload
);
590 case MessageType
.CALL_ERROR_MESSAGE
:
591 if (!this.requests
[messageId
]) {
593 throw new Error(`Error request for unknown message id ${messageId}`);
595 if (Utils
.isIterable(this.requests
[messageId
])) {
596 [, rejectCallback
] = this.requests
[messageId
];
598 throw new Error(`Error request for message id ${messageId} is not iterable`);
600 delete this.requests
[messageId
];
601 rejectCallback(new OCPPError(commandName
, commandPayload
.toString(), errorDetails
));
605 errMsg
= `${this.logPrefix()} Wrong message type ${messageType}`;
606 logger
.error(errMsg
);
607 throw new Error(errMsg
);
611 logger
.error('%s Incoming message %j processing error %j on request content type %j', this.logPrefix(), messageEvent
, error
, this.requests
[messageId
]);
613 messageType
!== MessageType
.CALL_ERROR_MESSAGE
&& await this.ocppRequestService
.sendError(messageId
, error
, commandName
);
617 private onPing(): void {
618 logger
.debug(this.logPrefix() + ' Has received a WS ping (rfc6455) from the server');
621 private onPong(): void {
622 logger
.debug(this.logPrefix() + ' Has received a WS pong (rfc6455) from the server');
625 private async onError(errorEvent
: any): Promise
<void> {
626 logger
.error(this.logPrefix() + ' Socket error: %j', errorEvent
);
627 // switch (errorEvent.code) {
628 // case 'ECONNREFUSED':
629 // await this._reconnect(errorEvent);
634 private getTemplateChargingStationConfiguration(): ChargingStationConfiguration
{
635 return this.stationInfo
.Configuration
? this.stationInfo
.Configuration
: {} as ChargingStationConfiguration
;
638 private getAuthorizationFile(): string | undefined {
639 return this.stationInfo
.authorizationFile
&& path
.join(path
.resolve(__dirname
, '../'), 'assets', path
.basename(this.stationInfo
.authorizationFile
));
642 private getAuthorizedTags(): string[] {
643 let authorizedTags
: string[] = [];
644 const authorizationFile
= this.getAuthorizationFile();
645 if (authorizationFile
) {
647 // Load authorization file
648 const fileDescriptor
= fs
.openSync(authorizationFile
, 'r');
649 authorizedTags
= JSON
.parse(fs
.readFileSync(fileDescriptor
, 'utf8')) as string[];
650 fs
.closeSync(fileDescriptor
);
652 FileUtils
.handleFileException(this.logPrefix(), 'Authorization', authorizationFile
, error
);
655 logger
.info(this.logPrefix() + ' No authorization file given in template file ' + this.stationTemplateFile
);
657 return authorizedTags
;
660 private getUseConnectorId0(): boolean | undefined {
661 return !Utils
.isUndefined(this.stationInfo
.useConnectorId0
) ? this.stationInfo
.useConnectorId0
: true;
664 private getNumberOfRunningTransactions(): number {
666 for (const connector
in this.connectors
) {
667 if (Utils
.convertToInt(connector
) > 0 && this.getConnector(Utils
.convertToInt(connector
)).transactionStarted
) {
675 private getConnectionTimeout(): number | undefined {
676 if (!Utils
.isUndefined(this.stationInfo
.connectionTimeout
)) {
677 return this.stationInfo
.connectionTimeout
;
679 if (!Utils
.isUndefined(Configuration
.getConnectionTimeout())) {
680 return Configuration
.getConnectionTimeout();
685 // -1 for unlimited, 0 for disabling
686 private getAutoReconnectMaxRetries(): number | undefined {
687 if (!Utils
.isUndefined(this.stationInfo
.autoReconnectMaxRetries
)) {
688 return this.stationInfo
.autoReconnectMaxRetries
;
690 if (!Utils
.isUndefined(Configuration
.getAutoReconnectMaxRetries())) {
691 return Configuration
.getAutoReconnectMaxRetries();
697 private getRegistrationMaxRetries(): number | undefined {
698 if (!Utils
.isUndefined(this.stationInfo
.registrationMaxRetries
)) {
699 return this.stationInfo
.registrationMaxRetries
;
704 private getPowerDivider(): number {
705 let powerDivider
= this.getNumberOfConnectors();
706 if (this.stationInfo
.powerSharedByConnectors
) {
707 powerDivider
= this.getNumberOfRunningTransactions();
712 private getTemplateMaxNumberOfConnectors(): number {
713 return Object.keys(this.stationInfo
.Connectors
).length
;
716 private getMaxNumberOfConnectors(): number {
717 let maxConnectors
= 0;
718 if (!Utils
.isEmptyArray(this.stationInfo
.numberOfConnectors
)) {
719 const numberOfConnectors
= this.stationInfo
.numberOfConnectors
as number[];
720 // Distribute evenly the number of connectors
721 maxConnectors
= numberOfConnectors
[(this.index
- 1) % numberOfConnectors
.length
];
722 } else if (!Utils
.isUndefined(this.stationInfo
.numberOfConnectors
)) {
723 maxConnectors
= this.stationInfo
.numberOfConnectors
as number;
725 maxConnectors
= this.stationInfo
.Connectors
[0] ? this.getTemplateMaxNumberOfConnectors() - 1 : this.getTemplateMaxNumberOfConnectors();
727 return maxConnectors
;
730 private getNumberOfConnectors(): number {
731 return this.connectors
[0] ? Object.keys(this.connectors
).length
- 1 : Object.keys(this.connectors
).length
;
734 private async startMessageSequence(): Promise
<void> {
735 // Start WebSocket ping
736 this.startWebSocketPing();
738 this.startHeartbeat();
739 // Initialize connectors status
740 for (const connector
in this.connectors
) {
741 if (Utils
.convertToInt(connector
) === 0) {
743 } else if (!this.hasStopped
&& !this.getConnector(Utils
.convertToInt(connector
))?.status && this.getConnector(Utils
.convertToInt(connector
))?.bootStatus
) {
744 // Send status in template at startup
745 await this.ocppRequestService
.sendStatusNotification(Utils
.convertToInt(connector
), this.getConnector(Utils
.convertToInt(connector
)).bootStatus
);
746 this.getConnector(Utils
.convertToInt(connector
)).status = this.getConnector(Utils
.convertToInt(connector
)).bootStatus
;
747 } else if (this.hasStopped
&& this.getConnector(Utils
.convertToInt(connector
))?.bootStatus
) {
748 // Send status in template after reset
749 await this.ocppRequestService
.sendStatusNotification(Utils
.convertToInt(connector
), this.getConnector(Utils
.convertToInt(connector
)).bootStatus
);
750 this.getConnector(Utils
.convertToInt(connector
)).status = this.getConnector(Utils
.convertToInt(connector
)).bootStatus
;
751 } else if (!this.hasStopped
&& this.getConnector(Utils
.convertToInt(connector
))?.status) {
752 // Send previous status at template reload
753 await this.ocppRequestService
.sendStatusNotification(Utils
.convertToInt(connector
), this.getConnector(Utils
.convertToInt(connector
)).status);
755 // Send default status
756 await this.ocppRequestService
.sendStatusNotification(Utils
.convertToInt(connector
), ChargePointStatus
.AVAILABLE
);
757 this.getConnector(Utils
.convertToInt(connector
)).status = ChargePointStatus
.AVAILABLE
;
761 this.startAutomaticTransactionGenerator();
762 if (this.getEnableStatistics()) {
763 this.performanceStatistics
.start();
767 private startAutomaticTransactionGenerator() {
768 if (this.stationInfo
.AutomaticTransactionGenerator
.enable
) {
769 if (!this.automaticTransactionGeneration
) {
770 this.automaticTransactionGeneration
= new AutomaticTransactionGenerator(this);
772 if (this.automaticTransactionGeneration
.timeToStop
) {
773 // The ATG might sleep
774 void this.automaticTransactionGeneration
.start();
779 private async stopMessageSequence(reason
: StopTransactionReason
= StopTransactionReason
.NONE
): Promise
<void> {
780 // Stop WebSocket ping
781 this.stopWebSocketPing();
783 this.stopHeartbeat();
785 if (this.stationInfo
.AutomaticTransactionGenerator
.enable
&&
786 this.automaticTransactionGeneration
&&
787 !this.automaticTransactionGeneration
.timeToStop
) {
788 await this.automaticTransactionGeneration
.stop(reason
);
790 for (const connector
in this.connectors
) {
791 if (Utils
.convertToInt(connector
) > 0 && this.getConnector(Utils
.convertToInt(connector
)).transactionStarted
) {
792 const transactionId
= this.getConnector(Utils
.convertToInt(connector
)).transactionId
;
793 await this.ocppRequestService
.sendStopTransaction(transactionId
, this.getEnergyActiveImportRegisterByTransactionId(transactionId
),
794 this.getTransactionIdTag(transactionId
), reason
);
800 private startWebSocketPing(): void {
801 const webSocketPingInterval
: number = this.getConfigurationKey(StandardParametersKey
.WebSocketPingInterval
)
802 ? Utils
.convertToInt(this.getConfigurationKey(StandardParametersKey
.WebSocketPingInterval
).value
)
804 if (webSocketPingInterval
> 0 && !this.webSocketPingSetInterval
) {
805 this.webSocketPingSetInterval
= setInterval(() => {
806 if (this.isWebSocketOpen()) {
807 this.wsConnection
.ping((): void => { });
809 }, webSocketPingInterval
* 1000);
810 logger
.info(this.logPrefix() + ' WebSocket ping started every ' + Utils
.secondsToHHMMSS(webSocketPingInterval
));
811 } else if (this.webSocketPingSetInterval
) {
812 logger
.info(this.logPrefix() + ' WebSocket ping every ' + Utils
.secondsToHHMMSS(webSocketPingInterval
) + ' already started');
814 logger
.error(`${this.logPrefix()} WebSocket ping interval set to ${webSocketPingInterval ? Utils.secondsToHHMMSS(webSocketPingInterval) : webSocketPingInterval}, not starting the WebSocket ping`);
818 private stopWebSocketPing(): void {
819 if (this.webSocketPingSetInterval
) {
820 clearInterval(this.webSocketPingSetInterval
);
824 private getSupervisionURL(): string {
825 const supervisionUrls
= Utils
.cloneObject
<string | string[]>(this.stationInfo
.supervisionURL
? this.stationInfo
.supervisionURL
: Configuration
.getSupervisionURLs());
827 if (!Utils
.isEmptyArray(supervisionUrls
)) {
828 if (Configuration
.getDistributeStationsToTenantsEqually()) {
829 indexUrl
= this.index
% supervisionUrls
.length
;
832 indexUrl
= Math.floor(Math.random() * supervisionUrls
.length
);
834 return supervisionUrls
[indexUrl
];
836 return supervisionUrls
as string;
839 private getHeartbeatInterval(): number | undefined {
840 const HeartbeatInterval
= this.getConfigurationKey(StandardParametersKey
.HeartbeatInterval
);
841 if (HeartbeatInterval
) {
842 return Utils
.convertToInt(HeartbeatInterval
.value
) * 1000;
844 const HeartBeatInterval
= this.getConfigurationKey(StandardParametersKey
.HeartBeatInterval
);
845 if (HeartBeatInterval
) {
846 return Utils
.convertToInt(HeartBeatInterval
.value
) * 1000;
850 private stopHeartbeat(): void {
851 if (this.heartbeatSetInterval
) {
852 clearInterval(this.heartbeatSetInterval
);
856 private openWSConnection(options
?: WebSocket
.ClientOptions
, forceCloseOpened
= false): void {
857 options
?? {} as WebSocket
.ClientOptions
;
858 options
?.handshakeTimeout
?? this.getConnectionTimeout() * 1000;
859 if (this.isWebSocketOpen() && forceCloseOpened
) {
860 this.wsConnection
.close();
863 switch (this.getOCPPVersion()) {
864 case OCPPVersion
.VERSION_16
:
865 protocol
= 'ocpp' + OCPPVersion
.VERSION_16
;
868 this.handleUnsupportedVersion(this.getOCPPVersion());
871 this.wsConnection
= new WebSocket(this.wsConnectionUrl
, protocol
, options
);
872 logger
.info(this.logPrefix() + ' Will communicate through URL ' + this.supervisionUrl
);
875 private stopMeterValues(connectorId
: number) {
876 if (this.getConnector(connectorId
)?.transactionSetInterval
) {
877 clearInterval(this.getConnector(connectorId
).transactionSetInterval
);
881 private startAuthorizationFileMonitoring(): void {
882 const authorizationFile
= this.getAuthorizationFile();
883 if (authorizationFile
) {
885 fs
.watch(authorizationFile
).on('change', (e
) => {
887 logger
.debug(this.logPrefix() + ' Authorization file ' + authorizationFile
+ ' have changed, reload');
888 // Initialize authorizedTags
889 this.authorizedTags
= this.getAuthorizedTags();
891 logger
.error(this.logPrefix() + ' Authorization file monitoring error: %j', error
);
895 FileUtils
.handleFileException(this.logPrefix(), 'Authorization', authorizationFile
, error
);
898 logger
.info(this.logPrefix() + ' No authorization file given in template file ' + this.stationTemplateFile
+ '. Not monitoring changes');
902 private startStationTemplateFileMonitoring(): void {
904 // eslint-disable-next-line @typescript-eslint/no-misused-promises
905 fs
.watch(this.stationTemplateFile
).on('change', async (e
): Promise
<void> => {
907 logger
.debug(this.logPrefix() + ' Template file ' + this.stationTemplateFile
+ ' have changed, reload');
911 if (!this.stationInfo
.AutomaticTransactionGenerator
.enable
&&
912 this.automaticTransactionGeneration
) {
913 await this.automaticTransactionGeneration
.stop();
916 this.startAutomaticTransactionGenerator();
917 // FIXME?: restart heartbeat and WebSocket ping when their interval values have changed
919 logger
.error(this.logPrefix() + ' Charging station template file monitoring error: %j', error
);
923 FileUtils
.handleFileException(this.logPrefix(), 'Template', this.stationTemplateFile
, error
);
927 private getReconnectExponentialDelay(): boolean | undefined {
928 return !Utils
.isUndefined(this.stationInfo
.reconnectExponentialDelay
) ? this.stationInfo
.reconnectExponentialDelay
: false;
931 private async reconnect(error
: any): Promise
<void> {
933 this.stopHeartbeat();
934 // Stop the ATG if needed
935 if (this.stationInfo
.AutomaticTransactionGenerator
.enable
&&
936 this.stationInfo
.AutomaticTransactionGenerator
.stopOnConnectionFailure
&&
937 this.automaticTransactionGeneration
&&
938 !this.automaticTransactionGeneration
.timeToStop
) {
939 await this.automaticTransactionGeneration
.stop();
941 if (this.autoReconnectRetryCount
< this.getAutoReconnectMaxRetries() || this.getAutoReconnectMaxRetries() === -1) {
942 this.autoReconnectRetryCount
++;
943 const reconnectDelay
= (this.getReconnectExponentialDelay() ? Utils
.exponentialDelay(this.autoReconnectRetryCount
) : this.getConnectionTimeout() * 1000);
944 logger
.error(`${this.logPrefix()} Socket: connection retry in ${Utils.roundTo(reconnectDelay, 2)}ms, timeout ${reconnectDelay - 100}ms`);
945 await Utils
.sleep(reconnectDelay
);
946 logger
.error(this.logPrefix() + ' Socket: reconnecting try #' + this.autoReconnectRetryCount
.toString());
947 this.openWSConnection({ handshakeTimeout
: reconnectDelay
- 100 });
948 this.hasSocketRestarted
= true;
949 } else if (this.getAutoReconnectMaxRetries() !== -1) {
950 logger
.error(`${this.logPrefix()} Socket reconnect failure: max retries reached (${this.autoReconnectRetryCount}) or retry disabled (${this.getAutoReconnectMaxRetries()})`);
954 private initTransactionAttributesOnConnector(connectorId
: number): void {
955 this.getConnector(connectorId
).transactionStarted
= false;
956 this.getConnector(connectorId
).energyActiveImportRegisterValue
= 0;
957 this.getConnector(connectorId
).transactionEnergyActiveImportRegisterValue
= 0;