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 { ConnectorPhaseRotation
, StandardParametersKey
, SupportedFeatureProfiles
} from
'../types/ocpp/Configuration';
5 import Connectors
, { Connector
} from
'../types/Connectors';
6 import { PerformanceObserver
, performance
} from
'perf_hooks';
7 import Requests
, { AvailabilityType
, BootNotificationRequest
, IncomingRequest
, IncomingRequestCommand
} from
'../types/ocpp/Requests';
8 import WebSocket
, { MessageEvent
} from
'ws';
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 Configuration from
'../utils/Configuration';
15 import Constants from
'../utils/Constants';
16 import FileUtils from
'../utils/FileUtils';
17 import { MessageType
} from
'../types/ocpp/MessageType';
18 import { MeterValueMeasurand
} from
'../types/ocpp/MeterValues';
19 import OCPP16IncomingRequestService from
'./ocpp/1.6/OCCP16IncomingRequestService';
20 import OCPP16RequestService from
'./ocpp/1.6/OCPP16RequestService';
21 import OCPP16ResponseService from
'./ocpp/1.6/OCPP16ResponseService';
22 import OCPPError from
'./OcppError';
23 import OCPPIncomingRequestService from
'./ocpp/OCPPIncomingRequestService';
24 import OCPPRequestService from
'./ocpp/OCPPRequestService';
25 import { OCPPVersion
} from
'../types/ocpp/OCPPVersion';
26 import PerformanceStatistics from
'../utils/PerformanceStatistics';
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 getTransactionDataMeterValues(): boolean {
165 return this.stationInfo
.transactionDataMeterValues
?? false;
168 public getEnergyActiveImportRegisterByTransactionId(transactionId
: number): number | undefined {
169 if (this.getMeteringPerTransaction()) {
170 for (const connector
in this.connectors
) {
171 if (Utils
.convertToInt(connector
) > 0 && this.getConnector(Utils
.convertToInt(connector
)).transactionId
=== transactionId
) {
172 return this.getConnector(Utils
.convertToInt(connector
)).transactionEnergyActiveImportRegisterValue
;
176 for (const connector
in this.connectors
) {
177 if (Utils
.convertToInt(connector
) > 0 && this.getConnector(Utils
.convertToInt(connector
)).transactionId
=== transactionId
) {
178 return this.getConnector(Utils
.convertToInt(connector
)).energyActiveImportRegisterValue
;
183 public getEnergyActiveImportRegisterByConnectorId(connectorId
: number): number | undefined {
184 if (this.getMeteringPerTransaction()) {
185 return this.getConnector(connectorId
).transactionEnergyActiveImportRegisterValue
;
187 return this.getConnector(connectorId
).energyActiveImportRegisterValue
;
190 public getAuthorizeRemoteTxRequests(): boolean {
191 const authorizeRemoteTxRequests
= this.getConfigurationKey(StandardParametersKey
.AuthorizeRemoteTxRequests
);
192 return authorizeRemoteTxRequests
? Utils
.convertToBoolean(authorizeRemoteTxRequests
.value
) : false;
195 public getLocalAuthListEnabled(): boolean {
196 const localAuthListEnabled
= this.getConfigurationKey(StandardParametersKey
.LocalAuthListEnabled
);
197 return localAuthListEnabled
? Utils
.convertToBoolean(localAuthListEnabled
.value
) : false;
200 public restartWebSocketPing(): void {
201 // Stop WebSocket ping
202 this.stopWebSocketPing();
203 // Start WebSocket ping
204 this.startWebSocketPing();
207 public getAutomaticTransactionGeneratorRequireAuthorize(): boolean {
208 return this.stationInfo
.AutomaticTransactionGenerator
.requireAuthorize
?? true;
211 public startHeartbeat(): void {
212 if (this.getHeartbeatInterval() && this.getHeartbeatInterval() > 0 && !this.heartbeatSetInterval
) {
213 // eslint-disable-next-line @typescript-eslint/no-misused-promises
214 this.heartbeatSetInterval
= setInterval(async (): Promise
<void> => {
215 await this.ocppRequestService
.sendHeartbeat();
216 }, this.getHeartbeatInterval());
217 logger
.info(this.logPrefix() + ' Heartbeat started every ' + Utils
.milliSecondsToHHMMSS(this.getHeartbeatInterval()));
218 } else if (this.heartbeatSetInterval
) {
219 logger
.info(this.logPrefix() + ' Heartbeat already started every ' + Utils
.milliSecondsToHHMMSS(this.getHeartbeatInterval()));
221 logger
.error(`${this.logPrefix()} Heartbeat interval set to ${this.getHeartbeatInterval() ? Utils.milliSecondsToHHMMSS(this.getHeartbeatInterval()) : this.getHeartbeatInterval()}, not starting the heartbeat`);
225 public restartHeartbeat(): void {
227 this.stopHeartbeat();
229 this.startHeartbeat();
232 public startMeterValues(connectorId
: number, interval
: number): void {
233 if (connectorId
=== 0) {
234 logger
.error(`${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId.toString()}`);
237 if (!this.getConnector(connectorId
)) {
238 logger
.error(`${this.logPrefix()} Trying to start MeterValues on non existing connector Id ${connectorId.toString()}`);
241 if (!this.getConnector(connectorId
)?.transactionStarted
) {
242 logger
.error(`${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId} with no transaction started`);
244 } else if (this.getConnector(connectorId
)?.transactionStarted
&& !this.getConnector(connectorId
)?.transactionId
) {
245 logger
.error(`${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId} with no transaction id`);
249 // eslint-disable-next-line @typescript-eslint/no-misused-promises
250 this.getConnector(connectorId
).transactionSetInterval
= setInterval(async (): Promise
<void> => {
251 if (this.getEnableStatistics()) {
252 const sendMeterValues
= performance
.timerify(this.ocppRequestService
.sendMeterValues
);
253 this.performanceObserver
.observe({
254 entryTypes
: ['function'],
256 await sendMeterValues(connectorId
, this.getConnector(connectorId
).transactionId
, interval
, this.ocppRequestService
);
258 await this.ocppRequestService
.sendMeterValues(connectorId
, this.getConnector(connectorId
).transactionId
, interval
, this.ocppRequestService
);
262 logger
.error(`${this.logPrefix()} Charging station ${StandardParametersKey.MeterValueSampleInterval} configuration set to ${interval ? Utils.milliSecondsToHHMMSS(interval) : interval}, not sending MeterValues`);
266 public start(): void {
267 this.openWSConnection();
268 // Monitor authorization file
269 this.startAuthorizationFileMonitoring();
270 // Monitor station template file
271 this.startStationTemplateFileMonitoring();
272 // Handle Socket incoming messages
273 this.wsConnection
.on('message', this.onMessage
.bind(this));
274 // Handle Socket error
275 this.wsConnection
.on('error', this.onError
.bind(this));
276 // Handle Socket close
277 this.wsConnection
.on('close', this.onClose
.bind(this));
278 // Handle Socket opening connection
279 this.wsConnection
.on('open', this.onOpen
.bind(this));
280 // Handle Socket ping
281 this.wsConnection
.on('ping', this.onPing
.bind(this));
282 // Handle Socket pong
283 this.wsConnection
.on('pong', this.onPong
.bind(this));
286 public async stop(reason
: StopTransactionReason
= StopTransactionReason
.NONE
): Promise
<void> {
287 // Stop message sequence
288 await this.stopMessageSequence(reason
);
289 for (const connector
in this.connectors
) {
290 if (Utils
.convertToInt(connector
) > 0) {
291 await this.ocppRequestService
.sendStatusNotification(Utils
.convertToInt(connector
), ChargePointStatus
.UNAVAILABLE
);
292 this.getConnector(Utils
.convertToInt(connector
)).status = ChargePointStatus
.UNAVAILABLE
;
295 if (this.isWebSocketOpen()) {
296 this.wsConnection
.close();
298 this.bootNotificationResponse
= null;
299 this.hasStopped
= true;
302 public getConfigurationKey(key
: string | StandardParametersKey
, caseInsensitive
= false): ConfigurationKey
| undefined {
303 const configurationKey
: ConfigurationKey
| undefined = this.configuration
.configurationKey
.find((configElement
) => {
304 if (caseInsensitive
) {
305 return configElement
.key
.toLowerCase() === key
.toLowerCase();
307 return configElement
.key
=== key
;
309 return configurationKey
;
312 public addConfigurationKey(key
: string | StandardParametersKey
, value
: string, readonly = false, visible
= true, reboot
= false): void {
313 const keyFound
= this.getConfigurationKey(key
);
315 this.configuration
.configurationKey
.push({
323 logger
.error(`${this.logPrefix()} Trying to add an already existing configuration key: %j`, keyFound
);
327 public setConfigurationKeyValue(key
: string | StandardParametersKey
, value
: string): void {
328 const keyFound
= this.getConfigurationKey(key
);
330 const keyIndex
= this.configuration
.configurationKey
.indexOf(keyFound
);
331 this.configuration
.configurationKey
[keyIndex
].value
= value
;
333 logger
.error(`${this.logPrefix()} Trying to set a value on a non existing configuration key: %j`, { key
, value
});
337 public setChargingProfile(connectorId
: number, cp
: ChargingProfile
): boolean {
338 if (!Utils
.isEmptyArray(this.getConnector(connectorId
).chargingProfiles
)) {
339 this.getConnector(connectorId
).chargingProfiles
?.forEach((chargingProfile
: ChargingProfile
, index
: number) => {
340 if (chargingProfile
.chargingProfileId
=== cp
.chargingProfileId
341 || (chargingProfile
.stackLevel
=== cp
.stackLevel
&& chargingProfile
.chargingProfilePurpose
=== cp
.chargingProfilePurpose
)) {
342 this.getConnector(connectorId
).chargingProfiles
[index
] = cp
;
347 this.getConnector(connectorId
).chargingProfiles
?.push(cp
);
351 public resetTransactionOnConnector(connectorId
: number): void {
352 this.getConnector(connectorId
).transactionStarted
= false;
353 delete this.getConnector(connectorId
).transactionId
;
354 delete this.getConnector(connectorId
).idTag
;
355 this.getConnector(connectorId
).transactionEnergyActiveImportRegisterValue
= 0;
356 delete this.getConnector(connectorId
).transactionBeginMeterValue
;
357 this.stopMeterValues(connectorId
);
360 public addToMessageQueue(message
: string): void {
362 // Handle dups in message queue
363 for (const bufferedMessage
of this.messageQueue
) {
364 // Message already in the queue
365 if (message
=== bufferedMessage
) {
372 this.messageQueue
.push(message
);
376 private flushMessageQueue() {
377 if (!Utils
.isEmptyArray(this.messageQueue
)) {
378 this.messageQueue
.forEach((message
, index
) => {
379 this.messageQueue
.splice(index
, 1);
380 this.wsConnection
.send(message
);
385 private getChargingStationId(stationTemplate
: ChargingStationTemplate
): string {
386 // In case of multiple instances: add instance index to charging station id
387 let instanceIndex
= process
.env
.CF_INSTANCE_INDEX
? process
.env
.CF_INSTANCE_INDEX
: 0;
388 instanceIndex
= instanceIndex
> 0 ? instanceIndex
: '';
389 const idSuffix
= stationTemplate
.nameSuffix
? stationTemplate
.nameSuffix
: '';
390 return stationTemplate
.fixedName
? stationTemplate
.baseName
: stationTemplate
.baseName
+ '-' + instanceIndex
.toString() + ('000000000' + this.index
.toString()).substr(('000000000' + this.index
.toString()).length
- 4) + idSuffix
;
393 private buildStationInfo(): ChargingStationInfo
{
394 let stationTemplateFromFile
: ChargingStationTemplate
;
396 // Load template file
397 const fileDescriptor
= fs
.openSync(this.stationTemplateFile
, 'r');
398 stationTemplateFromFile
= JSON
.parse(fs
.readFileSync(fileDescriptor
, 'utf8')) as ChargingStationTemplate
;
399 fs
.closeSync(fileDescriptor
);
401 FileUtils
.handleFileException(this.logPrefix(), 'Template', this.stationTemplateFile
, error
);
403 const stationInfo
: ChargingStationInfo
= stationTemplateFromFile
?? {} as ChargingStationInfo
;
404 if (!Utils
.isEmptyArray(stationTemplateFromFile
.power
)) {
405 stationTemplateFromFile
.power
= stationTemplateFromFile
.power
as number[];
406 const powerArrayRandomIndex
= Math.floor(Math.random() * stationTemplateFromFile
.power
.length
);
407 stationInfo
.maxPower
= stationTemplateFromFile
.powerUnit
=== PowerUnits
.KILO_WATT
408 ? stationTemplateFromFile
.power
[powerArrayRandomIndex
] * 1000
409 : stationTemplateFromFile
.power
[powerArrayRandomIndex
];
411 stationTemplateFromFile
.power
= stationTemplateFromFile
.power
as number;
412 stationInfo
.maxPower
= stationTemplateFromFile
.powerUnit
=== PowerUnits
.KILO_WATT
413 ? stationTemplateFromFile
.power
* 1000
414 : stationTemplateFromFile
.power
;
416 delete stationInfo
.power
;
417 delete stationInfo
.powerUnit
;
418 stationInfo
.chargingStationId
= this.getChargingStationId(stationTemplateFromFile
);
419 stationInfo
.resetTime
= stationTemplateFromFile
.resetTime
? stationTemplateFromFile
.resetTime
* 1000 : Constants
.CHARGING_STATION_DEFAULT_RESET_TIME
;
423 private getOCPPVersion(): OCPPVersion
{
424 return this.stationInfo
.ocppVersion
? this.stationInfo
.ocppVersion
: OCPPVersion
.VERSION_16
;
427 private handleUnsupportedVersion(version
: OCPPVersion
) {
428 const errMsg
= `${this.logPrefix()} Unsupported protocol version '${version}' configured in template file ${this.stationTemplateFile}`;
429 logger
.error(errMsg
);
430 throw new Error(errMsg
);
433 private initialize(): void {
434 this.stationInfo
= this.buildStationInfo();
435 this.bootNotificationRequest
= {
436 chargePointModel
: this.stationInfo
.chargePointModel
,
437 chargePointVendor
: this.stationInfo
.chargePointVendor
,
438 ...!Utils
.isUndefined(this.stationInfo
.chargeBoxSerialNumberPrefix
) && { chargeBoxSerialNumber
: this.stationInfo
.chargeBoxSerialNumberPrefix
},
439 ...!Utils
.isUndefined(this.stationInfo
.firmwareVersion
) && { firmwareVersion
: this.stationInfo
.firmwareVersion
},
441 this.configuration
= this.getTemplateChargingStationConfiguration();
442 this.supervisionUrl
= this.getSupervisionURL();
443 this.wsConnectionUrl
= this.supervisionUrl
+ '/' + this.stationInfo
.chargingStationId
;
444 // Build connectors if needed
445 const maxConnectors
= this.getMaxNumberOfConnectors();
446 if (maxConnectors
<= 0) {
447 logger
.warn(`${this.logPrefix()} Charging station template ${this.stationTemplateFile} with ${maxConnectors} connectors`);
449 const templateMaxConnectors
= this.getTemplateMaxNumberOfConnectors();
450 if (templateMaxConnectors
<= 0) {
451 logger
.warn(`${this.logPrefix()} Charging station template ${this.stationTemplateFile} with no connector configuration`);
453 if (!this.stationInfo
.Connectors
[0]) {
454 logger
.warn(`${this.logPrefix()} Charging station template ${this.stationTemplateFile} with no connector Id 0 configuration`);
457 if (maxConnectors
> (this.stationInfo
.Connectors
[0] ? templateMaxConnectors
- 1 : templateMaxConnectors
) && !this.stationInfo
.randomConnectors
) {
458 logger
.warn(`${this.logPrefix()} Number of connectors exceeds the number of connector configurations in template ${this.stationTemplateFile}, forcing random connector configurations affectation`);
459 this.stationInfo
.randomConnectors
= true;
461 const connectorsConfigHash
= crypto
.createHash('sha256').update(JSON
.stringify(this.stationInfo
.Connectors
) + maxConnectors
.toString()).digest('hex');
462 // FIXME: Handle shrinking the number of connectors
463 if (!this.connectors
|| (this.connectors
&& this.connectorsConfigurationHash
!== connectorsConfigHash
)) {
464 this.connectorsConfigurationHash
= connectorsConfigHash
;
465 // Add connector Id 0
466 let lastConnector
= '0';
467 for (lastConnector
in this.stationInfo
.Connectors
) {
468 if (Utils
.convertToInt(lastConnector
) === 0 && this.getUseConnectorId0() && this.stationInfo
.Connectors
[lastConnector
]) {
469 this.connectors
[lastConnector
] = Utils
.cloneObject
<Connector
>(this.stationInfo
.Connectors
[lastConnector
]);
470 this.connectors
[lastConnector
].availability
= AvailabilityType
.OPERATIVE
;
471 if (Utils
.isUndefined(this.connectors
[lastConnector
]?.chargingProfiles
)) {
472 this.connectors
[lastConnector
].chargingProfiles
= [];
476 // Generate all connectors
477 if ((this.stationInfo
.Connectors
[0] ? templateMaxConnectors
- 1 : templateMaxConnectors
) > 0) {
478 for (let index
= 1; index
<= maxConnectors
; index
++) {
479 const randConnectorID
= this.stationInfo
.randomConnectors
? Utils
.getRandomInt(Utils
.convertToInt(lastConnector
), 1) : index
;
480 this.connectors
[index
] = Utils
.cloneObject
<Connector
>(this.stationInfo
.Connectors
[randConnectorID
]);
481 this.connectors
[index
].availability
= AvailabilityType
.OPERATIVE
;
482 if (Utils
.isUndefined(this.connectors
[lastConnector
]?.chargingProfiles
)) {
483 this.connectors
[index
].chargingProfiles
= [];
488 // Avoid duplication of connectors related information
489 delete this.stationInfo
.Connectors
;
490 // Initialize transaction attributes on connectors
491 for (const connector
in this.connectors
) {
492 if (Utils
.convertToInt(connector
) > 0 && !this.getConnector(Utils
.convertToInt(connector
)).transactionStarted
) {
493 this.initTransactionAttributesOnConnector(Utils
.convertToInt(connector
));
496 switch (this.getOCPPVersion()) {
497 case OCPPVersion
.VERSION_16
:
498 this.ocppIncomingRequestService
= new OCPP16IncomingRequestService(this);
499 this.ocppRequestService
= new OCPP16RequestService(this, new OCPP16ResponseService(this));
502 this.handleUnsupportedVersion(this.getOCPPVersion());
506 this.addConfigurationKey(StandardParametersKey
.NumberOfConnectors
, this.getNumberOfConnectors().toString(), true);
507 if (!this.getConfigurationKey(StandardParametersKey
.MeterValuesSampledData
)) {
508 this.addConfigurationKey(StandardParametersKey
.MeterValuesSampledData
, MeterValueMeasurand
.ENERGY_ACTIVE_IMPORT_REGISTER
);
510 if (!this.getConfigurationKey(StandardParametersKey
.SupportedFeatureProfiles
)) {
511 this.addConfigurationKey(StandardParametersKey
.SupportedFeatureProfiles
, SupportedFeatureProfiles
.Core
);
513 if (!this.getConfigurationKey(StandardParametersKey
.ConnectorPhaseRotation
)) {
514 const connectorPhaseRotation
= [];
515 for (const connector
in this.connectors
) {
517 if (Utils
.convertToInt(connector
) === 0 && this.getNumberOfPhases() === 0) {
518 connectorPhaseRotation
.push(`${connector}.${ConnectorPhaseRotation.RST}`);
519 } else if (Utils
.convertToInt(connector
) > 0 && this.getNumberOfPhases() === 0) {
520 connectorPhaseRotation
.push(`${connector}.${ConnectorPhaseRotation.NotApplicable}`);
522 } else if (Utils
.convertToInt(connector
) > 0 && this.getNumberOfPhases() === 1) {
523 connectorPhaseRotation
.push(`${connector}.${ConnectorPhaseRotation.NotApplicable}`);
524 } else if (Utils
.convertToInt(connector
) > 0 && this.getNumberOfPhases() === 3) {
525 connectorPhaseRotation
.push(`${connector}.${ConnectorPhaseRotation.RST}`);
528 this.addConfigurationKey(StandardParametersKey
.ConnectorPhaseRotation
, connectorPhaseRotation
.toString());
530 this.stationInfo
.powerDivider
= this.getPowerDivider();
531 if (this.getEnableStatistics()) {
532 this.performanceStatistics
= new PerformanceStatistics(this.stationInfo
.chargingStationId
);
533 this.performanceObserver
= new PerformanceObserver((list
) => {
534 const entry
= list
.getEntries()[0];
535 this.performanceStatistics
.logPerformance(entry
, Constants
.ENTITY_CHARGING_STATION
);
536 this.performanceObserver
.disconnect();
541 private async onOpen(): Promise
<void> {
542 logger
.info(`${this.logPrefix()} Is connected to server through ${this.wsConnectionUrl}`);
543 if (!this.isRegistered()) {
544 // Send BootNotification
545 let registrationRetryCount
= 0;
547 this.bootNotificationResponse
= await this.ocppRequestService
.sendBootNotification(this.bootNotificationRequest
.chargePointModel
,
548 this.bootNotificationRequest
.chargePointVendor
, this.bootNotificationRequest
.chargeBoxSerialNumber
, this.bootNotificationRequest
.firmwareVersion
);
549 if (!this.isRegistered()) {
550 registrationRetryCount
++;
551 await Utils
.sleep(this.bootNotificationResponse
?.interval
? this.bootNotificationResponse
.interval
* 1000 : Constants
.OCPP_DEFAULT_BOOT_NOTIFICATION_INTERVAL
);
553 } while (!this.isRegistered() && (registrationRetryCount
<= this.getRegistrationMaxRetries() || this.getRegistrationMaxRetries() === -1));
555 if (this.isRegistered()) {
556 await this.startMessageSequence();
557 this.hasStopped
&& (this.hasStopped
= false);
558 if (this.hasSocketRestarted
&& this.isWebSocketOpen()) {
559 this.flushMessageQueue();
562 logger
.error(`${this.logPrefix()} Registration failure: max retries reached (${this.getRegistrationMaxRetries()}) or retry disabled (${this.getRegistrationMaxRetries()})`);
564 this.autoReconnectRetryCount
= 0;
565 this.hasSocketRestarted
= false;
568 private async onClose(closeEvent
: any): Promise
<void> {
569 switch (closeEvent
) {
570 case WebSocketCloseEventStatusCode
.CLOSE_NORMAL
: // Normal close
571 case WebSocketCloseEventStatusCode
.CLOSE_NO_STATUS
:
572 logger
.info(`${this.logPrefix()} Socket normally closed with status '${Utils.getWebSocketCloseEventStatusString(closeEvent)}'`);
573 this.autoReconnectRetryCount
= 0;
575 default: // Abnormal close
576 logger
.error(`${this.logPrefix()} Socket abnormally closed with status '${Utils.getWebSocketCloseEventStatusString(closeEvent)}'`);
577 await this.reconnect(closeEvent
);
582 private async onMessage(messageEvent
: MessageEvent
): Promise
<void> {
583 let [messageType
, messageId
, commandName
, commandPayload
, errorDetails
]: IncomingRequest
= [0, '', '' as IncomingRequestCommand
, {}, {}];
584 let responseCallback
: (payload
: Record
<string, unknown
> | string, requestPayload
: Record
<string, unknown
>) => void;
585 let rejectCallback
: (error
: OCPPError
) => void;
586 let requestPayload
: Record
<string, unknown
>;
590 [messageType
, messageId
, commandName
, commandPayload
, errorDetails
] = JSON
.parse(messageEvent
.toString()) as IncomingRequest
;
591 // Check the Type of message
592 switch (messageType
) {
594 case MessageType
.CALL_MESSAGE
:
595 if (this.getEnableStatistics()) {
596 this.performanceStatistics
.addMessage(commandName
, messageType
);
599 await this.ocppIncomingRequestService
.handleRequest(messageId
, commandName
, commandPayload
);
602 case MessageType
.CALL_RESULT_MESSAGE
:
604 if (Utils
.isIterable(this.requests
[messageId
])) {
605 [responseCallback
, , requestPayload
] = this.requests
[messageId
];
607 throw new Error(`Response request for message id ${messageId} is not iterable`);
609 if (!responseCallback
) {
611 throw new Error(`Response request for unknown message id ${messageId}`);
613 delete this.requests
[messageId
];
614 responseCallback(commandName
, requestPayload
);
617 case MessageType
.CALL_ERROR_MESSAGE
:
618 if (!this.requests
[messageId
]) {
620 throw new Error(`Error request for unknown message id ${messageId}`);
622 if (Utils
.isIterable(this.requests
[messageId
])) {
623 [, rejectCallback
] = this.requests
[messageId
];
625 throw new Error(`Error request for message id ${messageId} is not iterable`);
627 delete this.requests
[messageId
];
628 rejectCallback(new OCPPError(commandName
, commandPayload
.toString(), errorDetails
));
632 errMsg
= `${this.logPrefix()} Wrong message type ${messageType}`;
633 logger
.error(errMsg
);
634 throw new Error(errMsg
);
638 logger
.error('%s Incoming message %j processing error %j on request content type %j', this.logPrefix(), messageEvent
, error
, this.requests
[messageId
]);
640 messageType
!== MessageType
.CALL_ERROR_MESSAGE
&& await this.ocppRequestService
.sendError(messageId
, error
, commandName
);
644 private onPing(): void {
645 logger
.debug(this.logPrefix() + ' Has received a WS ping (rfc6455) from the server');
648 private onPong(): void {
649 logger
.debug(this.logPrefix() + ' Has received a WS pong (rfc6455) from the server');
652 private async onError(errorEvent
: any): Promise
<void> {
653 logger
.error(this.logPrefix() + ' Socket error: %j', errorEvent
);
654 // switch (errorEvent.code) {
655 // case 'ECONNREFUSED':
656 // await this._reconnect(errorEvent);
661 private getTemplateChargingStationConfiguration(): ChargingStationConfiguration
{
662 return this.stationInfo
.Configuration
? this.stationInfo
.Configuration
: {} as ChargingStationConfiguration
;
665 private getAuthorizationFile(): string | undefined {
666 return this.stationInfo
.authorizationFile
&& path
.join(path
.resolve(__dirname
, '../'), 'assets', path
.basename(this.stationInfo
.authorizationFile
));
669 private getAuthorizedTags(): string[] {
670 let authorizedTags
: string[] = [];
671 const authorizationFile
= this.getAuthorizationFile();
672 if (authorizationFile
) {
674 // Load authorization file
675 const fileDescriptor
= fs
.openSync(authorizationFile
, 'r');
676 authorizedTags
= JSON
.parse(fs
.readFileSync(fileDescriptor
, 'utf8')) as string[];
677 fs
.closeSync(fileDescriptor
);
679 FileUtils
.handleFileException(this.logPrefix(), 'Authorization', authorizationFile
, error
);
682 logger
.info(this.logPrefix() + ' No authorization file given in template file ' + this.stationTemplateFile
);
684 return authorizedTags
;
687 private getUseConnectorId0(): boolean | undefined {
688 return !Utils
.isUndefined(this.stationInfo
.useConnectorId0
) ? this.stationInfo
.useConnectorId0
: true;
691 private getNumberOfRunningTransactions(): number {
693 for (const connector
in this.connectors
) {
694 if (Utils
.convertToInt(connector
) > 0 && this.getConnector(Utils
.convertToInt(connector
)).transactionStarted
) {
702 private getConnectionTimeout(): number | undefined {
703 if (!Utils
.isUndefined(this.stationInfo
.connectionTimeout
)) {
704 return this.stationInfo
.connectionTimeout
;
706 if (!Utils
.isUndefined(Configuration
.getConnectionTimeout())) {
707 return Configuration
.getConnectionTimeout();
712 // -1 for unlimited, 0 for disabling
713 private getAutoReconnectMaxRetries(): number | undefined {
714 if (!Utils
.isUndefined(this.stationInfo
.autoReconnectMaxRetries
)) {
715 return this.stationInfo
.autoReconnectMaxRetries
;
717 if (!Utils
.isUndefined(Configuration
.getAutoReconnectMaxRetries())) {
718 return Configuration
.getAutoReconnectMaxRetries();
724 private getRegistrationMaxRetries(): number | undefined {
725 if (!Utils
.isUndefined(this.stationInfo
.registrationMaxRetries
)) {
726 return this.stationInfo
.registrationMaxRetries
;
731 private getPowerDivider(): number {
732 let powerDivider
= this.getNumberOfConnectors();
733 if (this.stationInfo
.powerSharedByConnectors
) {
734 powerDivider
= this.getNumberOfRunningTransactions();
739 private getTemplateMaxNumberOfConnectors(): number {
740 return Object.keys(this.stationInfo
.Connectors
).length
;
743 private getMaxNumberOfConnectors(): number {
744 let maxConnectors
= 0;
745 if (!Utils
.isEmptyArray(this.stationInfo
.numberOfConnectors
)) {
746 const numberOfConnectors
= this.stationInfo
.numberOfConnectors
as number[];
747 // Distribute evenly the number of connectors
748 maxConnectors
= numberOfConnectors
[(this.index
- 1) % numberOfConnectors
.length
];
749 } else if (!Utils
.isUndefined(this.stationInfo
.numberOfConnectors
)) {
750 maxConnectors
= this.stationInfo
.numberOfConnectors
as number;
752 maxConnectors
= this.stationInfo
.Connectors
[0] ? this.getTemplateMaxNumberOfConnectors() - 1 : this.getTemplateMaxNumberOfConnectors();
754 return maxConnectors
;
757 private getNumberOfConnectors(): number {
758 return this.connectors
[0] ? Object.keys(this.connectors
).length
- 1 : Object.keys(this.connectors
).length
;
761 private async startMessageSequence(): Promise
<void> {
762 // Start WebSocket ping
763 this.startWebSocketPing();
765 this.startHeartbeat();
766 // Initialize connectors status
767 for (const connector
in this.connectors
) {
768 if (Utils
.convertToInt(connector
) === 0) {
770 } else if (!this.hasStopped
&& !this.getConnector(Utils
.convertToInt(connector
))?.status && this.getConnector(Utils
.convertToInt(connector
))?.bootStatus
) {
771 // Send status in template at startup
772 await this.ocppRequestService
.sendStatusNotification(Utils
.convertToInt(connector
), this.getConnector(Utils
.convertToInt(connector
)).bootStatus
);
773 this.getConnector(Utils
.convertToInt(connector
)).status = this.getConnector(Utils
.convertToInt(connector
)).bootStatus
;
774 } else if (this.hasStopped
&& this.getConnector(Utils
.convertToInt(connector
))?.bootStatus
) {
775 // Send status in template after reset
776 await this.ocppRequestService
.sendStatusNotification(Utils
.convertToInt(connector
), this.getConnector(Utils
.convertToInt(connector
)).bootStatus
);
777 this.getConnector(Utils
.convertToInt(connector
)).status = this.getConnector(Utils
.convertToInt(connector
)).bootStatus
;
778 } else if (!this.hasStopped
&& this.getConnector(Utils
.convertToInt(connector
))?.status) {
779 // Send previous status at template reload
780 await this.ocppRequestService
.sendStatusNotification(Utils
.convertToInt(connector
), this.getConnector(Utils
.convertToInt(connector
)).status);
782 // Send default status
783 await this.ocppRequestService
.sendStatusNotification(Utils
.convertToInt(connector
), ChargePointStatus
.AVAILABLE
);
784 this.getConnector(Utils
.convertToInt(connector
)).status = ChargePointStatus
.AVAILABLE
;
788 this.startAutomaticTransactionGenerator();
789 if (this.getEnableStatistics()) {
790 this.performanceStatistics
.start();
794 private startAutomaticTransactionGenerator() {
795 if (this.stationInfo
.AutomaticTransactionGenerator
.enable
) {
796 if (!this.automaticTransactionGeneration
) {
797 this.automaticTransactionGeneration
= new AutomaticTransactionGenerator(this);
799 if (this.automaticTransactionGeneration
.timeToStop
) {
800 // The ATG might sleep
801 void this.automaticTransactionGeneration
.start();
806 private async stopMessageSequence(reason
: StopTransactionReason
= StopTransactionReason
.NONE
): Promise
<void> {
807 // Stop WebSocket ping
808 this.stopWebSocketPing();
810 this.stopHeartbeat();
812 if (this.stationInfo
.AutomaticTransactionGenerator
.enable
&&
813 this.automaticTransactionGeneration
&&
814 !this.automaticTransactionGeneration
.timeToStop
) {
815 await this.automaticTransactionGeneration
.stop(reason
);
817 for (const connector
in this.connectors
) {
818 if (Utils
.convertToInt(connector
) > 0 && this.getConnector(Utils
.convertToInt(connector
)).transactionStarted
) {
819 const transactionId
= this.getConnector(Utils
.convertToInt(connector
)).transactionId
;
820 await this.ocppRequestService
.sendStopTransaction(transactionId
, this.getEnergyActiveImportRegisterByTransactionId(transactionId
),
821 this.getTransactionIdTag(transactionId
), reason
);
827 private startWebSocketPing(): void {
828 const webSocketPingInterval
: number = this.getConfigurationKey(StandardParametersKey
.WebSocketPingInterval
)
829 ? Utils
.convertToInt(this.getConfigurationKey(StandardParametersKey
.WebSocketPingInterval
).value
)
831 if (webSocketPingInterval
> 0 && !this.webSocketPingSetInterval
) {
832 this.webSocketPingSetInterval
= setInterval(() => {
833 if (this.isWebSocketOpen()) {
834 this.wsConnection
.ping((): void => { });
836 }, webSocketPingInterval
* 1000);
837 logger
.info(this.logPrefix() + ' WebSocket ping started every ' + Utils
.secondsToHHMMSS(webSocketPingInterval
));
838 } else if (this.webSocketPingSetInterval
) {
839 logger
.info(this.logPrefix() + ' WebSocket ping every ' + Utils
.secondsToHHMMSS(webSocketPingInterval
) + ' already started');
841 logger
.error(`${this.logPrefix()} WebSocket ping interval set to ${webSocketPingInterval ? Utils.secondsToHHMMSS(webSocketPingInterval) : webSocketPingInterval}, not starting the WebSocket ping`);
845 private stopWebSocketPing(): void {
846 if (this.webSocketPingSetInterval
) {
847 clearInterval(this.webSocketPingSetInterval
);
851 private getSupervisionURL(): string {
852 const supervisionUrls
= Utils
.cloneObject
<string | string[]>(this.stationInfo
.supervisionURL
? this.stationInfo
.supervisionURL
: Configuration
.getSupervisionURLs());
854 if (!Utils
.isEmptyArray(supervisionUrls
)) {
855 if (Configuration
.getDistributeStationsToTenantsEqually()) {
856 indexUrl
= this.index
% supervisionUrls
.length
;
859 indexUrl
= Math.floor(Math.random() * supervisionUrls
.length
);
861 return supervisionUrls
[indexUrl
];
863 return supervisionUrls
as string;
866 private getHeartbeatInterval(): number | undefined {
867 const HeartbeatInterval
= this.getConfigurationKey(StandardParametersKey
.HeartbeatInterval
);
868 if (HeartbeatInterval
) {
869 return Utils
.convertToInt(HeartbeatInterval
.value
) * 1000;
871 const HeartBeatInterval
= this.getConfigurationKey(StandardParametersKey
.HeartBeatInterval
);
872 if (HeartBeatInterval
) {
873 return Utils
.convertToInt(HeartBeatInterval
.value
) * 1000;
877 private stopHeartbeat(): void {
878 if (this.heartbeatSetInterval
) {
879 clearInterval(this.heartbeatSetInterval
);
883 private openWSConnection(options
?: WebSocket
.ClientOptions
, forceCloseOpened
= false): void {
884 options
?? {} as WebSocket
.ClientOptions
;
885 options
?.handshakeTimeout
?? this.getConnectionTimeout() * 1000;
886 if (this.isWebSocketOpen() && forceCloseOpened
) {
887 this.wsConnection
.close();
890 switch (this.getOCPPVersion()) {
891 case OCPPVersion
.VERSION_16
:
892 protocol
= 'ocpp' + OCPPVersion
.VERSION_16
;
895 this.handleUnsupportedVersion(this.getOCPPVersion());
898 this.wsConnection
= new WebSocket(this.wsConnectionUrl
, protocol
, options
);
899 logger
.info(this.logPrefix() + ' Will communicate through URL ' + this.supervisionUrl
);
902 private stopMeterValues(connectorId
: number) {
903 if (this.getConnector(connectorId
)?.transactionSetInterval
) {
904 clearInterval(this.getConnector(connectorId
).transactionSetInterval
);
908 private startAuthorizationFileMonitoring(): void {
909 const authorizationFile
= this.getAuthorizationFile();
910 if (authorizationFile
) {
912 fs
.watch(authorizationFile
).on('change', () => {
914 logger
.debug(this.logPrefix() + ' Authorization file ' + authorizationFile
+ ' have changed, reload');
915 // Initialize authorizedTags
916 this.authorizedTags
= this.getAuthorizedTags();
918 logger
.error(this.logPrefix() + ' Authorization file monitoring error: %j', error
);
922 FileUtils
.handleFileException(this.logPrefix(), 'Authorization', authorizationFile
, error
);
925 logger
.info(this.logPrefix() + ' No authorization file given in template file ' + this.stationTemplateFile
+ '. Not monitoring changes');
929 private startStationTemplateFileMonitoring(): void {
931 // eslint-disable-next-line @typescript-eslint/no-misused-promises
932 fs
.watch(this.stationTemplateFile
).on('change', async (): Promise
<void> => {
934 logger
.debug(this.logPrefix() + ' Template file ' + this.stationTemplateFile
+ ' have changed, reload');
938 if (!this.stationInfo
.AutomaticTransactionGenerator
.enable
&&
939 this.automaticTransactionGeneration
) {
940 await this.automaticTransactionGeneration
.stop();
943 this.startAutomaticTransactionGenerator();
944 // FIXME?: restart heartbeat and WebSocket ping when their interval values have changed
946 logger
.error(this.logPrefix() + ' Charging station template file monitoring error: %j', error
);
950 FileUtils
.handleFileException(this.logPrefix(), 'Template', this.stationTemplateFile
, error
);
954 private getReconnectExponentialDelay(): boolean | undefined {
955 return !Utils
.isUndefined(this.stationInfo
.reconnectExponentialDelay
) ? this.stationInfo
.reconnectExponentialDelay
: false;
958 private async reconnect(error
: any): Promise
<void> {
960 this.stopHeartbeat();
961 // Stop the ATG if needed
962 if (this.stationInfo
.AutomaticTransactionGenerator
.enable
&&
963 this.stationInfo
.AutomaticTransactionGenerator
.stopOnConnectionFailure
&&
964 this.automaticTransactionGeneration
&&
965 !this.automaticTransactionGeneration
.timeToStop
) {
966 await this.automaticTransactionGeneration
.stop();
968 if (this.autoReconnectRetryCount
< this.getAutoReconnectMaxRetries() || this.getAutoReconnectMaxRetries() === -1) {
969 this.autoReconnectRetryCount
++;
970 const reconnectDelay
= (this.getReconnectExponentialDelay() ? Utils
.exponentialDelay(this.autoReconnectRetryCount
) : this.getConnectionTimeout() * 1000);
971 logger
.error(`${this.logPrefix()} Socket: connection retry in ${Utils.roundTo(reconnectDelay, 2)}ms, timeout ${reconnectDelay - 100}ms`);
972 await Utils
.sleep(reconnectDelay
);
973 logger
.error(this.logPrefix() + ' Socket: reconnecting try #' + this.autoReconnectRetryCount
.toString());
974 this.openWSConnection({ handshakeTimeout
: reconnectDelay
- 100 });
975 this.hasSocketRestarted
= true;
976 } else if (this.getAutoReconnectMaxRetries() !== -1) {
977 logger
.error(`${this.logPrefix()} Socket reconnect failure: max retries reached (${this.autoReconnectRetryCount}) or retry disabled (${this.getAutoReconnectMaxRetries()})`);
981 private initTransactionAttributesOnConnector(connectorId
: number): void {
982 this.getConnector(connectorId
).transactionStarted
= false;
983 this.getConnector(connectorId
).energyActiveImportRegisterValue
= 0;
984 this.getConnector(connectorId
).transactionEnergyActiveImportRegisterValue
= 0;