Version 1.1.57
[e-mobility-charging-stations-simulator.git] / src / charging-station / ChargingStation.ts
1 // Partial Copyright Jerome Benoit. 2021. All Rights Reserved.
2
3 import { ACElectricUtils, DCElectricUtils } from '../utils/ElectricUtils';
4 import {
5 AvailabilityType,
6 BootNotificationRequest,
7 CachedRequest,
8 HeartbeatRequest,
9 IncomingRequest,
10 IncomingRequestCommand,
11 MeterValuesRequest,
12 RequestCommand,
13 StatusNotificationRequest,
14 } from '../types/ocpp/Requests';
15 import {
16 BootNotificationResponse,
17 HeartbeatResponse,
18 MeterValuesResponse,
19 RegistrationStatus,
20 StatusNotificationResponse,
21 } from '../types/ocpp/Responses';
22 import {
23 ChargingProfile,
24 ChargingRateUnitType,
25 ChargingSchedulePeriod,
26 } from '../types/ocpp/ChargingProfile';
27 import ChargingStationConfiguration, { Section } from '../types/ChargingStationConfiguration';
28 import ChargingStationOcppConfiguration, {
29 ConfigurationKey,
30 } from '../types/ChargingStationOcppConfiguration';
31 import ChargingStationTemplate, {
32 AmpereUnits,
33 CurrentType,
34 PowerUnits,
35 Voltage,
36 WsOptions,
37 } from '../types/ChargingStationTemplate';
38 import {
39 ConnectorPhaseRotation,
40 StandardParametersKey,
41 SupportedFeatureProfiles,
42 VendorDefaultParametersKey,
43 } from '../types/ocpp/Configuration';
44 import { MeterValue, MeterValueMeasurand, MeterValuePhase } from '../types/ocpp/MeterValues';
45 import {
46 StopTransactionReason,
47 StopTransactionRequest,
48 StopTransactionResponse,
49 } from '../types/ocpp/Transaction';
50 import { WSError, WebSocketCloseEventStatusCode } from '../types/WebSocket';
51 import WebSocket, { Data, OPEN, RawData } from 'ws';
52
53 import AutomaticTransactionGenerator from './AutomaticTransactionGenerator';
54 import { ChargePointErrorCode } from '../types/ocpp/ChargePointErrorCode';
55 import { ChargePointStatus } from '../types/ocpp/ChargePointStatus';
56 import ChargingStationInfo from '../types/ChargingStationInfo';
57 import { ChargingStationWorkerMessageEvents } from '../types/ChargingStationWorker';
58 import Configuration from '../utils/Configuration';
59 import { ConnectorStatus } from '../types/ConnectorStatus';
60 import Constants from '../utils/Constants';
61 import { ErrorType } from '../types/ocpp/ErrorType';
62 import { FileType } from '../types/FileType';
63 import FileUtils from '../utils/FileUtils';
64 import { JsonType } from '../types/JsonType';
65 import { MessageType } from '../types/ocpp/MessageType';
66 import OCPP16IncomingRequestService from './ocpp/1.6/OCPP16IncomingRequestService';
67 import OCPP16RequestService from './ocpp/1.6/OCPP16RequestService';
68 import OCPP16ResponseService from './ocpp/1.6/OCPP16ResponseService';
69 import { OCPP16ServiceUtils } from './ocpp/1.6/OCPP16ServiceUtils';
70 import OCPPError from '../exception/OCPPError';
71 import OCPPIncomingRequestService from './ocpp/OCPPIncomingRequestService';
72 import OCPPRequestService from './ocpp/OCPPRequestService';
73 import { OCPPVersion } from '../types/ocpp/OCPPVersion';
74 import PerformanceStatistics from '../performance/PerformanceStatistics';
75 import { SampledValueTemplate } from '../types/MeasurandPerPhaseSampledValueTemplates';
76 import { SupervisionUrlDistribution } from '../types/ConfigurationData';
77 import { URL } from 'url';
78 import Utils from '../utils/Utils';
79 import crypto from 'crypto';
80 import fs from 'fs';
81 import logger from '../utils/Logger';
82 import { parentPort } from 'worker_threads';
83 import path from 'path';
84
85 export default class ChargingStation {
86 public hashId!: string;
87 public readonly templateFile: string;
88 public authorizedTags: string[];
89 public stationInfo!: ChargingStationInfo;
90 public readonly connectors: Map<number, ConnectorStatus>;
91 public ocppConfiguration!: ChargingStationOcppConfiguration;
92 public wsConnection!: WebSocket;
93 public readonly requests: Map<string, CachedRequest>;
94 public performanceStatistics!: PerformanceStatistics;
95 public heartbeatSetInterval!: NodeJS.Timeout;
96 public ocppRequestService!: OCPPRequestService;
97 public bootNotificationResponse!: BootNotificationResponse | null;
98 private readonly index: number;
99 private configurationFile!: string;
100 private bootNotificationRequest!: BootNotificationRequest;
101 private connectorsConfigurationHash!: string;
102 private ocppIncomingRequestService!: OCPPIncomingRequestService;
103 private readonly messageBuffer: Set<string>;
104 private wsConfiguredConnectionUrl!: URL;
105 private wsConnectionRestarted: boolean;
106 private stopped: boolean;
107 private autoReconnectRetryCount: number;
108 private automaticTransactionGenerator!: AutomaticTransactionGenerator;
109 private webSocketPingSetInterval!: NodeJS.Timeout;
110
111 constructor(index: number, templateFile: string) {
112 this.index = index;
113 this.templateFile = templateFile;
114 this.stopped = false;
115 this.wsConnectionRestarted = false;
116 this.autoReconnectRetryCount = 0;
117 this.connectors = new Map<number, ConnectorStatus>();
118 this.requests = new Map<string, CachedRequest>();
119 this.messageBuffer = new Set<string>();
120 this.initialize();
121 this.authorizedTags = this.getAuthorizedTags();
122 }
123
124 private get wsConnectionUrl(): URL {
125 return this.getSupervisionUrlOcppConfiguration()
126 ? new URL(
127 this.getConfigurationKey(this.getSupervisionUrlOcppKey()).value +
128 '/' +
129 this.stationInfo.chargingStationId
130 )
131 : this.wsConfiguredConnectionUrl;
132 }
133
134 public logPrefix(): string {
135 return Utils.logPrefix(` ${this.stationInfo.chargingStationId} |`);
136 }
137
138 public getBootNotificationRequest(): BootNotificationRequest {
139 return this.bootNotificationRequest;
140 }
141
142 public getRandomIdTag(): string {
143 const index = Math.floor(Utils.secureRandom() * this.authorizedTags.length);
144 return this.authorizedTags[index];
145 }
146
147 public hasAuthorizedTags(): boolean {
148 return !Utils.isEmptyArray(this.authorizedTags);
149 }
150
151 public getEnableStatistics(): boolean | undefined {
152 return !Utils.isUndefined(this.stationInfo.enableStatistics)
153 ? this.stationInfo.enableStatistics
154 : true;
155 }
156
157 public getMayAuthorizeAtRemoteStart(): boolean | undefined {
158 return this.stationInfo.mayAuthorizeAtRemoteStart ?? true;
159 }
160
161 public getNumberOfPhases(): number | undefined {
162 switch (this.getCurrentOutType()) {
163 case CurrentType.AC:
164 return !Utils.isUndefined(this.stationInfo.numberOfPhases)
165 ? this.stationInfo.numberOfPhases
166 : 3;
167 case CurrentType.DC:
168 return 0;
169 }
170 }
171
172 public isWebSocketConnectionOpened(): boolean {
173 return this?.wsConnection?.readyState === OPEN;
174 }
175
176 public getRegistrationStatus(): RegistrationStatus {
177 return this?.bootNotificationResponse?.status;
178 }
179
180 public isInUnknownState(): boolean {
181 return Utils.isNullOrUndefined(this?.bootNotificationResponse?.status);
182 }
183
184 public isInPendingState(): boolean {
185 return this?.bootNotificationResponse?.status === RegistrationStatus.PENDING;
186 }
187
188 public isInAcceptedState(): boolean {
189 return this?.bootNotificationResponse?.status === RegistrationStatus.ACCEPTED;
190 }
191
192 public isInRejectedState(): boolean {
193 return this?.bootNotificationResponse?.status === RegistrationStatus.REJECTED;
194 }
195
196 public isRegistered(): boolean {
197 return !this.isInUnknownState() && (this.isInAcceptedState() || this.isInPendingState());
198 }
199
200 public isChargingStationAvailable(): boolean {
201 return this.getConnectorStatus(0).availability === AvailabilityType.OPERATIVE;
202 }
203
204 public isConnectorAvailable(id: number): boolean {
205 return id > 0 && this.getConnectorStatus(id).availability === AvailabilityType.OPERATIVE;
206 }
207
208 public getNumberOfConnectors(): number {
209 return this.connectors.get(0) ? this.connectors.size - 1 : this.connectors.size;
210 }
211
212 public getConnectorStatus(id: number): ConnectorStatus {
213 return this.connectors.get(id);
214 }
215
216 public getCurrentOutType(): CurrentType | undefined {
217 return this.stationInfo.currentOutType ?? CurrentType.AC;
218 }
219
220 public getOcppStrictCompliance(): boolean {
221 return this.stationInfo.ocppStrictCompliance ?? false;
222 }
223
224 public getVoltageOut(): number | undefined {
225 const errMsg = `${this.logPrefix()} Unknown ${this.getCurrentOutType()} currentOutType in template file ${
226 this.templateFile
227 }, cannot define default voltage out`;
228 let defaultVoltageOut: number;
229 switch (this.getCurrentOutType()) {
230 case CurrentType.AC:
231 defaultVoltageOut = Voltage.VOLTAGE_230;
232 break;
233 case CurrentType.DC:
234 defaultVoltageOut = Voltage.VOLTAGE_400;
235 break;
236 default:
237 logger.error(errMsg);
238 throw new Error(errMsg);
239 }
240 return !Utils.isUndefined(this.stationInfo.voltageOut)
241 ? this.stationInfo.voltageOut
242 : defaultVoltageOut;
243 }
244
245 public getConnectorMaximumAvailablePower(connectorId: number): number {
246 let connectorAmperageLimitationPowerLimit: number;
247 if (
248 !Utils.isNullOrUndefined(this.getAmperageLimitation()) &&
249 this.getAmperageLimitation() < this.stationInfo.maximumAmperage
250 ) {
251 connectorAmperageLimitationPowerLimit =
252 (this.getCurrentOutType() === CurrentType.AC
253 ? ACElectricUtils.powerTotal(
254 this.getNumberOfPhases(),
255 this.getVoltageOut(),
256 this.getAmperageLimitation() * this.getNumberOfConnectors()
257 )
258 : DCElectricUtils.power(this.getVoltageOut(), this.getAmperageLimitation())) /
259 this.stationInfo.powerDivider;
260 }
261 const connectorMaximumPower = this.getMaximumPower() / this.stationInfo.powerDivider;
262 const connectorChargingProfilePowerLimit = this.getChargingProfilePowerLimit(connectorId);
263 return Math.min(
264 isNaN(connectorMaximumPower) ? Infinity : connectorMaximumPower,
265 isNaN(connectorAmperageLimitationPowerLimit)
266 ? Infinity
267 : connectorAmperageLimitationPowerLimit,
268 isNaN(connectorChargingProfilePowerLimit) ? Infinity : connectorChargingProfilePowerLimit
269 );
270 }
271
272 public getTransactionIdTag(transactionId: number): string | undefined {
273 for (const connectorId of this.connectors.keys()) {
274 if (connectorId > 0 && this.getConnectorStatus(connectorId).transactionId === transactionId) {
275 return this.getConnectorStatus(connectorId).transactionIdTag;
276 }
277 }
278 }
279
280 public getOutOfOrderEndMeterValues(): boolean {
281 return this.stationInfo.outOfOrderEndMeterValues ?? false;
282 }
283
284 public getBeginEndMeterValues(): boolean {
285 return this.stationInfo.beginEndMeterValues ?? false;
286 }
287
288 public getMeteringPerTransaction(): boolean {
289 return this.stationInfo.meteringPerTransaction ?? true;
290 }
291
292 public getTransactionDataMeterValues(): boolean {
293 return this.stationInfo.transactionDataMeterValues ?? false;
294 }
295
296 public getMainVoltageMeterValues(): boolean {
297 return this.stationInfo.mainVoltageMeterValues ?? true;
298 }
299
300 public getPhaseLineToLineVoltageMeterValues(): boolean {
301 return this.stationInfo.phaseLineToLineVoltageMeterValues ?? false;
302 }
303
304 public getConnectorIdByTransactionId(transactionId: number): number | undefined {
305 for (const connectorId of this.connectors.keys()) {
306 if (
307 connectorId > 0 &&
308 this.getConnectorStatus(connectorId)?.transactionId === transactionId
309 ) {
310 return connectorId;
311 }
312 }
313 }
314
315 public getEnergyActiveImportRegisterByTransactionId(transactionId: number): number | undefined {
316 const transactionConnectorStatus = this.getConnectorStatus(
317 this.getConnectorIdByTransactionId(transactionId)
318 );
319 if (this.getMeteringPerTransaction()) {
320 return transactionConnectorStatus?.transactionEnergyActiveImportRegisterValue;
321 }
322 return transactionConnectorStatus?.energyActiveImportRegisterValue;
323 }
324
325 public getEnergyActiveImportRegisterByConnectorId(connectorId: number): number | undefined {
326 const connectorStatus = this.getConnectorStatus(connectorId);
327 if (this.getMeteringPerTransaction()) {
328 return connectorStatus?.transactionEnergyActiveImportRegisterValue;
329 }
330 return connectorStatus?.energyActiveImportRegisterValue;
331 }
332
333 public getAuthorizeRemoteTxRequests(): boolean {
334 const authorizeRemoteTxRequests = this.getConfigurationKey(
335 StandardParametersKey.AuthorizeRemoteTxRequests
336 );
337 return authorizeRemoteTxRequests
338 ? Utils.convertToBoolean(authorizeRemoteTxRequests.value)
339 : false;
340 }
341
342 public getLocalAuthListEnabled(): boolean {
343 const localAuthListEnabled = this.getConfigurationKey(
344 StandardParametersKey.LocalAuthListEnabled
345 );
346 return localAuthListEnabled ? Utils.convertToBoolean(localAuthListEnabled.value) : false;
347 }
348
349 public restartWebSocketPing(): void {
350 // Stop WebSocket ping
351 this.stopWebSocketPing();
352 // Start WebSocket ping
353 this.startWebSocketPing();
354 }
355
356 public getSampledValueTemplate(
357 connectorId: number,
358 measurand: MeterValueMeasurand = MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER,
359 phase?: MeterValuePhase
360 ): SampledValueTemplate | undefined {
361 const onPhaseStr = phase ? `on phase ${phase} ` : '';
362 if (!Constants.SUPPORTED_MEASURANDS.includes(measurand)) {
363 logger.warn(
364 `${this.logPrefix()} Trying to get unsupported MeterValues measurand '${measurand}' ${onPhaseStr}in template on connectorId ${connectorId}`
365 );
366 return;
367 }
368 if (
369 measurand !== MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER &&
370 !this.getConfigurationKey(StandardParametersKey.MeterValuesSampledData)?.value.includes(
371 measurand
372 )
373 ) {
374 logger.debug(
375 `${this.logPrefix()} Trying to get MeterValues measurand '${measurand}' ${onPhaseStr}in template on connectorId ${connectorId} not found in '${
376 StandardParametersKey.MeterValuesSampledData
377 }' OCPP parameter`
378 );
379 return;
380 }
381 const sampledValueTemplates: SampledValueTemplate[] =
382 this.getConnectorStatus(connectorId).MeterValues;
383 for (
384 let index = 0;
385 !Utils.isEmptyArray(sampledValueTemplates) && index < sampledValueTemplates.length;
386 index++
387 ) {
388 if (
389 !Constants.SUPPORTED_MEASURANDS.includes(
390 sampledValueTemplates[index]?.measurand ??
391 MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER
392 )
393 ) {
394 logger.warn(
395 `${this.logPrefix()} Unsupported MeterValues measurand '${measurand}' ${onPhaseStr}in template on connectorId ${connectorId}`
396 );
397 } else if (
398 phase &&
399 sampledValueTemplates[index]?.phase === phase &&
400 sampledValueTemplates[index]?.measurand === measurand &&
401 this.getConfigurationKey(StandardParametersKey.MeterValuesSampledData)?.value.includes(
402 measurand
403 )
404 ) {
405 return sampledValueTemplates[index];
406 } else if (
407 !phase &&
408 !sampledValueTemplates[index].phase &&
409 sampledValueTemplates[index]?.measurand === measurand &&
410 this.getConfigurationKey(StandardParametersKey.MeterValuesSampledData)?.value.includes(
411 measurand
412 )
413 ) {
414 return sampledValueTemplates[index];
415 } else if (
416 measurand === MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER &&
417 (!sampledValueTemplates[index].measurand ||
418 sampledValueTemplates[index].measurand === measurand)
419 ) {
420 return sampledValueTemplates[index];
421 }
422 }
423 if (measurand === MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER) {
424 const errorMsg = `${this.logPrefix()} Missing MeterValues for default measurand '${measurand}' in template on connectorId ${connectorId}`;
425 logger.error(errorMsg);
426 throw new Error(errorMsg);
427 }
428 logger.debug(
429 `${this.logPrefix()} No MeterValues for measurand '${measurand}' ${onPhaseStr}in template on connectorId ${connectorId}`
430 );
431 }
432
433 public getAutomaticTransactionGeneratorRequireAuthorize(): boolean {
434 return this.stationInfo.AutomaticTransactionGenerator.requireAuthorize ?? true;
435 }
436
437 public startHeartbeat(): void {
438 if (
439 this.getHeartbeatInterval() &&
440 this.getHeartbeatInterval() > 0 &&
441 !this.heartbeatSetInterval
442 ) {
443 // eslint-disable-next-line @typescript-eslint/no-misused-promises
444 this.heartbeatSetInterval = setInterval(async (): Promise<void> => {
445 await this.ocppRequestService.sendMessageHandler<HeartbeatRequest, HeartbeatResponse>(
446 RequestCommand.HEARTBEAT
447 );
448 }, this.getHeartbeatInterval());
449 logger.info(
450 this.logPrefix() +
451 ' Heartbeat started every ' +
452 Utils.formatDurationMilliSeconds(this.getHeartbeatInterval())
453 );
454 } else if (this.heartbeatSetInterval) {
455 logger.info(
456 this.logPrefix() +
457 ' Heartbeat already started every ' +
458 Utils.formatDurationMilliSeconds(this.getHeartbeatInterval())
459 );
460 } else {
461 logger.error(
462 `${this.logPrefix()} Heartbeat interval set to ${
463 this.getHeartbeatInterval()
464 ? Utils.formatDurationMilliSeconds(this.getHeartbeatInterval())
465 : this.getHeartbeatInterval()
466 }, not starting the heartbeat`
467 );
468 }
469 }
470
471 public restartHeartbeat(): void {
472 // Stop heartbeat
473 this.stopHeartbeat();
474 // Start heartbeat
475 this.startHeartbeat();
476 }
477
478 public startMeterValues(connectorId: number, interval: number): void {
479 if (connectorId === 0) {
480 logger.error(
481 `${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId.toString()}`
482 );
483 return;
484 }
485 if (!this.getConnectorStatus(connectorId)) {
486 logger.error(
487 `${this.logPrefix()} Trying to start MeterValues on non existing connector Id ${connectorId.toString()}`
488 );
489 return;
490 }
491 if (!this.getConnectorStatus(connectorId)?.transactionStarted) {
492 logger.error(
493 `${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId} with no transaction started`
494 );
495 return;
496 } else if (
497 this.getConnectorStatus(connectorId)?.transactionStarted &&
498 !this.getConnectorStatus(connectorId)?.transactionId
499 ) {
500 logger.error(
501 `${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId} with no transaction id`
502 );
503 return;
504 }
505 if (interval > 0) {
506 // eslint-disable-next-line @typescript-eslint/no-misused-promises
507 this.getConnectorStatus(connectorId).transactionSetInterval = setInterval(
508 // eslint-disable-next-line @typescript-eslint/no-misused-promises
509 async (): Promise<void> => {
510 // FIXME: Implement OCPP version agnostic helpers
511 const meterValue: MeterValue = OCPP16ServiceUtils.buildMeterValue(
512 this,
513 connectorId,
514 this.getConnectorStatus(connectorId).transactionId,
515 interval
516 );
517 await this.ocppRequestService.sendMessageHandler<MeterValuesRequest, MeterValuesResponse>(
518 RequestCommand.METER_VALUES,
519 {
520 connectorId,
521 transactionId: this.getConnectorStatus(connectorId).transactionId,
522 meterValue: [meterValue],
523 }
524 );
525 },
526 interval
527 );
528 } else {
529 logger.error(
530 `${this.logPrefix()} Charging station ${
531 StandardParametersKey.MeterValueSampleInterval
532 } configuration set to ${
533 interval ? Utils.formatDurationMilliSeconds(interval) : interval
534 }, not sending MeterValues`
535 );
536 }
537 }
538
539 public start(): void {
540 if (this.getEnableStatistics()) {
541 this.performanceStatistics.start();
542 }
543 this.openWSConnection();
544 // Monitor authorization file
545 FileUtils.watchJsonFile<string[]>(
546 this.logPrefix(),
547 FileType.Authorization,
548 this.getAuthorizationFile(),
549 this.authorizedTags
550 );
551 // Monitor charging station template file
552 FileUtils.watchJsonFile(
553 this.logPrefix(),
554 FileType.ChargingStationTemplate,
555 this.templateFile,
556 null,
557 (event, filename): void => {
558 if (filename && event === 'change') {
559 try {
560 logger.debug(
561 `${this.logPrefix()} ${FileType.ChargingStationTemplate} ${
562 this.templateFile
563 } file have changed, reload`
564 );
565 // Initialize
566 this.initialize();
567 // Restart the ATG
568 if (
569 !this.stationInfo.AutomaticTransactionGenerator.enable &&
570 this.automaticTransactionGenerator
571 ) {
572 this.automaticTransactionGenerator.stop();
573 }
574 this.startAutomaticTransactionGenerator();
575 if (this.getEnableStatistics()) {
576 this.performanceStatistics.restart();
577 } else {
578 this.performanceStatistics.stop();
579 }
580 // FIXME?: restart heartbeat and WebSocket ping when their interval values have changed
581 } catch (error) {
582 logger.error(
583 `${this.logPrefix()} ${FileType.ChargingStationTemplate} file monitoring error: %j`,
584 error
585 );
586 }
587 }
588 }
589 );
590 // Handle WebSocket message
591 this.wsConnection.on(
592 'message',
593 this.onMessage.bind(this) as (this: WebSocket, data: RawData, isBinary: boolean) => void
594 );
595 // Handle WebSocket error
596 this.wsConnection.on(
597 'error',
598 this.onError.bind(this) as (this: WebSocket, error: Error) => void
599 );
600 // Handle WebSocket close
601 this.wsConnection.on(
602 'close',
603 this.onClose.bind(this) as (this: WebSocket, code: number, reason: Buffer) => void
604 );
605 // Handle WebSocket open
606 this.wsConnection.on('open', this.onOpen.bind(this) as (this: WebSocket) => void);
607 // Handle WebSocket ping
608 this.wsConnection.on('ping', this.onPing.bind(this) as (this: WebSocket, data: Buffer) => void);
609 // Handle WebSocket pong
610 this.wsConnection.on('pong', this.onPong.bind(this) as (this: WebSocket, data: Buffer) => void);
611 parentPort.postMessage({
612 id: ChargingStationWorkerMessageEvents.STARTED,
613 data: { id: this.stationInfo.chargingStationId },
614 });
615 }
616
617 public async stop(reason: StopTransactionReason = StopTransactionReason.NONE): Promise<void> {
618 // Stop message sequence
619 await this.stopMessageSequence(reason);
620 for (const connectorId of this.connectors.keys()) {
621 if (connectorId > 0) {
622 await this.ocppRequestService.sendMessageHandler<
623 StatusNotificationRequest,
624 StatusNotificationResponse
625 >(RequestCommand.STATUS_NOTIFICATION, {
626 connectorId,
627 status: ChargePointStatus.UNAVAILABLE,
628 errorCode: ChargePointErrorCode.NO_ERROR,
629 });
630 this.getConnectorStatus(connectorId).status = ChargePointStatus.UNAVAILABLE;
631 }
632 }
633 if (this.isWebSocketConnectionOpened()) {
634 this.wsConnection.close();
635 }
636 if (this.getEnableStatistics()) {
637 this.performanceStatistics.stop();
638 }
639 this.bootNotificationResponse = null;
640 parentPort.postMessage({
641 id: ChargingStationWorkerMessageEvents.STOPPED,
642 data: { id: this.stationInfo.chargingStationId },
643 });
644 this.stopped = true;
645 }
646
647 public getConfigurationKey(
648 key: string | StandardParametersKey,
649 caseInsensitive = false
650 ): ConfigurationKey | undefined {
651 return this.ocppConfiguration.configurationKey.find((configElement) => {
652 if (caseInsensitive) {
653 return configElement.key.toLowerCase() === key.toLowerCase();
654 }
655 return configElement.key === key;
656 });
657 }
658
659 public addConfigurationKey(
660 key: string | StandardParametersKey,
661 value: string,
662 options: { readonly?: boolean; visible?: boolean; reboot?: boolean } = {
663 readonly: false,
664 visible: true,
665 reboot: false,
666 },
667 params: { overwrite?: boolean; save?: boolean } = { overwrite: false, save: false }
668 ): void {
669 options = options ?? ({} as { readonly?: boolean; visible?: boolean; reboot?: boolean });
670 options.readonly = options?.readonly ?? false;
671 options.visible = options?.visible ?? true;
672 options.reboot = options?.reboot ?? false;
673 let keyFound = this.getConfigurationKey(key);
674 if (keyFound && params?.overwrite) {
675 this.deleteConfigurationKey(keyFound.key, { save: false });
676 keyFound = undefined;
677 }
678 if (!keyFound) {
679 this.ocppConfiguration.configurationKey.push({
680 key,
681 readonly: options.readonly,
682 value,
683 visible: options.visible,
684 reboot: options.reboot,
685 });
686 params?.save && this.saveOcppConfiguration();
687 } else {
688 logger.error(
689 `${this.logPrefix()} Trying to add an already existing configuration key: %j`,
690 keyFound
691 );
692 }
693 }
694
695 public setConfigurationKeyValue(
696 key: string | StandardParametersKey,
697 value: string,
698 caseInsensitive = false
699 ): void {
700 const keyFound = this.getConfigurationKey(key, caseInsensitive);
701 if (keyFound) {
702 this.ocppConfiguration.configurationKey[
703 this.ocppConfiguration.configurationKey.indexOf(keyFound)
704 ].value = value;
705 this.saveOcppConfiguration();
706 } else {
707 logger.error(
708 `${this.logPrefix()} Trying to set a value on a non existing configuration key: %j`,
709 { key, value }
710 );
711 }
712 }
713
714 public deleteConfigurationKey(
715 key: string | StandardParametersKey,
716 params: { save?: boolean; caseInsensitive?: boolean } = { save: true, caseInsensitive: false }
717 ): ConfigurationKey[] {
718 const keyFound = this.getConfigurationKey(key, params?.caseInsensitive);
719 if (keyFound) {
720 const deletedConfigurationKey = this.ocppConfiguration.configurationKey.splice(
721 this.ocppConfiguration.configurationKey.indexOf(keyFound),
722 1
723 );
724 params?.save && this.saveOcppConfiguration();
725 return deletedConfigurationKey;
726 }
727 }
728
729 public getChargingProfilePowerLimit(connectorId: number): number | undefined {
730 const timestamp = new Date().getTime();
731 let matchingChargingProfile: ChargingProfile;
732 let chargingSchedulePeriods: ChargingSchedulePeriod[] = [];
733 if (!Utils.isEmptyArray(this.getConnectorStatus(connectorId)?.chargingProfiles)) {
734 const chargingProfiles: ChargingProfile[] = this.getConnectorStatus(
735 connectorId
736 ).chargingProfiles.filter(
737 (chargingProfile) =>
738 timestamp >= chargingProfile.chargingSchedule?.startSchedule.getTime() &&
739 timestamp <
740 chargingProfile.chargingSchedule?.startSchedule.getTime() +
741 chargingProfile.chargingSchedule.duration * 1000 &&
742 chargingProfile?.stackLevel === Math.max(...chargingProfiles.map((cp) => cp?.stackLevel))
743 );
744 if (!Utils.isEmptyArray(chargingProfiles)) {
745 for (const chargingProfile of chargingProfiles) {
746 if (!Utils.isEmptyArray(chargingProfile.chargingSchedule.chargingSchedulePeriod)) {
747 chargingSchedulePeriods =
748 chargingProfile.chargingSchedule.chargingSchedulePeriod.filter(
749 (chargingSchedulePeriod, index) => {
750 timestamp >=
751 chargingProfile.chargingSchedule.startSchedule.getTime() +
752 chargingSchedulePeriod.startPeriod * 1000 &&
753 ((chargingProfile.chargingSchedule.chargingSchedulePeriod[index + 1] &&
754 timestamp <
755 chargingProfile.chargingSchedule.startSchedule.getTime() +
756 chargingProfile.chargingSchedule.chargingSchedulePeriod[index + 1]
757 ?.startPeriod *
758 1000) ||
759 !chargingProfile.chargingSchedule.chargingSchedulePeriod[index + 1]);
760 }
761 );
762 if (!Utils.isEmptyArray(chargingSchedulePeriods)) {
763 matchingChargingProfile = chargingProfile;
764 break;
765 }
766 }
767 }
768 }
769 }
770 let limit: number;
771 if (!Utils.isEmptyArray(chargingSchedulePeriods)) {
772 switch (this.getCurrentOutType()) {
773 case CurrentType.AC:
774 limit =
775 matchingChargingProfile.chargingSchedule.chargingRateUnit === ChargingRateUnitType.WATT
776 ? chargingSchedulePeriods[0].limit
777 : ACElectricUtils.powerTotal(
778 this.getNumberOfPhases(),
779 this.getVoltageOut(),
780 chargingSchedulePeriods[0].limit
781 );
782 break;
783 case CurrentType.DC:
784 limit =
785 matchingChargingProfile.chargingSchedule.chargingRateUnit === ChargingRateUnitType.WATT
786 ? chargingSchedulePeriods[0].limit
787 : DCElectricUtils.power(this.getVoltageOut(), chargingSchedulePeriods[0].limit);
788 }
789 }
790 const connectorMaximumPower = this.getMaximumPower() / this.stationInfo.powerDivider;
791 if (limit > connectorMaximumPower) {
792 logger.error(
793 `${this.logPrefix()} Charging profile id ${
794 matchingChargingProfile.chargingProfileId
795 } limit is greater than connector id ${connectorId} maximum, dump charging profiles' stack: %j`,
796 this.getConnectorStatus(connectorId).chargingProfiles
797 );
798 limit = connectorMaximumPower;
799 }
800 return limit;
801 }
802
803 public setChargingProfile(connectorId: number, cp: ChargingProfile): void {
804 let cpReplaced = false;
805 if (!Utils.isEmptyArray(this.getConnectorStatus(connectorId).chargingProfiles)) {
806 this.getConnectorStatus(connectorId).chargingProfiles?.forEach(
807 (chargingProfile: ChargingProfile, index: number) => {
808 if (
809 chargingProfile.chargingProfileId === cp.chargingProfileId ||
810 (chargingProfile.stackLevel === cp.stackLevel &&
811 chargingProfile.chargingProfilePurpose === cp.chargingProfilePurpose)
812 ) {
813 this.getConnectorStatus(connectorId).chargingProfiles[index] = cp;
814 cpReplaced = true;
815 }
816 }
817 );
818 }
819 !cpReplaced && this.getConnectorStatus(connectorId).chargingProfiles?.push(cp);
820 }
821
822 public resetConnectorStatus(connectorId: number): void {
823 this.getConnectorStatus(connectorId).idTagLocalAuthorized = false;
824 this.getConnectorStatus(connectorId).idTagAuthorized = false;
825 this.getConnectorStatus(connectorId).transactionRemoteStarted = false;
826 this.getConnectorStatus(connectorId).transactionStarted = false;
827 delete this.getConnectorStatus(connectorId).localAuthorizeIdTag;
828 delete this.getConnectorStatus(connectorId).authorizeIdTag;
829 delete this.getConnectorStatus(connectorId).transactionId;
830 delete this.getConnectorStatus(connectorId).transactionIdTag;
831 this.getConnectorStatus(connectorId).transactionEnergyActiveImportRegisterValue = 0;
832 delete this.getConnectorStatus(connectorId).transactionBeginMeterValue;
833 this.stopMeterValues(connectorId);
834 }
835
836 public hasFeatureProfile(featureProfile: SupportedFeatureProfiles) {
837 return this.getConfigurationKey(StandardParametersKey.SupportedFeatureProfiles)?.value.includes(
838 featureProfile
839 );
840 }
841
842 public bufferMessage(message: string): void {
843 this.messageBuffer.add(message);
844 }
845
846 private flushMessageBuffer() {
847 if (this.messageBuffer.size > 0) {
848 this.messageBuffer.forEach((message) => {
849 // TODO: evaluate the need to track performance
850 this.wsConnection.send(message);
851 this.messageBuffer.delete(message);
852 });
853 }
854 }
855
856 private getSupervisionUrlOcppConfiguration(): boolean {
857 return this.stationInfo.supervisionUrlOcppConfiguration ?? false;
858 }
859
860 private getSupervisionUrlOcppKey(): string {
861 return this.stationInfo.supervisionUrlOcppKey ?? VendorDefaultParametersKey.ConnectionUrl;
862 }
863
864 private getChargingStationId(stationTemplate: ChargingStationTemplate): string {
865 // In case of multiple instances: add instance index to charging station id
866 const instanceIndex = process.env.CF_INSTANCE_INDEX ?? 0;
867 const idSuffix = stationTemplate.nameSuffix ?? '';
868 const idStr = '000000000' + this.index.toString();
869 return stationTemplate.fixedName
870 ? stationTemplate.baseName
871 : stationTemplate.baseName +
872 '-' +
873 instanceIndex.toString() +
874 idStr.substring(idStr.length - 4) +
875 idSuffix;
876 }
877
878 private getRandomSerialNumberSuffix(params?: {
879 randomBytesLength?: number;
880 upperCase?: boolean;
881 }): string {
882 const randomSerialNumberSuffix = crypto
883 .randomBytes(params?.randomBytesLength ?? 16)
884 .toString('hex');
885 if (params?.upperCase) {
886 return randomSerialNumberSuffix.toUpperCase();
887 }
888 return randomSerialNumberSuffix;
889 }
890
891 private getTemplateFromFile(): ChargingStationTemplate | null {
892 let template: ChargingStationTemplate = null;
893 try {
894 const measureId = `${FileType.ChargingStationTemplate} read`;
895 const beginId = PerformanceStatistics.beginMeasure(measureId);
896 template = JSON.parse(fs.readFileSync(this.templateFile, 'utf8')) as ChargingStationTemplate;
897 PerformanceStatistics.endMeasure(measureId, beginId);
898 } catch (error) {
899 FileUtils.handleFileException(
900 this.logPrefix(),
901 FileType.ChargingStationTemplate,
902 this.templateFile,
903 error as NodeJS.ErrnoException
904 );
905 }
906 return template;
907 }
908
909 private createSerialNumber(
910 stationInfo: ChargingStationInfo,
911 existingStationInfo?: ChargingStationInfo,
912 params: { randomSerialNumberUpperCase?: boolean; randomSerialNumber?: boolean } = {
913 randomSerialNumberUpperCase: true,
914 randomSerialNumber: true,
915 }
916 ): void {
917 params = params ?? {};
918 params.randomSerialNumberUpperCase = params?.randomSerialNumberUpperCase ?? true;
919 params.randomSerialNumber = params?.randomSerialNumber ?? true;
920 if (existingStationInfo) {
921 existingStationInfo?.chargePointSerialNumber &&
922 (stationInfo.chargePointSerialNumber = existingStationInfo.chargePointSerialNumber);
923 existingStationInfo?.chargeBoxSerialNumber &&
924 (stationInfo.chargeBoxSerialNumber = existingStationInfo.chargeBoxSerialNumber);
925 existingStationInfo?.meterSerialNumber &&
926 (stationInfo.meterSerialNumber = existingStationInfo.meterSerialNumber);
927 } else {
928 const serialNumberSuffix = params?.randomSerialNumber
929 ? this.getRandomSerialNumberSuffix({ upperCase: params.randomSerialNumberUpperCase })
930 : '';
931 stationInfo.chargePointSerialNumber =
932 stationInfo?.chargePointSerialNumberPrefix &&
933 stationInfo.chargePointSerialNumberPrefix + serialNumberSuffix;
934 stationInfo.chargeBoxSerialNumber =
935 stationInfo?.chargeBoxSerialNumberPrefix &&
936 stationInfo.chargeBoxSerialNumberPrefix + serialNumberSuffix;
937 stationInfo.meterSerialNumber =
938 stationInfo?.meterSerialNumberPrefix &&
939 stationInfo.meterSerialNumberPrefix + serialNumberSuffix;
940 }
941 }
942
943 private getStationInfoFromTemplate(): ChargingStationInfo {
944 const stationInfo: ChargingStationInfo =
945 this.getTemplateFromFile() ?? ({} as ChargingStationInfo);
946 stationInfo.hash = crypto
947 .createHash(Constants.DEFAULT_HASH_ALGORITHM)
948 .update(JSON.stringify(stationInfo))
949 .digest('hex');
950 const chargingStationId = this.getChargingStationId(stationInfo);
951 // Deprecation template keys section
952 this.warnDeprecatedTemplateKey(
953 stationInfo,
954 'supervisionUrl',
955 chargingStationId,
956 "Use 'supervisionUrls' instead"
957 );
958 this.convertDeprecatedTemplateKey(stationInfo, 'supervisionUrl', 'supervisionUrls');
959 stationInfo.wsOptions = stationInfo?.wsOptions ?? {};
960 if (!Utils.isEmptyArray(stationInfo.power)) {
961 stationInfo.power = stationInfo.power as number[];
962 const powerArrayRandomIndex = Math.floor(Utils.secureRandom() * stationInfo.power.length);
963 stationInfo.maximumPower =
964 stationInfo.powerUnit === PowerUnits.KILO_WATT
965 ? stationInfo.power[powerArrayRandomIndex] * 1000
966 : stationInfo.power[powerArrayRandomIndex];
967 } else {
968 stationInfo.power = stationInfo.power as number;
969 stationInfo.maximumPower =
970 stationInfo.powerUnit === PowerUnits.KILO_WATT
971 ? stationInfo.power * 1000
972 : stationInfo.power;
973 }
974 delete stationInfo.power;
975 delete stationInfo.powerUnit;
976 stationInfo.chargingStationId = chargingStationId;
977 stationInfo.resetTime = stationInfo.resetTime
978 ? stationInfo.resetTime * 1000
979 : Constants.CHARGING_STATION_DEFAULT_RESET_TIME;
980 return stationInfo;
981 }
982
983 private getStationInfoFromFile(): ChargingStationInfo | null {
984 return this.getConfigurationFromFile()?.stationInfo ?? null;
985 }
986
987 private getStationInfo(): ChargingStationInfo {
988 const stationInfoFromTemplate: ChargingStationInfo = this.getStationInfoFromTemplate();
989 this.hashId = this.getHashId(stationInfoFromTemplate);
990 this.configurationFile = path.join(
991 path.resolve(__dirname, '../'),
992 'assets',
993 'configurations',
994 this.hashId + '.json'
995 );
996 const stationInfoFromFile: ChargingStationInfo = this.getStationInfoFromFile();
997 if (stationInfoFromFile?.hash === stationInfoFromTemplate.hash) {
998 return stationInfoFromFile;
999 }
1000 this.createSerialNumber(stationInfoFromTemplate, stationInfoFromFile);
1001 return stationInfoFromTemplate;
1002 }
1003
1004 private saveStationInfo(): void {
1005 this.saveConfiguration(Section.stationInfo);
1006 }
1007
1008 private getOcppVersion(): OCPPVersion {
1009 return this.stationInfo.ocppVersion ? this.stationInfo.ocppVersion : OCPPVersion.VERSION_16;
1010 }
1011
1012 private getOcppPersistentConfiguration(): boolean {
1013 return this.stationInfo.ocppPersistentConfiguration ?? true;
1014 }
1015
1016 private handleUnsupportedVersion(version: OCPPVersion) {
1017 const errMsg = `${this.logPrefix()} Unsupported protocol version '${version}' configured in template file ${
1018 this.templateFile
1019 }`;
1020 logger.error(errMsg);
1021 throw new Error(errMsg);
1022 }
1023
1024 private createBootNotificationRequest(stationInfo: ChargingStationInfo): BootNotificationRequest {
1025 return {
1026 chargePointModel: stationInfo.chargePointModel,
1027 chargePointVendor: stationInfo.chargePointVendor,
1028 ...(!Utils.isUndefined(stationInfo.chargeBoxSerialNumber) && {
1029 chargeBoxSerialNumber: stationInfo.chargeBoxSerialNumber,
1030 }),
1031 ...(!Utils.isUndefined(stationInfo.chargePointSerialNumber) && {
1032 chargePointSerialNumber: stationInfo.chargePointSerialNumber,
1033 }),
1034 ...(!Utils.isUndefined(stationInfo.firmwareVersion) && {
1035 firmwareVersion: stationInfo.firmwareVersion,
1036 }),
1037 ...(!Utils.isUndefined(stationInfo.iccid) && { iccid: stationInfo.iccid }),
1038 ...(!Utils.isUndefined(stationInfo.imsi) && { imsi: stationInfo.imsi }),
1039 ...(!Utils.isUndefined(stationInfo.meterSerialNumber) && {
1040 meterSerialNumber: stationInfo.meterSerialNumber,
1041 }),
1042 ...(!Utils.isUndefined(stationInfo.meterType) && {
1043 meterType: stationInfo.meterType,
1044 }),
1045 };
1046 }
1047
1048 private getHashId(stationInfo: ChargingStationInfo): string {
1049 const hashBootNotificationRequest = {
1050 chargePointModel: stationInfo.chargePointModel,
1051 chargePointVendor: stationInfo.chargePointVendor,
1052 ...(!Utils.isUndefined(stationInfo.chargeBoxSerialNumberPrefix) && {
1053 chargeBoxSerialNumber: stationInfo.chargeBoxSerialNumberPrefix,
1054 }),
1055 ...(!Utils.isUndefined(stationInfo.chargePointSerialNumberPrefix) && {
1056 chargePointSerialNumber: stationInfo.chargePointSerialNumberPrefix,
1057 }),
1058 ...(!Utils.isUndefined(stationInfo.firmwareVersion) && {
1059 firmwareVersion: stationInfo.firmwareVersion,
1060 }),
1061 ...(!Utils.isUndefined(stationInfo.iccid) && { iccid: stationInfo.iccid }),
1062 ...(!Utils.isUndefined(stationInfo.imsi) && { imsi: stationInfo.imsi }),
1063 ...(!Utils.isUndefined(stationInfo.meterSerialNumberPrefix) && {
1064 meterSerialNumber: stationInfo.meterSerialNumberPrefix,
1065 }),
1066 ...(!Utils.isUndefined(stationInfo.meterType) && {
1067 meterType: stationInfo.meterType,
1068 }),
1069 };
1070 return crypto
1071 .createHash(Constants.DEFAULT_HASH_ALGORITHM)
1072 .update(JSON.stringify(hashBootNotificationRequest) + stationInfo.chargingStationId)
1073 .digest('hex');
1074 }
1075
1076 private initialize(): void {
1077 this.stationInfo = this.getStationInfo();
1078 logger.info(`${this.logPrefix()} Charging station hashId '${this.hashId}'`);
1079 this.bootNotificationRequest = this.createBootNotificationRequest(this.stationInfo);
1080 this.ocppConfiguration = this.getOcppConfiguration();
1081 delete this.stationInfo.Configuration;
1082 this.wsConfiguredConnectionUrl = new URL(
1083 this.getConfiguredSupervisionUrl().href + '/' + this.stationInfo.chargingStationId
1084 );
1085 // Build connectors if needed
1086 const maxConnectors = this.getMaxNumberOfConnectors();
1087 if (maxConnectors <= 0) {
1088 logger.warn(
1089 `${this.logPrefix()} Charging station template ${
1090 this.templateFile
1091 } with ${maxConnectors} connectors`
1092 );
1093 }
1094 const templateMaxConnectors = this.getTemplateMaxNumberOfConnectors();
1095 if (templateMaxConnectors <= 0) {
1096 logger.warn(
1097 `${this.logPrefix()} Charging station template ${
1098 this.templateFile
1099 } with no connector configuration`
1100 );
1101 }
1102 if (!this.stationInfo.Connectors[0]) {
1103 logger.warn(
1104 `${this.logPrefix()} Charging station template ${
1105 this.templateFile
1106 } with no connector Id 0 configuration`
1107 );
1108 }
1109 // Sanity check
1110 if (
1111 maxConnectors >
1112 (this.stationInfo.Connectors[0] ? templateMaxConnectors - 1 : templateMaxConnectors) &&
1113 !this.stationInfo.randomConnectors
1114 ) {
1115 logger.warn(
1116 `${this.logPrefix()} Number of connectors exceeds the number of connector configurations in template ${
1117 this.templateFile
1118 }, forcing random connector configurations affectation`
1119 );
1120 this.stationInfo.randomConnectors = true;
1121 }
1122 const connectorsConfigHash = crypto
1123 .createHash(Constants.DEFAULT_HASH_ALGORITHM)
1124 .update(JSON.stringify(this.stationInfo.Connectors) + maxConnectors.toString())
1125 .digest('hex');
1126 const connectorsConfigChanged =
1127 this.connectors?.size !== 0 && this.connectorsConfigurationHash !== connectorsConfigHash;
1128 if (this.connectors?.size === 0 || connectorsConfigChanged) {
1129 connectorsConfigChanged && this.connectors.clear();
1130 this.connectorsConfigurationHash = connectorsConfigHash;
1131 // Add connector Id 0
1132 let lastConnector = '0';
1133 for (lastConnector in this.stationInfo.Connectors) {
1134 const lastConnectorId = Utils.convertToInt(lastConnector);
1135 if (
1136 lastConnectorId === 0 &&
1137 this.getUseConnectorId0() &&
1138 this.stationInfo.Connectors[lastConnector]
1139 ) {
1140 this.connectors.set(
1141 lastConnectorId,
1142 Utils.cloneObject<ConnectorStatus>(this.stationInfo.Connectors[lastConnector])
1143 );
1144 this.getConnectorStatus(lastConnectorId).availability = AvailabilityType.OPERATIVE;
1145 if (Utils.isUndefined(this.getConnectorStatus(lastConnectorId)?.chargingProfiles)) {
1146 this.getConnectorStatus(lastConnectorId).chargingProfiles = [];
1147 }
1148 }
1149 }
1150 // Generate all connectors
1151 if (
1152 (this.stationInfo.Connectors[0] ? templateMaxConnectors - 1 : templateMaxConnectors) > 0
1153 ) {
1154 for (let index = 1; index <= maxConnectors; index++) {
1155 const randConnectorId = this.stationInfo.randomConnectors
1156 ? Utils.getRandomInteger(Utils.convertToInt(lastConnector), 1)
1157 : index;
1158 this.connectors.set(
1159 index,
1160 Utils.cloneObject<ConnectorStatus>(this.stationInfo.Connectors[randConnectorId])
1161 );
1162 this.getConnectorStatus(index).availability = AvailabilityType.OPERATIVE;
1163 if (Utils.isUndefined(this.getConnectorStatus(index)?.chargingProfiles)) {
1164 this.getConnectorStatus(index).chargingProfiles = [];
1165 }
1166 }
1167 }
1168 }
1169 this.stationInfo.maximumAmperage = this.getMaximumAmperage();
1170 this.saveStationInfo();
1171 // Avoid duplication of connectors related information in RAM
1172 delete this.stationInfo.Connectors;
1173 // Initialize transaction attributes on connectors
1174 for (const connectorId of this.connectors.keys()) {
1175 if (connectorId > 0 && !this.getConnectorStatus(connectorId)?.transactionStarted) {
1176 this.initializeConnectorStatus(connectorId);
1177 }
1178 }
1179 // OCPP configuration
1180 this.initializeOcppConfiguration();
1181 if (this.getEnableStatistics()) {
1182 this.performanceStatistics = PerformanceStatistics.getInstance(
1183 this.hashId,
1184 this.stationInfo.chargingStationId,
1185 this.wsConnectionUrl
1186 );
1187 }
1188 switch (this.getOcppVersion()) {
1189 case OCPPVersion.VERSION_16:
1190 this.ocppIncomingRequestService =
1191 OCPP16IncomingRequestService.getInstance<OCPP16IncomingRequestService>(this);
1192 this.ocppRequestService = OCPP16RequestService.getInstance<OCPP16RequestService>(
1193 this,
1194 OCPP16ResponseService.getInstance<OCPP16ResponseService>(this)
1195 );
1196 break;
1197 default:
1198 this.handleUnsupportedVersion(this.getOcppVersion());
1199 break;
1200 }
1201 if (this.stationInfo.autoRegister) {
1202 this.bootNotificationResponse = {
1203 currentTime: new Date().toISOString(),
1204 interval: this.getHeartbeatInterval() / 1000,
1205 status: RegistrationStatus.ACCEPTED,
1206 };
1207 }
1208 this.stationInfo.powerDivider = this.getPowerDivider();
1209 }
1210
1211 private initializeOcppConfiguration(): void {
1212 if (
1213 this.getSupervisionUrlOcppConfiguration() &&
1214 !this.getConfigurationKey(this.getSupervisionUrlOcppKey())
1215 ) {
1216 this.addConfigurationKey(
1217 this.getSupervisionUrlOcppKey(),
1218 this.getConfiguredSupervisionUrl().href,
1219 { reboot: true }
1220 );
1221 } else if (
1222 !this.getSupervisionUrlOcppConfiguration() &&
1223 this.getConfigurationKey(this.getSupervisionUrlOcppKey())
1224 ) {
1225 this.deleteConfigurationKey(this.getSupervisionUrlOcppKey(), { save: false });
1226 }
1227 if (
1228 this.stationInfo.amperageLimitationOcppKey &&
1229 !this.getConfigurationKey(this.stationInfo.amperageLimitationOcppKey)
1230 ) {
1231 this.addConfigurationKey(
1232 this.stationInfo.amperageLimitationOcppKey,
1233 (this.stationInfo.maximumAmperage * this.getAmperageLimitationUnitDivider()).toString()
1234 );
1235 }
1236 if (!this.getConfigurationKey(StandardParametersKey.SupportedFeatureProfiles)) {
1237 this.addConfigurationKey(
1238 StandardParametersKey.SupportedFeatureProfiles,
1239 `${SupportedFeatureProfiles.Core},${SupportedFeatureProfiles.FirmwareManagement},${SupportedFeatureProfiles.LocalAuthListManagement},${SupportedFeatureProfiles.SmartCharging},${SupportedFeatureProfiles.RemoteTrigger}`
1240 );
1241 }
1242 this.addConfigurationKey(
1243 StandardParametersKey.NumberOfConnectors,
1244 this.getNumberOfConnectors().toString(),
1245 { readonly: true },
1246 { overwrite: true }
1247 );
1248 if (!this.getConfigurationKey(StandardParametersKey.MeterValuesSampledData)) {
1249 this.addConfigurationKey(
1250 StandardParametersKey.MeterValuesSampledData,
1251 MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER
1252 );
1253 }
1254 if (!this.getConfigurationKey(StandardParametersKey.ConnectorPhaseRotation)) {
1255 const connectorPhaseRotation = [];
1256 for (const connectorId of this.connectors.keys()) {
1257 // AC/DC
1258 if (connectorId === 0 && this.getNumberOfPhases() === 0) {
1259 connectorPhaseRotation.push(`${connectorId}.${ConnectorPhaseRotation.RST}`);
1260 } else if (connectorId > 0 && this.getNumberOfPhases() === 0) {
1261 connectorPhaseRotation.push(`${connectorId}.${ConnectorPhaseRotation.NotApplicable}`);
1262 // AC
1263 } else if (connectorId > 0 && this.getNumberOfPhases() === 1) {
1264 connectorPhaseRotation.push(`${connectorId}.${ConnectorPhaseRotation.NotApplicable}`);
1265 } else if (connectorId > 0 && this.getNumberOfPhases() === 3) {
1266 connectorPhaseRotation.push(`${connectorId}.${ConnectorPhaseRotation.RST}`);
1267 }
1268 }
1269 this.addConfigurationKey(
1270 StandardParametersKey.ConnectorPhaseRotation,
1271 connectorPhaseRotation.toString()
1272 );
1273 }
1274 if (!this.getConfigurationKey(StandardParametersKey.AuthorizeRemoteTxRequests)) {
1275 this.addConfigurationKey(StandardParametersKey.AuthorizeRemoteTxRequests, 'true');
1276 }
1277 if (
1278 !this.getConfigurationKey(StandardParametersKey.LocalAuthListEnabled) &&
1279 this.getConfigurationKey(StandardParametersKey.SupportedFeatureProfiles)?.value.includes(
1280 SupportedFeatureProfiles.LocalAuthListManagement
1281 )
1282 ) {
1283 this.addConfigurationKey(StandardParametersKey.LocalAuthListEnabled, 'false');
1284 }
1285 if (!this.getConfigurationKey(StandardParametersKey.ConnectionTimeOut)) {
1286 this.addConfigurationKey(
1287 StandardParametersKey.ConnectionTimeOut,
1288 Constants.DEFAULT_CONNECTION_TIMEOUT.toString()
1289 );
1290 }
1291 this.saveOcppConfiguration();
1292 }
1293
1294 private getConfigurationFromFile(): ChargingStationConfiguration | null {
1295 let configuration: ChargingStationConfiguration = null;
1296 if (this.configurationFile && fs.existsSync(this.configurationFile)) {
1297 try {
1298 const measureId = `${FileType.ChargingStationConfiguration} read`;
1299 const beginId = PerformanceStatistics.beginMeasure(measureId);
1300 configuration = JSON.parse(
1301 fs.readFileSync(this.configurationFile, 'utf8')
1302 ) as ChargingStationConfiguration;
1303 PerformanceStatistics.endMeasure(measureId, beginId);
1304 } catch (error) {
1305 FileUtils.handleFileException(
1306 this.logPrefix(),
1307 FileType.ChargingStationConfiguration,
1308 this.configurationFile,
1309 error as NodeJS.ErrnoException
1310 );
1311 }
1312 }
1313 return configuration;
1314 }
1315
1316 private saveConfiguration(section?: Section): void {
1317 if (this.configurationFile) {
1318 try {
1319 const configurationData: ChargingStationConfiguration =
1320 this.getConfigurationFromFile() ?? {};
1321 if (!fs.existsSync(path.dirname(this.configurationFile))) {
1322 fs.mkdirSync(path.dirname(this.configurationFile), { recursive: true });
1323 }
1324 switch (section) {
1325 case Section.ocppConfiguration:
1326 configurationData.configurationKey = this.ocppConfiguration.configurationKey;
1327 break;
1328 case Section.stationInfo:
1329 configurationData.stationInfo = this.stationInfo;
1330 break;
1331 default:
1332 configurationData.configurationKey = this.ocppConfiguration.configurationKey;
1333 configurationData.stationInfo = this.stationInfo;
1334 break;
1335 }
1336 const measureId = `${FileType.ChargingStationConfiguration} write`;
1337 const beginId = PerformanceStatistics.beginMeasure(measureId);
1338 const fileDescriptor = fs.openSync(this.configurationFile, 'w');
1339 fs.writeFileSync(fileDescriptor, JSON.stringify(configurationData, null, 2), 'utf8');
1340 fs.closeSync(fileDescriptor);
1341 PerformanceStatistics.endMeasure(measureId, beginId);
1342 } catch (error) {
1343 FileUtils.handleFileException(
1344 this.logPrefix(),
1345 FileType.ChargingStationConfiguration,
1346 this.configurationFile,
1347 error as NodeJS.ErrnoException
1348 );
1349 }
1350 } else {
1351 logger.error(
1352 `${this.logPrefix()} Trying to save charging station configuration to undefined file`
1353 );
1354 }
1355 }
1356
1357 private getOcppConfigurationFromTemplate(): ChargingStationOcppConfiguration {
1358 return this.getTemplateFromFile().Configuration ?? ({} as ChargingStationOcppConfiguration);
1359 }
1360
1361 private getOcppConfigurationFromFile(): ChargingStationOcppConfiguration | null {
1362 let configuration: ChargingStationConfiguration = null;
1363 if (this.getOcppPersistentConfiguration()) {
1364 const configurationFromFile = this.getConfigurationFromFile();
1365 configuration = configurationFromFile?.configurationKey && configurationFromFile;
1366 }
1367 configuration && delete configuration.stationInfo;
1368 return configuration;
1369 }
1370
1371 private getOcppConfiguration(): ChargingStationOcppConfiguration {
1372 let ocppConfiguration: ChargingStationOcppConfiguration = this.getOcppConfigurationFromFile();
1373 if (!ocppConfiguration) {
1374 ocppConfiguration = this.getOcppConfigurationFromTemplate();
1375 }
1376 return ocppConfiguration;
1377 }
1378
1379 private saveOcppConfiguration(): void {
1380 if (this.getOcppPersistentConfiguration()) {
1381 this.saveConfiguration(Section.ocppConfiguration);
1382 }
1383 }
1384
1385 private async onOpen(): Promise<void> {
1386 if (this.isWebSocketConnectionOpened()) {
1387 logger.info(
1388 `${this.logPrefix()} Connection to OCPP server through ${this.wsConnectionUrl.toString()} succeeded`
1389 );
1390 if (!this.isInAcceptedState()) {
1391 // Send BootNotification
1392 let registrationRetryCount = 0;
1393 do {
1394 this.bootNotificationResponse = await this.ocppRequestService.sendMessageHandler<
1395 BootNotificationRequest,
1396 BootNotificationResponse
1397 >(
1398 RequestCommand.BOOT_NOTIFICATION,
1399 {
1400 chargePointModel: this.bootNotificationRequest.chargePointModel,
1401 chargePointVendor: this.bootNotificationRequest.chargePointVendor,
1402 chargeBoxSerialNumber: this.bootNotificationRequest.chargeBoxSerialNumber,
1403 firmwareVersion: this.bootNotificationRequest.firmwareVersion,
1404 chargePointSerialNumber: this.bootNotificationRequest.chargePointSerialNumber,
1405 iccid: this.bootNotificationRequest.iccid,
1406 imsi: this.bootNotificationRequest.imsi,
1407 meterSerialNumber: this.bootNotificationRequest.meterSerialNumber,
1408 meterType: this.bootNotificationRequest.meterType,
1409 },
1410 { skipBufferingOnError: true }
1411 );
1412 if (!this.isInAcceptedState()) {
1413 this.getRegistrationMaxRetries() !== -1 && registrationRetryCount++;
1414 await Utils.sleep(
1415 this.bootNotificationResponse?.interval
1416 ? this.bootNotificationResponse.interval * 1000
1417 : Constants.OCPP_DEFAULT_BOOT_NOTIFICATION_INTERVAL
1418 );
1419 }
1420 } while (
1421 !this.isInAcceptedState() &&
1422 (registrationRetryCount <= this.getRegistrationMaxRetries() ||
1423 this.getRegistrationMaxRetries() === -1)
1424 );
1425 }
1426 if (this.isInAcceptedState()) {
1427 await this.startMessageSequence();
1428 this.stopped && (this.stopped = false);
1429 if (this.wsConnectionRestarted) {
1430 this.flushMessageBuffer();
1431 }
1432 } else {
1433 logger.error(
1434 `${this.logPrefix()} Registration failure: max retries reached (${this.getRegistrationMaxRetries()}) or retry disabled (${this.getRegistrationMaxRetries()})`
1435 );
1436 }
1437 this.autoReconnectRetryCount = 0;
1438 this.wsConnectionRestarted = false;
1439 } else {
1440 logger.warn(
1441 `${this.logPrefix()} Connection to OCPP server through ${this.wsConnectionUrl.toString()} failed`
1442 );
1443 }
1444 }
1445
1446 private async onClose(code: number, reason: string): Promise<void> {
1447 switch (code) {
1448 // Normal close
1449 case WebSocketCloseEventStatusCode.CLOSE_NORMAL:
1450 case WebSocketCloseEventStatusCode.CLOSE_NO_STATUS:
1451 logger.info(
1452 `${this.logPrefix()} WebSocket normally closed with status '${Utils.getWebSocketCloseEventStatusString(
1453 code
1454 )}' and reason '${reason}'`
1455 );
1456 this.autoReconnectRetryCount = 0;
1457 break;
1458 // Abnormal close
1459 default:
1460 logger.error(
1461 `${this.logPrefix()} WebSocket abnormally closed with status '${Utils.getWebSocketCloseEventStatusString(
1462 code
1463 )}' and reason '${reason}'`
1464 );
1465 await this.reconnect(code);
1466 break;
1467 }
1468 }
1469
1470 private async onMessage(data: Data): Promise<void> {
1471 let [messageType, messageId, commandName, commandPayload, errorDetails]: IncomingRequest = [
1472 0,
1473 '',
1474 '' as IncomingRequestCommand,
1475 {},
1476 {},
1477 ];
1478 let responseCallback: (
1479 payload: JsonType | string,
1480 requestPayload: JsonType | OCPPError
1481 ) => void;
1482 let rejectCallback: (error: OCPPError, requestStatistic?: boolean) => void;
1483 let requestCommandName: RequestCommand | IncomingRequestCommand;
1484 let requestPayload: JsonType | OCPPError;
1485 let cachedRequest: CachedRequest;
1486 let errMsg: string;
1487 try {
1488 const request = JSON.parse(data.toString()) as IncomingRequest;
1489 if (Utils.isIterable(request)) {
1490 // Parse the message
1491 [messageType, messageId, commandName, commandPayload, errorDetails] = request;
1492 } else {
1493 throw new OCPPError(
1494 ErrorType.PROTOCOL_ERROR,
1495 'Incoming message is not iterable',
1496 Utils.isString(commandName) && commandName,
1497 { payload: request }
1498 );
1499 }
1500 // Check the Type of message
1501 switch (messageType) {
1502 // Incoming Message
1503 case MessageType.CALL_MESSAGE:
1504 if (this.getEnableStatistics()) {
1505 this.performanceStatistics.addRequestStatistic(commandName, messageType);
1506 }
1507 logger.debug(
1508 `${this.logPrefix()} << Command '${commandName}' received request payload: ${JSON.stringify(
1509 request
1510 )}`
1511 );
1512 // Process the call
1513 await this.ocppIncomingRequestService.handleRequest(
1514 messageId,
1515 commandName,
1516 commandPayload
1517 );
1518 break;
1519 // Outcome Message
1520 case MessageType.CALL_RESULT_MESSAGE:
1521 // Respond
1522 cachedRequest = this.requests.get(messageId);
1523 if (Utils.isIterable(cachedRequest)) {
1524 [responseCallback, , requestCommandName, requestPayload] = cachedRequest;
1525 } else {
1526 throw new OCPPError(
1527 ErrorType.PROTOCOL_ERROR,
1528 `Cached request for message id ${messageId} response is not iterable`,
1529 requestCommandName
1530 );
1531 }
1532 logger.debug(
1533 `${this.logPrefix()} << Command '${requestCommandName}' received response payload: ${JSON.stringify(
1534 request
1535 )}`
1536 );
1537 if (!responseCallback) {
1538 // Error
1539 throw new OCPPError(
1540 ErrorType.INTERNAL_ERROR,
1541 `Response for unknown message id ${messageId}`,
1542 requestCommandName
1543 );
1544 }
1545 responseCallback(commandName, requestPayload);
1546 break;
1547 // Error Message
1548 case MessageType.CALL_ERROR_MESSAGE:
1549 cachedRequest = this.requests.get(messageId);
1550 if (Utils.isIterable(cachedRequest)) {
1551 [, rejectCallback, requestCommandName] = cachedRequest;
1552 } else {
1553 throw new OCPPError(
1554 ErrorType.PROTOCOL_ERROR,
1555 `Cached request for message id ${messageId} error response is not iterable`
1556 );
1557 }
1558 logger.debug(
1559 `${this.logPrefix()} << Command '${requestCommandName}' received error payload: ${JSON.stringify(
1560 request
1561 )}`
1562 );
1563 if (!rejectCallback) {
1564 // Error
1565 throw new OCPPError(
1566 ErrorType.INTERNAL_ERROR,
1567 `Error response for unknown message id ${messageId}`,
1568 requestCommandName
1569 );
1570 }
1571 rejectCallback(
1572 new OCPPError(commandName, commandPayload.toString(), requestCommandName, errorDetails)
1573 );
1574 break;
1575 // Error
1576 default:
1577 // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
1578 errMsg = `${this.logPrefix()} Wrong message type ${messageType}`;
1579 logger.error(errMsg);
1580 throw new OCPPError(ErrorType.PROTOCOL_ERROR, errMsg);
1581 }
1582 } catch (error) {
1583 // Log
1584 logger.error(
1585 '%s Incoming OCPP message %j matching cached request %j processing error %j',
1586 this.logPrefix(),
1587 data.toString(),
1588 this.requests.get(messageId),
1589 error
1590 );
1591 // Send error
1592 messageType === MessageType.CALL_MESSAGE &&
1593 (await this.ocppRequestService.sendError(messageId, error as OCPPError, commandName));
1594 }
1595 }
1596
1597 private onPing(): void {
1598 logger.debug(this.logPrefix() + ' Received a WS ping (rfc6455) from the server');
1599 }
1600
1601 private onPong(): void {
1602 logger.debug(this.logPrefix() + ' Received a WS pong (rfc6455) from the server');
1603 }
1604
1605 private onError(error: WSError): void {
1606 logger.error(this.logPrefix() + ' WebSocket error: %j', error);
1607 }
1608
1609 private getAuthorizationFile(): string | undefined {
1610 return (
1611 this.stationInfo.authorizationFile &&
1612 path.join(
1613 path.resolve(__dirname, '../'),
1614 'assets',
1615 path.basename(this.stationInfo.authorizationFile)
1616 )
1617 );
1618 }
1619
1620 private getAuthorizedTags(): string[] {
1621 let authorizedTags: string[] = [];
1622 const authorizationFile = this.getAuthorizationFile();
1623 if (authorizationFile) {
1624 try {
1625 // Load authorization file
1626 authorizedTags = JSON.parse(fs.readFileSync(authorizationFile, 'utf8')) as string[];
1627 } catch (error) {
1628 FileUtils.handleFileException(
1629 this.logPrefix(),
1630 FileType.Authorization,
1631 authorizationFile,
1632 error as NodeJS.ErrnoException
1633 );
1634 }
1635 } else {
1636 logger.info(
1637 this.logPrefix() + ' No authorization file given in template file ' + this.templateFile
1638 );
1639 }
1640 return authorizedTags;
1641 }
1642
1643 private getUseConnectorId0(): boolean | undefined {
1644 return !Utils.isUndefined(this.stationInfo.useConnectorId0)
1645 ? this.stationInfo.useConnectorId0
1646 : true;
1647 }
1648
1649 private getNumberOfRunningTransactions(): number {
1650 let trxCount = 0;
1651 for (const connectorId of this.connectors.keys()) {
1652 if (connectorId > 0 && this.getConnectorStatus(connectorId)?.transactionStarted) {
1653 trxCount++;
1654 }
1655 }
1656 return trxCount;
1657 }
1658
1659 // 0 for disabling
1660 private getConnectionTimeout(): number | undefined {
1661 if (this.getConfigurationKey(StandardParametersKey.ConnectionTimeOut)) {
1662 return (
1663 parseInt(this.getConfigurationKey(StandardParametersKey.ConnectionTimeOut).value) ??
1664 Constants.DEFAULT_CONNECTION_TIMEOUT
1665 );
1666 }
1667 return Constants.DEFAULT_CONNECTION_TIMEOUT;
1668 }
1669
1670 // -1 for unlimited, 0 for disabling
1671 private getAutoReconnectMaxRetries(): number | undefined {
1672 if (!Utils.isUndefined(this.stationInfo.autoReconnectMaxRetries)) {
1673 return this.stationInfo.autoReconnectMaxRetries;
1674 }
1675 if (!Utils.isUndefined(Configuration.getAutoReconnectMaxRetries())) {
1676 return Configuration.getAutoReconnectMaxRetries();
1677 }
1678 return -1;
1679 }
1680
1681 // 0 for disabling
1682 private getRegistrationMaxRetries(): number | undefined {
1683 if (!Utils.isUndefined(this.stationInfo.registrationMaxRetries)) {
1684 return this.stationInfo.registrationMaxRetries;
1685 }
1686 return -1;
1687 }
1688
1689 private getPowerDivider(): number {
1690 let powerDivider = this.getNumberOfConnectors();
1691 if (this.stationInfo.powerSharedByConnectors) {
1692 powerDivider = this.getNumberOfRunningTransactions();
1693 }
1694 return powerDivider;
1695 }
1696
1697 private getTemplateMaxNumberOfConnectors(): number {
1698 return Object.keys(this.stationInfo.Connectors).length;
1699 }
1700
1701 private getMaxNumberOfConnectors(): number {
1702 let maxConnectors: number;
1703 if (!Utils.isEmptyArray(this.stationInfo.numberOfConnectors)) {
1704 const numberOfConnectors = this.stationInfo.numberOfConnectors as number[];
1705 // Distribute evenly the number of connectors
1706 maxConnectors = numberOfConnectors[(this.index - 1) % numberOfConnectors.length];
1707 } else if (!Utils.isUndefined(this.stationInfo.numberOfConnectors)) {
1708 maxConnectors = this.stationInfo.numberOfConnectors as number;
1709 } else {
1710 maxConnectors = this.stationInfo.Connectors[0]
1711 ? this.getTemplateMaxNumberOfConnectors() - 1
1712 : this.getTemplateMaxNumberOfConnectors();
1713 }
1714 return maxConnectors;
1715 }
1716
1717 private getMaximumPower(): number {
1718 return (this.stationInfo['maxPower'] as number) ?? this.stationInfo.maximumPower;
1719 }
1720
1721 private getMaximumAmperage(): number | undefined {
1722 const maximumPower = this.getMaximumPower();
1723 switch (this.getCurrentOutType()) {
1724 case CurrentType.AC:
1725 return ACElectricUtils.amperagePerPhaseFromPower(
1726 this.getNumberOfPhases(),
1727 maximumPower / this.getNumberOfConnectors(),
1728 this.getVoltageOut()
1729 );
1730 case CurrentType.DC:
1731 return DCElectricUtils.amperage(maximumPower, this.getVoltageOut());
1732 }
1733 }
1734
1735 private getAmperageLimitationUnitDivider(): number {
1736 let unitDivider = 1;
1737 switch (this.stationInfo.amperageLimitationUnit) {
1738 case AmpereUnits.DECI_AMPERE:
1739 unitDivider = 10;
1740 break;
1741 case AmpereUnits.CENTI_AMPERE:
1742 unitDivider = 100;
1743 break;
1744 case AmpereUnits.MILLI_AMPERE:
1745 unitDivider = 1000;
1746 break;
1747 }
1748 return unitDivider;
1749 }
1750
1751 private getAmperageLimitation(): number | undefined {
1752 if (
1753 this.stationInfo.amperageLimitationOcppKey &&
1754 this.getConfigurationKey(this.stationInfo.amperageLimitationOcppKey)
1755 ) {
1756 return (
1757 Utils.convertToInt(
1758 this.getConfigurationKey(this.stationInfo.amperageLimitationOcppKey).value
1759 ) / this.getAmperageLimitationUnitDivider()
1760 );
1761 }
1762 }
1763
1764 private async startMessageSequence(): Promise<void> {
1765 if (this.stationInfo.autoRegister) {
1766 await this.ocppRequestService.sendMessageHandler<
1767 BootNotificationRequest,
1768 BootNotificationResponse
1769 >(
1770 RequestCommand.BOOT_NOTIFICATION,
1771 {
1772 chargePointModel: this.bootNotificationRequest.chargePointModel,
1773 chargePointVendor: this.bootNotificationRequest.chargePointVendor,
1774 chargeBoxSerialNumber: this.bootNotificationRequest.chargeBoxSerialNumber,
1775 firmwareVersion: this.bootNotificationRequest.firmwareVersion,
1776 chargePointSerialNumber: this.bootNotificationRequest.chargePointSerialNumber,
1777 iccid: this.bootNotificationRequest.iccid,
1778 imsi: this.bootNotificationRequest.imsi,
1779 meterSerialNumber: this.bootNotificationRequest.meterSerialNumber,
1780 meterType: this.bootNotificationRequest.meterType,
1781 },
1782 { skipBufferingOnError: true }
1783 );
1784 }
1785 // Start WebSocket ping
1786 this.startWebSocketPing();
1787 // Start heartbeat
1788 this.startHeartbeat();
1789 // Initialize connectors status
1790 for (const connectorId of this.connectors.keys()) {
1791 if (connectorId === 0) {
1792 continue;
1793 } else if (
1794 !this.stopped &&
1795 !this.getConnectorStatus(connectorId)?.status &&
1796 this.getConnectorStatus(connectorId)?.bootStatus
1797 ) {
1798 // Send status in template at startup
1799 await this.ocppRequestService.sendMessageHandler<
1800 StatusNotificationRequest,
1801 StatusNotificationResponse
1802 >(RequestCommand.STATUS_NOTIFICATION, {
1803 connectorId,
1804 status: this.getConnectorStatus(connectorId).bootStatus,
1805 errorCode: ChargePointErrorCode.NO_ERROR,
1806 });
1807 this.getConnectorStatus(connectorId).status =
1808 this.getConnectorStatus(connectorId).bootStatus;
1809 } else if (
1810 this.stopped &&
1811 this.getConnectorStatus(connectorId)?.status &&
1812 this.getConnectorStatus(connectorId)?.bootStatus
1813 ) {
1814 // Send status in template after reset
1815 await this.ocppRequestService.sendMessageHandler<
1816 StatusNotificationRequest,
1817 StatusNotificationResponse
1818 >(RequestCommand.STATUS_NOTIFICATION, {
1819 connectorId,
1820 status: this.getConnectorStatus(connectorId).bootStatus,
1821 errorCode: ChargePointErrorCode.NO_ERROR,
1822 });
1823 this.getConnectorStatus(connectorId).status =
1824 this.getConnectorStatus(connectorId).bootStatus;
1825 } else if (!this.stopped && this.getConnectorStatus(connectorId)?.status) {
1826 // Send previous status at template reload
1827 await this.ocppRequestService.sendMessageHandler<
1828 StatusNotificationRequest,
1829 StatusNotificationResponse
1830 >(RequestCommand.STATUS_NOTIFICATION, {
1831 connectorId,
1832 status: this.getConnectorStatus(connectorId).status,
1833 errorCode: ChargePointErrorCode.NO_ERROR,
1834 });
1835 } else {
1836 // Send default status
1837 await this.ocppRequestService.sendMessageHandler<
1838 StatusNotificationRequest,
1839 StatusNotificationResponse
1840 >(RequestCommand.STATUS_NOTIFICATION, {
1841 connectorId,
1842 status: ChargePointStatus.AVAILABLE,
1843 errorCode: ChargePointErrorCode.NO_ERROR,
1844 });
1845 this.getConnectorStatus(connectorId).status = ChargePointStatus.AVAILABLE;
1846 }
1847 }
1848 // Start the ATG
1849 this.startAutomaticTransactionGenerator();
1850 }
1851
1852 private startAutomaticTransactionGenerator() {
1853 if (this.stationInfo.AutomaticTransactionGenerator.enable) {
1854 if (!this.automaticTransactionGenerator) {
1855 this.automaticTransactionGenerator = AutomaticTransactionGenerator.getInstance(this);
1856 }
1857 if (!this.automaticTransactionGenerator.started) {
1858 this.automaticTransactionGenerator.start();
1859 }
1860 }
1861 }
1862
1863 private async stopMessageSequence(
1864 reason: StopTransactionReason = StopTransactionReason.NONE
1865 ): Promise<void> {
1866 // Stop WebSocket ping
1867 this.stopWebSocketPing();
1868 // Stop heartbeat
1869 this.stopHeartbeat();
1870 // Stop the ATG
1871 if (
1872 this.stationInfo.AutomaticTransactionGenerator.enable &&
1873 this.automaticTransactionGenerator?.started
1874 ) {
1875 this.automaticTransactionGenerator.stop();
1876 } else {
1877 for (const connectorId of this.connectors.keys()) {
1878 if (connectorId > 0 && this.getConnectorStatus(connectorId)?.transactionStarted) {
1879 const transactionId = this.getConnectorStatus(connectorId).transactionId;
1880 if (
1881 this.getBeginEndMeterValues() &&
1882 this.getOcppStrictCompliance() &&
1883 !this.getOutOfOrderEndMeterValues()
1884 ) {
1885 // FIXME: Implement OCPP version agnostic helpers
1886 const transactionEndMeterValue = OCPP16ServiceUtils.buildTransactionEndMeterValue(
1887 this,
1888 connectorId,
1889 this.getEnergyActiveImportRegisterByTransactionId(transactionId)
1890 );
1891 await this.ocppRequestService.sendMessageHandler<
1892 MeterValuesRequest,
1893 MeterValuesResponse
1894 >(RequestCommand.METER_VALUES, {
1895 connectorId,
1896 transactionId,
1897 meterValue: transactionEndMeterValue,
1898 });
1899 }
1900 await this.ocppRequestService.sendMessageHandler<
1901 StopTransactionRequest,
1902 StopTransactionResponse
1903 >(RequestCommand.STOP_TRANSACTION, {
1904 transactionId,
1905 meterStop: this.getEnergyActiveImportRegisterByTransactionId(transactionId),
1906 idTag: this.getTransactionIdTag(transactionId),
1907 reason,
1908 });
1909 }
1910 }
1911 }
1912 }
1913
1914 private startWebSocketPing(): void {
1915 const webSocketPingInterval: number = this.getConfigurationKey(
1916 StandardParametersKey.WebSocketPingInterval
1917 )
1918 ? Utils.convertToInt(
1919 this.getConfigurationKey(StandardParametersKey.WebSocketPingInterval).value
1920 )
1921 : 0;
1922 if (webSocketPingInterval > 0 && !this.webSocketPingSetInterval) {
1923 this.webSocketPingSetInterval = setInterval(() => {
1924 if (this.isWebSocketConnectionOpened()) {
1925 this.wsConnection.ping((): void => {
1926 /* This is intentional */
1927 });
1928 }
1929 }, webSocketPingInterval * 1000);
1930 logger.info(
1931 this.logPrefix() +
1932 ' WebSocket ping started every ' +
1933 Utils.formatDurationSeconds(webSocketPingInterval)
1934 );
1935 } else if (this.webSocketPingSetInterval) {
1936 logger.info(
1937 this.logPrefix() +
1938 ' WebSocket ping every ' +
1939 Utils.formatDurationSeconds(webSocketPingInterval) +
1940 ' already started'
1941 );
1942 } else {
1943 logger.error(
1944 `${this.logPrefix()} WebSocket ping interval set to ${
1945 webSocketPingInterval
1946 ? Utils.formatDurationSeconds(webSocketPingInterval)
1947 : webSocketPingInterval
1948 }, not starting the WebSocket ping`
1949 );
1950 }
1951 }
1952
1953 private stopWebSocketPing(): void {
1954 if (this.webSocketPingSetInterval) {
1955 clearInterval(this.webSocketPingSetInterval);
1956 }
1957 }
1958
1959 private warnDeprecatedTemplateKey(
1960 template: ChargingStationTemplate,
1961 key: string,
1962 chargingStationId: string,
1963 logMsgToAppend = ''
1964 ): void {
1965 if (!Utils.isUndefined(template[key])) {
1966 const logPrefixStr = ` ${chargingStationId} |`;
1967 logger.warn(
1968 `${Utils.logPrefix(logPrefixStr)} Deprecated template key '${key}' usage in file '${
1969 this.templateFile
1970 }'${logMsgToAppend && '. ' + logMsgToAppend}`
1971 );
1972 }
1973 }
1974
1975 private convertDeprecatedTemplateKey(
1976 template: ChargingStationTemplate,
1977 deprecatedKey: string,
1978 key: string
1979 ): void {
1980 if (!Utils.isUndefined(template[deprecatedKey])) {
1981 template[key] = template[deprecatedKey] as unknown;
1982 delete template[deprecatedKey];
1983 }
1984 }
1985
1986 private getConfiguredSupervisionUrl(): URL {
1987 const supervisionUrls = Utils.cloneObject<string | string[]>(
1988 this.stationInfo.supervisionUrls ?? Configuration.getSupervisionUrls()
1989 );
1990 if (!Utils.isEmptyArray(supervisionUrls)) {
1991 let urlIndex = 0;
1992 switch (Configuration.getSupervisionUrlDistribution()) {
1993 case SupervisionUrlDistribution.ROUND_ROBIN:
1994 urlIndex = (this.index - 1) % supervisionUrls.length;
1995 break;
1996 case SupervisionUrlDistribution.RANDOM:
1997 // Get a random url
1998 urlIndex = Math.floor(Utils.secureRandom() * supervisionUrls.length);
1999 break;
2000 case SupervisionUrlDistribution.SEQUENTIAL:
2001 if (this.index <= supervisionUrls.length) {
2002 urlIndex = this.index - 1;
2003 } else {
2004 logger.warn(
2005 `${this.logPrefix()} No more configured supervision urls available, using the first one`
2006 );
2007 }
2008 break;
2009 default:
2010 logger.error(
2011 `${this.logPrefix()} Unknown supervision url distribution '${Configuration.getSupervisionUrlDistribution()}' from values '${SupervisionUrlDistribution.toString()}', defaulting to ${
2012 SupervisionUrlDistribution.ROUND_ROBIN
2013 }`
2014 );
2015 urlIndex = (this.index - 1) % supervisionUrls.length;
2016 break;
2017 }
2018 return new URL(supervisionUrls[urlIndex]);
2019 }
2020 return new URL(supervisionUrls as string);
2021 }
2022
2023 private getHeartbeatInterval(): number | undefined {
2024 const HeartbeatInterval = this.getConfigurationKey(StandardParametersKey.HeartbeatInterval);
2025 if (HeartbeatInterval) {
2026 return Utils.convertToInt(HeartbeatInterval.value) * 1000;
2027 }
2028 const HeartBeatInterval = this.getConfigurationKey(StandardParametersKey.HeartBeatInterval);
2029 if (HeartBeatInterval) {
2030 return Utils.convertToInt(HeartBeatInterval.value) * 1000;
2031 }
2032 !this.stationInfo.autoRegister &&
2033 logger.warn(
2034 `${this.logPrefix()} Heartbeat interval configuration key not set, using default value: ${
2035 Constants.DEFAULT_HEARTBEAT_INTERVAL
2036 }`
2037 );
2038 return Constants.DEFAULT_HEARTBEAT_INTERVAL;
2039 }
2040
2041 private stopHeartbeat(): void {
2042 if (this.heartbeatSetInterval) {
2043 clearInterval(this.heartbeatSetInterval);
2044 }
2045 }
2046
2047 private openWSConnection(
2048 options: WsOptions = this.stationInfo.wsOptions,
2049 forceCloseOpened = false
2050 ): void {
2051 options.handshakeTimeout = options?.handshakeTimeout ?? this.getConnectionTimeout() * 1000;
2052 if (
2053 !Utils.isNullOrUndefined(this.stationInfo.supervisionUser) &&
2054 !Utils.isNullOrUndefined(this.stationInfo.supervisionPassword)
2055 ) {
2056 options.auth = `${this.stationInfo.supervisionUser}:${this.stationInfo.supervisionPassword}`;
2057 }
2058 if (this.isWebSocketConnectionOpened() && forceCloseOpened) {
2059 this.wsConnection.close();
2060 }
2061 let protocol: string;
2062 switch (this.getOcppVersion()) {
2063 case OCPPVersion.VERSION_16:
2064 protocol = 'ocpp' + OCPPVersion.VERSION_16;
2065 break;
2066 default:
2067 this.handleUnsupportedVersion(this.getOcppVersion());
2068 break;
2069 }
2070 this.wsConnection = new WebSocket(this.wsConnectionUrl, protocol, options);
2071 logger.info(
2072 this.logPrefix() + ' Open OCPP connection to URL ' + this.wsConnectionUrl.toString()
2073 );
2074 }
2075
2076 private stopMeterValues(connectorId: number) {
2077 if (this.getConnectorStatus(connectorId)?.transactionSetInterval) {
2078 clearInterval(this.getConnectorStatus(connectorId).transactionSetInterval);
2079 }
2080 }
2081
2082 private getReconnectExponentialDelay(): boolean | undefined {
2083 return !Utils.isUndefined(this.stationInfo.reconnectExponentialDelay)
2084 ? this.stationInfo.reconnectExponentialDelay
2085 : false;
2086 }
2087
2088 private async reconnect(code: number): Promise<void> {
2089 // Stop WebSocket ping
2090 this.stopWebSocketPing();
2091 // Stop heartbeat
2092 this.stopHeartbeat();
2093 // Stop the ATG if needed
2094 if (
2095 this.stationInfo.AutomaticTransactionGenerator.enable &&
2096 this.stationInfo.AutomaticTransactionGenerator.stopOnConnectionFailure &&
2097 this.automaticTransactionGenerator?.started
2098 ) {
2099 this.automaticTransactionGenerator.stop();
2100 }
2101 if (
2102 this.autoReconnectRetryCount < this.getAutoReconnectMaxRetries() ||
2103 this.getAutoReconnectMaxRetries() === -1
2104 ) {
2105 this.autoReconnectRetryCount++;
2106 const reconnectDelay = this.getReconnectExponentialDelay()
2107 ? Utils.exponentialDelay(this.autoReconnectRetryCount)
2108 : this.getConnectionTimeout() * 1000;
2109 const reconnectTimeout = reconnectDelay - 100 > 0 && reconnectDelay;
2110 logger.error(
2111 `${this.logPrefix()} WebSocket: connection retry in ${Utils.roundTo(
2112 reconnectDelay,
2113 2
2114 )}ms, timeout ${reconnectTimeout}ms`
2115 );
2116 await Utils.sleep(reconnectDelay);
2117 logger.error(
2118 this.logPrefix() +
2119 ' WebSocket: reconnecting try #' +
2120 this.autoReconnectRetryCount.toString()
2121 );
2122 this.openWSConnection(
2123 { ...this.stationInfo.wsOptions, handshakeTimeout: reconnectTimeout },
2124 true
2125 );
2126 this.wsConnectionRestarted = true;
2127 } else if (this.getAutoReconnectMaxRetries() !== -1) {
2128 logger.error(
2129 `${this.logPrefix()} WebSocket reconnect failure: maximum retries reached (${
2130 this.autoReconnectRetryCount
2131 }) or retry disabled (${this.getAutoReconnectMaxRetries()})`
2132 );
2133 }
2134 }
2135
2136 private initializeConnectorStatus(connectorId: number): void {
2137 this.getConnectorStatus(connectorId).idTagLocalAuthorized = false;
2138 this.getConnectorStatus(connectorId).idTagAuthorized = false;
2139 this.getConnectorStatus(connectorId).transactionRemoteStarted = false;
2140 this.getConnectorStatus(connectorId).transactionStarted = false;
2141 this.getConnectorStatus(connectorId).energyActiveImportRegisterValue = 0;
2142 this.getConnectorStatus(connectorId).transactionEnergyActiveImportRegisterValue = 0;
2143 }
2144 }