1 import { AuthorizationStatus
, StartTransactionRequest
, StartTransactionResponse
, StopTransactionReason
, StopTransactionRequest
, StopTransactionResponse
} from
'../types/ocpp/1.6/Transaction';
2 import { AvailabilityType
, BootNotificationRequest
, ChangeAvailabilityRequest
, ChangeConfigurationRequest
, GetConfigurationRequest
, HeartbeatRequest
, IncomingRequestCommand
, RemoteStartTransactionRequest
, RemoteStopTransactionRequest
, RequestCommand
, ResetRequest
, SetChargingProfileRequest
, StatusNotificationRequest
, UnlockConnectorRequest
} from
'../types/ocpp/1.6/Requests';
3 import { BootNotificationResponse
, ChangeAvailabilityResponse
, ChangeConfigurationResponse
, DefaultResponse
, GetConfigurationResponse
, HeartbeatResponse
, RegistrationStatus
, SetChargingProfileResponse
, StatusNotificationResponse
, UnlockConnectorResponse
} from
'../types/ocpp/1.6/RequestResponses';
4 import { ChargingProfile
, ChargingProfilePurposeType
} from
'../types/ocpp/1.6/ChargingProfile';
5 import ChargingStationConfiguration
, { ConfigurationKey
} from
'../types/ChargingStationConfiguration';
6 import ChargingStationTemplate
, { PowerOutType
, VoltageOut
} from
'../types/ChargingStationTemplate';
7 import Connectors
, { Connector
} from
'../types/Connectors';
8 import { MeterValue
, MeterValueLocation
, MeterValueMeasurand
, MeterValuePhase
, MeterValueUnit
, MeterValuesRequest
, MeterValuesResponse
, SampledValue
} from
'../types/ocpp/1.6/MeterValues';
9 import { PerformanceObserver
, performance
} from
'perf_hooks';
10 import Requests
, { IncomingRequest
, Request
} from
'../types/ocpp/Requests';
11 import WebSocket
, { MessageEvent
} from
'ws';
13 import AutomaticTransactionGenerator from
'./AutomaticTransactionGenerator';
14 import { ChargePointErrorCode
} from
'../types/ocpp/1.6/ChargePointErrorCode';
15 import { ChargePointStatus
} from
'../types/ocpp/1.6/ChargePointStatus';
16 import ChargingStationInfo from
'../types/ChargingStationInfo';
17 import Configuration from
'../utils/Configuration';
18 import Constants from
'../utils/Constants';
19 import ElectricUtils from
'../utils/ElectricUtils';
20 import { ErrorType
} from
'../types/ocpp/ErrorType';
21 import MeasurandValues from
'../types/MeasurandValues';
22 import { MessageType
} from
'../types/ocpp/MessageType';
23 import { OCPPConfigurationKey
} from
'../types/ocpp/Configuration';
24 import OCPPError from
'./OcppError';
25 import { StandardParametersKey
} from
'../types/ocpp/1.6/Configuration';
26 import Statistics from
'../utils/Statistics';
27 import Utils from
'../utils/Utils';
28 import { WebSocketCloseEventStatusCode
} from
'../types/WebSocket';
29 import crypto from
'crypto';
31 import logger from
'../utils/Logger';
33 export default class ChargingStation
{
34 private _index
: number;
35 private _stationTemplateFile
: string;
36 private _stationInfo
: ChargingStationInfo
;
37 private _bootNotificationRequest
: BootNotificationRequest
;
38 private _bootNotificationResponse
: BootNotificationResponse
;
39 private _connectors
: Connectors
;
40 private _configuration
: ChargingStationConfiguration
;
41 private _connectorsConfigurationHash
: string;
42 private _supervisionUrl
: string;
43 private _wsConnectionUrl
: string;
44 private _wsConnection
: WebSocket
;
45 private _hasStopped
: boolean;
46 private _hasSocketRestarted
: boolean;
47 private _autoReconnectRetryCount
: number;
48 private _requests
: Requests
;
49 private _messageQueue
: string[];
50 private _automaticTransactionGeneration
: AutomaticTransactionGenerator
;
51 private _authorizedTags
: string[];
52 private _heartbeatSetInterval
: NodeJS
.Timeout
;
53 private _webSocketPingSetInterval
: NodeJS
.Timeout
;
54 private _statistics
: Statistics
;
55 private _performanceObserver
: PerformanceObserver
;
57 constructor(index
: number, stationTemplateFile
: string) {
59 this._stationTemplateFile
= stationTemplateFile
;
60 this._connectors
= {} as Connectors
;
63 this._hasStopped
= false;
64 this._hasSocketRestarted
= false;
65 this._autoReconnectRetryCount
= 0;
67 this._requests
= {} as Requests
;
68 this._messageQueue
= [] as string[];
70 this._authorizedTags
= this._loadAndGetAuthorizedTags();
73 _getStationName(stationTemplate
: ChargingStationTemplate
): string {
74 return stationTemplate
.fixedName
? stationTemplate
.baseName
: stationTemplate
.baseName
+ '-' + ('000000000' + this._index
.toString()).substr(('000000000' + this._index
.toString()).length
- 4);
77 _buildStationInfo(): ChargingStationInfo
{
78 let stationTemplateFromFile
: ChargingStationTemplate
;
81 const fileDescriptor
= fs
.openSync(this._stationTemplateFile
, 'r');
82 stationTemplateFromFile
= JSON
.parse(fs
.readFileSync(fileDescriptor
, 'utf8')) as ChargingStationTemplate
;
83 fs
.closeSync(fileDescriptor
);
85 logger
.error('Template file ' + this._stationTemplateFile
+ ' loading error: %j', error
);
88 const stationInfo
: ChargingStationInfo
= stationTemplateFromFile
|| {} as ChargingStationInfo
;
89 if (!Utils
.isEmptyArray(stationTemplateFromFile
.power
)) {
90 stationTemplateFromFile
.power
= stationTemplateFromFile
.power
as number[];
91 stationInfo
.maxPower
= stationTemplateFromFile
.power
[Math.floor(Math.random() * stationTemplateFromFile
.power
.length
)];
93 stationInfo
.maxPower
= stationTemplateFromFile
.power
as number;
95 stationInfo
.name
= this._getStationName(stationTemplateFromFile
);
96 stationInfo
.resetTime
= stationTemplateFromFile
.resetTime
? stationTemplateFromFile
.resetTime
* 1000 : Constants
.CHARGING_STATION_DEFAULT_RESET_TIME
;
100 get
stationInfo(): ChargingStationInfo
{
101 return this._stationInfo
;
104 _initialize(): void {
105 this._stationInfo
= this._buildStationInfo();
106 this._bootNotificationRequest
= {
107 chargePointModel
: this._stationInfo
.chargePointModel
,
108 chargePointVendor
: this._stationInfo
.chargePointVendor
,
109 ...!Utils
.isUndefined(this._stationInfo
.chargeBoxSerialNumberPrefix
) && { chargeBoxSerialNumber
: this._stationInfo
.chargeBoxSerialNumberPrefix
},
110 ...!Utils
.isUndefined(this._stationInfo
.firmwareVersion
) && { firmwareVersion
: this._stationInfo
.firmwareVersion
},
112 this._configuration
= this._getTemplateChargingStationConfiguration();
113 this._supervisionUrl
= this._getSupervisionURL();
114 this._wsConnectionUrl
= this._supervisionUrl
+ '/' + this._stationInfo
.name
;
115 // Build connectors if needed
116 const maxConnectors
= this._getMaxNumberOfConnectors();
117 if (maxConnectors
<= 0) {
118 logger
.warn(`${this._logPrefix()} Charging station template ${this._stationTemplateFile} with ${maxConnectors} connectors`);
120 const templateMaxConnectors
= this._getTemplateMaxNumberOfConnectors();
121 if (templateMaxConnectors
<= 0) {
122 logger
.warn(`${this._logPrefix()} Charging station template ${this._stationTemplateFile} with no connector configuration`);
124 if (!this._stationInfo
.Connectors
[0]) {
125 logger
.warn(`${this._logPrefix()} Charging station template ${this._stationTemplateFile} with no connector Id 0 configuration`);
128 if (maxConnectors
> (this._stationInfo
.Connectors
[0] ? templateMaxConnectors
- 1 : templateMaxConnectors
) && !this._stationInfo
.randomConnectors
) {
129 logger
.warn(`${this._logPrefix()} Number of connectors exceeds the number of connector configurations in template ${this._stationTemplateFile}, forcing random connector configurations affectation`);
130 this._stationInfo
.randomConnectors
= true;
132 const connectorsConfigHash
= crypto
.createHash('sha256').update(JSON
.stringify(this._stationInfo
.Connectors
) + maxConnectors
.toString()).digest('hex');
133 // FIXME: Handle shrinking the number of connectors
134 if (!this._connectors
|| (this._connectors
&& this._connectorsConfigurationHash
!== connectorsConfigHash
)) {
135 this._connectorsConfigurationHash
= connectorsConfigHash
;
136 // Add connector Id 0
137 let lastConnector
= '0';
138 for (lastConnector
in this._stationInfo
.Connectors
) {
139 if (Utils
.convertToInt(lastConnector
) === 0 && this._getUseConnectorId0() && this._stationInfo
.Connectors
[lastConnector
]) {
140 this._connectors
[lastConnector
] = Utils
.cloneObject
<Connector
>(this._stationInfo
.Connectors
[lastConnector
]);
141 this._connectors
[lastConnector
].availability
= AvailabilityType
.OPERATIVE
;
144 // Generate all connectors
145 if ((this._stationInfo
.Connectors
[0] ? templateMaxConnectors
- 1 : templateMaxConnectors
) > 0) {
146 for (let index
= 1; index
<= maxConnectors
; index
++) {
147 const randConnectorID
= this._stationInfo
.randomConnectors
? Utils
.getRandomInt(Utils
.convertToInt(lastConnector
), 1) : index
;
148 this._connectors
[index
] = Utils
.cloneObject
<Connector
>(this._stationInfo
.Connectors
[randConnectorID
]);
149 this._connectors
[index
].availability
= AvailabilityType
.OPERATIVE
;
153 // Avoid duplication of connectors related information
154 delete this._stationInfo
.Connectors
;
155 // Initialize transaction attributes on connectors
156 for (const connector
in this._connectors
) {
157 if (Utils
.convertToInt(connector
) > 0 && !this.getConnector(Utils
.convertToInt(connector
)).transactionStarted
) {
158 this._initTransactionOnConnector(Utils
.convertToInt(connector
));
162 this._addConfigurationKey(StandardParametersKey
.NumberOfConnectors
, this._getNumberOfConnectors().toString(), true);
163 if (!this._getConfigurationKey(StandardParametersKey
.MeterValuesSampledData
)) {
164 this._addConfigurationKey(StandardParametersKey
.MeterValuesSampledData
, MeterValueMeasurand
.ENERGY_ACTIVE_IMPORT_REGISTER
);
166 this._stationInfo
.powerDivider
= this._getPowerDivider();
167 if (this.getEnableStatistics()) {
168 this._statistics
= Statistics
.getInstance();
169 this._statistics
.objName
= this._stationInfo
.name
;
170 this._performanceObserver
= new PerformanceObserver((list
) => {
171 const entry
= list
.getEntries()[0];
172 this._statistics
.logPerformance(entry
, Constants
.ENTITY_CHARGING_STATION
);
173 this._performanceObserver
.disconnect();
178 get
connectors(): Connectors
{
179 return this._connectors
;
182 get
statistics(): Statistics
{
183 return this._statistics
;
186 _logPrefix(): string {
187 return Utils
.logPrefix(` ${this._stationInfo.name}:`);
190 _isWebSocketOpen(): boolean {
191 return this._wsConnection
?.readyState
=== WebSocket
.OPEN
;
194 _isRegistered(): boolean {
195 return this._bootNotificationResponse
?.status === RegistrationStatus
.ACCEPTED
;
198 _getTemplateChargingStationConfiguration(): ChargingStationConfiguration
{
199 return this._stationInfo
.Configuration
? this._stationInfo
.Configuration
: {} as ChargingStationConfiguration
;
202 _getAuthorizationFile(): string {
203 return this._stationInfo
.authorizationFile
&& this._stationInfo
.authorizationFile
;
206 _getUseConnectorId0(): boolean {
207 return !Utils
.isUndefined(this._stationInfo
.useConnectorId0
) ? this._stationInfo
.useConnectorId0
: true;
210 _loadAndGetAuthorizedTags(): string[] {
211 let authorizedTags
: string[] = [];
212 const authorizationFile
= this._getAuthorizationFile();
213 if (authorizationFile
) {
215 // Load authorization file
216 const fileDescriptor
= fs
.openSync(authorizationFile
, 'r');
217 authorizedTags
= JSON
.parse(fs
.readFileSync(fileDescriptor
, 'utf8')) as string[];
218 fs
.closeSync(fileDescriptor
);
220 logger
.error(this._logPrefix() + ' Authorization file ' + authorizationFile
+ ' loading error: %j', error
);
224 logger
.info(this._logPrefix() + ' No authorization file given in template file ' + this._stationTemplateFile
);
226 return authorizedTags
;
229 getRandomTagId(): string {
230 const index
= Math.floor(Math.random() * this._authorizedTags
.length
);
231 return this._authorizedTags
[index
];
234 hasAuthorizedTags(): boolean {
235 return !Utils
.isEmptyArray(this._authorizedTags
);
238 getEnableStatistics(): boolean {
239 return !Utils
.isUndefined(this._stationInfo
.enableStatistics
) ? this._stationInfo
.enableStatistics
: true;
242 _getNumberOfPhases(): number {
243 switch (this._getPowerOutType()) {
244 case PowerOutType
.AC
:
245 return !Utils
.isUndefined(this._stationInfo
.numberOfPhases
) ? this._stationInfo
.numberOfPhases
: 3;
246 case PowerOutType
.DC
:
251 _getNumberOfRunningTransactions(): number {
253 for (const connector
in this._connectors
) {
254 if (Utils
.convertToInt(connector
) > 0 && this.getConnector(Utils
.convertToInt(connector
)).transactionStarted
) {
262 _getConnectionTimeout(): number {
263 if (!Utils
.isUndefined(this._stationInfo
.connectionTimeout
)) {
264 return this._stationInfo
.connectionTimeout
;
266 if (!Utils
.isUndefined(Configuration
.getConnectionTimeout())) {
267 return Configuration
.getConnectionTimeout();
272 // -1 for unlimited, 0 for disabling
273 _getAutoReconnectMaxRetries(): number {
274 if (!Utils
.isUndefined(this._stationInfo
.autoReconnectMaxRetries
)) {
275 return this._stationInfo
.autoReconnectMaxRetries
;
277 if (!Utils
.isUndefined(Configuration
.getAutoReconnectMaxRetries())) {
278 return Configuration
.getAutoReconnectMaxRetries();
284 _getRegistrationMaxRetries(): number {
285 if (!Utils
.isUndefined(this._stationInfo
.registrationMaxRetries
)) {
286 return this._stationInfo
.registrationMaxRetries
;
291 _getPowerDivider(): number {
292 let powerDivider
= this._getNumberOfConnectors();
293 if (this._stationInfo
.powerSharedByConnectors
) {
294 powerDivider
= this._getNumberOfRunningTransactions();
299 getConnector(id
: number): Connector
{
300 return this._connectors
[id
];
303 _isConnectorAvailable(id
: number): boolean {
304 return this.getConnector(id
).availability
=== AvailabilityType
.OPERATIVE
;
307 _isChargingStationAvailable(): boolean {
308 return this.getConnector(0).availability
=== AvailabilityType
.OPERATIVE
;
311 _getTemplateMaxNumberOfConnectors(): number {
312 return Object.keys(this._stationInfo
.Connectors
).length
;
315 _getMaxNumberOfConnectors(): number {
316 let maxConnectors
= 0;
317 if (!Utils
.isEmptyArray(this._stationInfo
.numberOfConnectors
)) {
318 const numberOfConnectors
= this._stationInfo
.numberOfConnectors
as number[];
319 // Distribute evenly the number of connectors
320 maxConnectors
= numberOfConnectors
[(this._index
- 1) % numberOfConnectors
.length
];
321 } else if (!Utils
.isUndefined(this._stationInfo
.numberOfConnectors
)) {
322 maxConnectors
= this._stationInfo
.numberOfConnectors
as number;
324 maxConnectors
= this._stationInfo
.Connectors
[0] ? this._getTemplateMaxNumberOfConnectors() - 1 : this._getTemplateMaxNumberOfConnectors();
326 return maxConnectors
;
329 _getNumberOfConnectors(): number {
330 return this._connectors
[0] ? Object.keys(this._connectors
).length
- 1 : Object.keys(this._connectors
).length
;
333 _getVoltageOut(): number {
334 const errMsg
= `${this._logPrefix()} Unknown ${this._getPowerOutType()} powerOutType in template file ${this._stationTemplateFile}, cannot define default voltage out`;
335 let defaultVoltageOut
: number;
336 switch (this._getPowerOutType()) {
337 case PowerOutType
.AC
:
338 defaultVoltageOut
= VoltageOut
.VOLTAGE_230
;
340 case PowerOutType
.DC
:
341 defaultVoltageOut
= VoltageOut
.VOLTAGE_400
;
344 logger
.error(errMsg
);
347 return !Utils
.isUndefined(this._stationInfo
.voltageOut
) ? this._stationInfo
.voltageOut
: defaultVoltageOut
;
350 _getTransactionIdTag(transactionId
: number): string {
351 for (const connector
in this._connectors
) {
352 if (Utils
.convertToInt(connector
) > 0 && this.getConnector(Utils
.convertToInt(connector
)).transactionId
=== transactionId
) {
353 return this.getConnector(Utils
.convertToInt(connector
)).idTag
;
358 _getTransactionMeterStop(transactionId
: number): number {
359 for (const connector
in this._connectors
) {
360 if (Utils
.convertToInt(connector
) > 0 && this.getConnector(Utils
.convertToInt(connector
)).transactionId
=== transactionId
) {
361 return this.getConnector(Utils
.convertToInt(connector
)).lastEnergyActiveImportRegisterValue
;
366 _getPowerOutType(): PowerOutType
{
367 return !Utils
.isUndefined(this._stationInfo
.powerOutType
) ? this._stationInfo
.powerOutType
: PowerOutType
.AC
;
370 _getSupervisionURL(): string {
371 const supervisionUrls
= Utils
.cloneObject
<string | string[]>(this._stationInfo
.supervisionURL
? this._stationInfo
.supervisionURL
: Configuration
.getSupervisionURLs());
373 if (!Utils
.isEmptyArray(supervisionUrls
)) {
374 if (Configuration
.getDistributeStationsToTenantsEqually()) {
375 indexUrl
= this._index
% supervisionUrls
.length
;
378 indexUrl
= Math.floor(Math.random() * supervisionUrls
.length
);
380 return supervisionUrls
[indexUrl
];
382 return supervisionUrls
as string;
385 _getReconnectExponentialDelay(): boolean {
386 return !Utils
.isUndefined(this._stationInfo
.reconnectExponentialDelay
) ? this._stationInfo
.reconnectExponentialDelay
: false;
389 _getHeartbeatInterval(): number {
390 const HeartbeatInterval
= this._getConfigurationKey(StandardParametersKey
.HeartbeatInterval
);
391 if (HeartbeatInterval
) {
392 return Utils
.convertToInt(HeartbeatInterval
.value
) * 1000;
394 const HeartBeatInterval
= this._getConfigurationKey(StandardParametersKey
.HeartBeatInterval
);
395 if (HeartBeatInterval
) {
396 return Utils
.convertToInt(HeartBeatInterval
.value
) * 1000;
400 _getAuthorizeRemoteTxRequests(): boolean {
401 const authorizeRemoteTxRequests
= this._getConfigurationKey(StandardParametersKey
.AuthorizeRemoteTxRequests
);
402 return authorizeRemoteTxRequests
? Utils
.convertToBoolean(authorizeRemoteTxRequests
.value
) : false;
405 _getLocalAuthListEnabled(): boolean {
406 const localAuthListEnabled
= this._getConfigurationKey(StandardParametersKey
.LocalAuthListEnabled
);
407 return localAuthListEnabled
? Utils
.convertToBoolean(localAuthListEnabled
.value
) : false;
410 async _startMessageSequence(): Promise
<void> {
411 // Start WebSocket ping
412 this._startWebSocketPing();
414 this._startHeartbeat();
415 // Initialize connectors status
416 for (const connector
in this._connectors
) {
417 if (Utils
.convertToInt(connector
) === 0) {
419 } else if (!this._hasStopped
&& !this.getConnector(Utils
.convertToInt(connector
))?.status && this.getConnector(Utils
.convertToInt(connector
))?.bootStatus
) {
420 // Send status in template at startup
421 await this.sendStatusNotification(Utils
.convertToInt(connector
), this.getConnector(Utils
.convertToInt(connector
)).bootStatus
);
422 } else if (this._hasStopped
&& this.getConnector(Utils
.convertToInt(connector
))?.bootStatus
) {
423 // Send status in template after reset
424 await this.sendStatusNotification(Utils
.convertToInt(connector
), this.getConnector(Utils
.convertToInt(connector
)).bootStatus
);
425 } else if (!this._hasStopped
&& this.getConnector(Utils
.convertToInt(connector
))?.status) {
426 // Send previous status at template reload
427 await this.sendStatusNotification(Utils
.convertToInt(connector
), this.getConnector(Utils
.convertToInt(connector
)).status);
429 // Send default status
430 await this.sendStatusNotification(Utils
.convertToInt(connector
), ChargePointStatus
.AVAILABLE
);
434 if (this._stationInfo
.AutomaticTransactionGenerator
.enable
) {
435 if (!this._automaticTransactionGeneration
) {
436 this._automaticTransactionGeneration
= new AutomaticTransactionGenerator(this);
438 if (this._automaticTransactionGeneration
.timeToStop
) {
439 this._automaticTransactionGeneration
.start();
442 if (this.getEnableStatistics()) {
443 this._statistics
.start();
447 async _stopMessageSequence(reason
: StopTransactionReason
= StopTransactionReason
.NONE
): Promise
<void> {
448 // Stop WebSocket ping
449 this._stopWebSocketPing();
451 this._stopHeartbeat();
453 if (this._stationInfo
.AutomaticTransactionGenerator
.enable
&&
454 this._automaticTransactionGeneration
&&
455 !this._automaticTransactionGeneration
.timeToStop
) {
456 await this._automaticTransactionGeneration
.stop(reason
);
458 for (const connector
in this._connectors
) {
459 if (Utils
.convertToInt(connector
) > 0 && this.getConnector(Utils
.convertToInt(connector
)).transactionStarted
) {
460 await this.sendStopTransaction(this.getConnector(Utils
.convertToInt(connector
)).transactionId
, reason
);
466 _startWebSocketPing(): void {
467 const webSocketPingInterval
: number = this._getConfigurationKey(StandardParametersKey
.WebSocketPingInterval
) ? Utils
.convertToInt(this._getConfigurationKey(StandardParametersKey
.WebSocketPingInterval
).value
) : 0;
468 if (webSocketPingInterval
> 0 && !this._webSocketPingSetInterval
) {
469 this._webSocketPingSetInterval
= setInterval(() => {
470 if (this._isWebSocketOpen()) {
471 this._wsConnection
.ping((): void => { });
473 }, webSocketPingInterval
* 1000);
474 logger
.info(this._logPrefix() + ' WebSocket ping started every ' + Utils
.secondsToHHMMSS(webSocketPingInterval
));
475 } else if (this._webSocketPingSetInterval
) {
476 logger
.info(this._logPrefix() + ' WebSocket ping every ' + Utils
.secondsToHHMMSS(webSocketPingInterval
) + ' already started');
478 logger
.error(`${this._logPrefix()} WebSocket ping interval set to ${webSocketPingInterval ? Utils.secondsToHHMMSS(webSocketPingInterval) : webSocketPingInterval}, not starting the WebSocket ping`);
482 _stopWebSocketPing(): void {
483 if (this._webSocketPingSetInterval
) {
484 clearInterval(this._webSocketPingSetInterval
);
485 this._webSocketPingSetInterval
= null;
489 _restartWebSocketPing(): void {
490 // Stop WebSocket ping
491 this._stopWebSocketPing();
492 // Start WebSocket ping
493 this._startWebSocketPing();
496 _startHeartbeat(): void {
497 if (this._getHeartbeatInterval() && this._getHeartbeatInterval() > 0 && !this._heartbeatSetInterval
) {
498 this._heartbeatSetInterval
= setInterval(async () => {
499 await this.sendHeartbeat();
500 }, this._getHeartbeatInterval());
501 logger
.info(this._logPrefix() + ' Heartbeat started every ' + Utils
.milliSecondsToHHMMSS(this._getHeartbeatInterval()));
502 } else if (this._heartbeatSetInterval
) {
503 logger
.info(this._logPrefix() + ' Heartbeat every ' + Utils
.milliSecondsToHHMMSS(this._getHeartbeatInterval()) + ' already started');
505 logger
.error(`${this._logPrefix()} Heartbeat interval set to ${this._getHeartbeatInterval() ? Utils.milliSecondsToHHMMSS(this._getHeartbeatInterval()) : this._getHeartbeatInterval()}, not starting the heartbeat`);
509 _stopHeartbeat(): void {
510 if (this._heartbeatSetInterval
) {
511 clearInterval(this._heartbeatSetInterval
);
512 this._heartbeatSetInterval
= null;
516 _restartHeartbeat(): void {
518 this._stopHeartbeat();
520 this._startHeartbeat();
523 _startAuthorizationFileMonitoring(): void {
524 // eslint-disable-next-line @typescript-eslint/no-unused-vars
525 fs
.watchFile(this._getAuthorizationFile(), (current
, previous
) => {
527 logger
.debug(this._logPrefix() + ' Authorization file ' + this._getAuthorizationFile() + ' have changed, reload');
528 // Initialize _authorizedTags
529 this._authorizedTags
= this._loadAndGetAuthorizedTags();
531 logger
.error(this._logPrefix() + ' Authorization file monitoring error: %j', error
);
536 _startStationTemplateFileMonitoring(): void {
537 // eslint-disable-next-line @typescript-eslint/no-unused-vars
538 fs
.watchFile(this._stationTemplateFile
, (current
, previous
) => {
540 logger
.debug(this._logPrefix() + ' Template file ' + this._stationTemplateFile
+ ' have changed, reload');
543 if (!this._stationInfo
.AutomaticTransactionGenerator
.enable
&&
544 this._automaticTransactionGeneration
) {
545 this._automaticTransactionGeneration
.stop().catch(() => { });
547 // FIXME?: restart heartbeat and WebSocket ping when their interval values have changed
549 logger
.error(this._logPrefix() + ' Charging station template file monitoring error: %j', error
);
554 _startMeterValues(connectorId
: number, interval
: number): void {
555 if (connectorId
=== 0) {
556 logger
.error(`${this._logPrefix()} Trying to start MeterValues on connector Id ${connectorId.toString()}`);
559 if (!this.getConnector(connectorId
)) {
560 logger
.error(`${this._logPrefix()} Trying to start MeterValues on non existing connector Id ${connectorId.toString()}`);
563 if (!this.getConnector(connectorId
)?.transactionStarted
) {
564 logger
.error(`${this._logPrefix()} Trying to start MeterValues on connector Id ${connectorId} with no transaction started`);
566 } else if (this.getConnector(connectorId
)?.transactionStarted
&& !this.getConnector(connectorId
)?.transactionId
) {
567 logger
.error(`${this._logPrefix()} Trying to start MeterValues on connector Id ${connectorId} with no transaction id`);
571 this.getConnector(connectorId
).transactionSetInterval
= setInterval(async () => {
572 if (this.getEnableStatistics()) {
573 const sendMeterValues
= performance
.timerify(this.sendMeterValues
);
574 this._performanceObserver
.observe({
575 entryTypes
: ['function'],
577 await sendMeterValues(connectorId
, interval
, this);
579 await this.sendMeterValues(connectorId
, interval
, this);
583 logger
.error(`${this._logPrefix()} Charging station ${StandardParametersKey.MeterValueSampleInterval} configuration set to ${Utils.milliSecondsToHHMMSS(interval)}, not sending MeterValues`);
587 _openWSConnection(options
?: WebSocket
.ClientOptions
, forceCloseOpened
= false): void {
588 if (Utils
.isUndefined(options
)) {
589 options
= {} as WebSocket
.ClientOptions
;
591 if (Utils
.isUndefined(options
.handshakeTimeout
)) {
592 options
.handshakeTimeout
= this._getConnectionTimeout() * 1000;
594 if (this._isWebSocketOpen() && forceCloseOpened
) {
595 this._wsConnection
.close();
597 this._wsConnection
= new WebSocket(this._wsConnectionUrl
, 'ocpp' + Constants
.OCPP_VERSION_16
, options
);
598 logger
.info(this._logPrefix() + ' Will communicate through URL ' + this._supervisionUrl
);
602 this._openWSConnection();
603 // Monitor authorization file
604 this._startAuthorizationFileMonitoring();
605 // Monitor station template file
606 this._startStationTemplateFileMonitoring();
607 // Handle Socket incoming messages
608 this._wsConnection
.on('message', this.onMessage
.bind(this));
609 // Handle Socket error
610 this._wsConnection
.on('error', this.onError
.bind(this));
611 // Handle Socket close
612 this._wsConnection
.on('close', this.onClose
.bind(this));
613 // Handle Socket opening connection
614 this._wsConnection
.on('open', this.onOpen
.bind(this));
615 // Handle Socket ping
616 this._wsConnection
.on('ping', this.onPing
.bind(this));
617 // Handle Socket pong
618 this._wsConnection
.on('pong', this.onPong
.bind(this));
621 async stop(reason
: StopTransactionReason
= StopTransactionReason
.NONE
): Promise
<void> {
622 // Stop message sequence
623 await this._stopMessageSequence(reason
);
624 for (const connector
in this._connectors
) {
625 if (Utils
.convertToInt(connector
) > 0) {
626 await this.sendStatusNotification(Utils
.convertToInt(connector
), ChargePointStatus
.UNAVAILABLE
);
629 if (this._isWebSocketOpen()) {
630 this._wsConnection
.close();
632 this._bootNotificationResponse
= null;
633 this._hasStopped
= true;
636 async _reconnect(error
): Promise
<void> {
638 this._stopHeartbeat();
639 // Stop the ATG if needed
640 if (this._stationInfo
.AutomaticTransactionGenerator
.enable
&&
641 this._stationInfo
.AutomaticTransactionGenerator
.stopOnConnectionFailure
&&
642 this._automaticTransactionGeneration
&&
643 !this._automaticTransactionGeneration
.timeToStop
) {
644 this._automaticTransactionGeneration
.stop().catch(() => { });
646 if (this._autoReconnectRetryCount
< this._getAutoReconnectMaxRetries() || this._getAutoReconnectMaxRetries() === -1) {
647 this._autoReconnectRetryCount
++;
648 const reconnectDelay
= (this._getReconnectExponentialDelay() ? Utils
.exponentialDelay(this._autoReconnectRetryCount
) : this._getConnectionTimeout() * 1000);
649 logger
.error(`${this._logPrefix()} Socket: connection retry in ${Utils.roundTo(reconnectDelay, 2)}ms, timeout ${reconnectDelay - 100}ms`);
650 await Utils
.sleep(reconnectDelay
);
651 logger
.error(this._logPrefix() + ' Socket: reconnecting try #' + this._autoReconnectRetryCount
.toString());
652 this._openWSConnection({ handshakeTimeout
: reconnectDelay
- 100 });
653 this._hasSocketRestarted
= true;
654 } else if (this._getAutoReconnectMaxRetries() !== -1) {
655 logger
.error(`${this._logPrefix()} Socket reconnect failure: max retries reached (${this._autoReconnectRetryCount}) or retry disabled (${this._getAutoReconnectMaxRetries()})`);
659 async onOpen(): Promise
<void> {
660 logger
.info(`${this._logPrefix()} Is connected to server through ${this._wsConnectionUrl}`);
661 if (!this._isRegistered()) {
662 // Send BootNotification
663 let registrationRetryCount
= 0;
665 this._bootNotificationResponse
= await this.sendBootNotification();
666 if (!this._isRegistered()) {
667 registrationRetryCount
++;
668 await Utils
.sleep(this._bootNotificationResponse
?.interval
? this._bootNotificationResponse
.interval
* 1000 : Constants
.OCPP_DEFAULT_BOOT_NOTIFICATION_INTERVAL
);
670 } while (!this._isRegistered() && (registrationRetryCount
<= this._getRegistrationMaxRetries() || this._getRegistrationMaxRetries() === -1));
672 if (this._isRegistered()) {
673 await this._startMessageSequence();
674 if (this._hasSocketRestarted
&& this._isWebSocketOpen()) {
675 if (!Utils
.isEmptyArray(this._messageQueue
)) {
676 this._messageQueue
.forEach((message
, index
) => {
677 this._messageQueue
.splice(index
, 1);
678 this._wsConnection
.send(message
);
683 logger
.error(`${this._logPrefix()} Registration failure: max retries reached (${this._getRegistrationMaxRetries()}) or retry disabled (${this._getRegistrationMaxRetries()})`);
685 this._autoReconnectRetryCount
= 0;
686 this._hasSocketRestarted
= false;
689 async onError(errorEvent
): Promise
<void> {
690 logger
.error(this._logPrefix() + ' Socket error: %j', errorEvent
);
691 // pragma switch (errorEvent.code) {
692 // case 'ECONNREFUSED':
693 // await this._reconnect(errorEvent);
698 async onClose(closeEvent
): Promise
<void> {
699 switch (closeEvent
) {
700 case WebSocketCloseEventStatusCode
.CLOSE_NORMAL
: // Normal close
701 case WebSocketCloseEventStatusCode
.CLOSE_NO_STATUS
:
702 logger
.info(`${this._logPrefix()} Socket normally closed with status '${Utils.getWebSocketCloseEventStatusString(closeEvent)}'`);
703 this._autoReconnectRetryCount
= 0;
705 default: // Abnormal close
706 logger
.error(`${this._logPrefix()} Socket abnormally closed with status '${Utils.getWebSocketCloseEventStatusString(closeEvent)}'`);
707 await this._reconnect(closeEvent
);
713 logger
.debug(this._logPrefix() + ' Has received a WS ping (rfc6455) from the server');
717 logger
.debug(this._logPrefix() + ' Has received a WS pong (rfc6455) from the server');
720 async onMessage(messageEvent
: MessageEvent
): Promise
<void> {
721 let [messageType
, messageId
, commandName
, commandPayload
, errorDetails
]: IncomingRequest
= [0, '', '' as IncomingRequestCommand
, {}, {}];
722 let responseCallback
: (payload
?: Record
<string, unknown
> | string, requestPayload
?: Record
<string, unknown
>) => void;
723 let rejectCallback
: (error
: OCPPError
) => void;
724 let requestPayload
: Record
<string, unknown
>;
728 [messageType
, messageId
, commandName
, commandPayload
, errorDetails
] = JSON
.parse(messageEvent
.toString()) as IncomingRequest
;
730 // Check the Type of message
731 switch (messageType
) {
733 case MessageType
.CALL_MESSAGE
:
734 if (this.getEnableStatistics()) {
735 this._statistics
.addMessage(commandName
, messageType
);
738 await this.handleRequest(messageId
, commandName
, commandPayload
);
741 case MessageType
.CALL_RESULT_MESSAGE
:
743 if (Utils
.isIterable(this._requests
[messageId
])) {
744 [responseCallback
, , requestPayload
] = this._requests
[messageId
];
746 throw new Error(`Response request for message id ${messageId} is not iterable`);
748 if (!responseCallback
) {
750 throw new Error(`Response request for unknown message id ${messageId}`);
752 delete this._requests
[messageId
];
753 responseCallback(commandName
, requestPayload
);
756 case MessageType
.CALL_ERROR_MESSAGE
:
757 if (!this._requests
[messageId
]) {
759 throw new Error(`Error request for unknown message id ${messageId}`);
761 if (Utils
.isIterable(this._requests
[messageId
])) {
762 [, rejectCallback
] = this._requests
[messageId
];
764 throw new Error(`Error request for message id ${messageId} is not iterable`);
766 delete this._requests
[messageId
];
767 rejectCallback(new OCPPError(commandName
, commandPayload
.toString(), errorDetails
));
771 errMsg
= `${this._logPrefix()} Wrong message type ${messageType}`;
772 logger
.error(errMsg
);
773 throw new Error(errMsg
);
777 logger
.error('%s Incoming message %j processing error %j on request content type %j', this._logPrefix(), messageEvent
, error
, this._requests
[messageId
]);
779 messageType
!== MessageType
.CALL_ERROR_MESSAGE
&& await this.sendError(messageId
, error
, commandName
);
783 async sendHeartbeat(): Promise
<void> {
785 const payload
: HeartbeatRequest
= {};
786 await this.sendMessage(Utils
.generateUUID(), payload
, MessageType
.CALL_MESSAGE
, RequestCommand
.HEARTBEAT
);
788 this.handleRequestError(RequestCommand
.HEARTBEAT
, error
);
792 async sendBootNotification(): Promise
<BootNotificationResponse
> {
794 return await this.sendMessage(Utils
.generateUUID(), this._bootNotificationRequest
, MessageType
.CALL_MESSAGE
, RequestCommand
.BOOT_NOTIFICATION
) as BootNotificationResponse
;
796 this.handleRequestError(RequestCommand
.BOOT_NOTIFICATION
, error
);
800 async sendStatusNotification(connectorId
: number, status: ChargePointStatus
, errorCode
: ChargePointErrorCode
= ChargePointErrorCode
.NO_ERROR
): Promise
<void> {
801 this.getConnector(connectorId
).status = status;
803 const payload
: StatusNotificationRequest
= {
808 await this.sendMessage(Utils
.generateUUID(), payload
, MessageType
.CALL_MESSAGE
, RequestCommand
.STATUS_NOTIFICATION
);
810 this.handleRequestError(RequestCommand
.STATUS_NOTIFICATION
, error
);
814 async sendStartTransaction(connectorId
: number, idTag
?: string): Promise
<StartTransactionResponse
> {
816 const payload
: StartTransactionRequest
= {
818 ...!Utils
.isUndefined(idTag
) ? { idTag
} : { idTag
: Constants
.TRANSACTION_DEFAULT_IDTAG
},
820 timestamp
: new Date().toISOString(),
822 return await this.sendMessage(Utils
.generateUUID(), payload
, MessageType
.CALL_MESSAGE
, RequestCommand
.START_TRANSACTION
) as StartTransactionResponse
;
824 this.handleRequestError(RequestCommand
.START_TRANSACTION
, error
);
828 async sendStopTransaction(transactionId
: number, reason
: StopTransactionReason
= StopTransactionReason
.NONE
): Promise
<StopTransactionResponse
> {
829 const idTag
= this._getTransactionIdTag(transactionId
);
831 const payload
: StopTransactionRequest
= {
833 ...!Utils
.isUndefined(idTag
) && { idTag
: idTag
},
834 meterStop
: this._getTransactionMeterStop(transactionId
),
835 timestamp
: new Date().toISOString(),
836 ...reason
&& { reason
},
838 return await this.sendMessage(Utils
.generateUUID(), payload
, MessageType
.CALL_MESSAGE
, RequestCommand
.STOP_TRANSACTION
) as StartTransactionResponse
;
840 this.handleRequestError(RequestCommand
.STOP_TRANSACTION
, error
);
844 async sendError(messageId
: string, error
: OCPPError
, commandName
: RequestCommand
| IncomingRequestCommand
): Promise
<unknown
> {
846 return this.sendMessage(messageId
, error
, MessageType
.CALL_ERROR_MESSAGE
, commandName
);
849 async sendMessage(messageId
: string, commandParams
: any, messageType
: MessageType
= MessageType
.CALL_RESULT_MESSAGE
, commandName
: RequestCommand
| IncomingRequestCommand
): Promise
<any> {
850 // eslint-disable-next-line @typescript-eslint/no-this-alias
852 // Send a message through wsConnection
853 return new Promise((resolve
: (value
?: any | PromiseLike
<any>) => void, reject
: (reason
?: any) => void) => {
854 let messageToSend
: string;
856 switch (messageType
) {
858 case MessageType
.CALL_MESSAGE
:
860 this._requests
[messageId
] = [responseCallback
, rejectCallback
, commandParams
] as Request
;
861 messageToSend
= JSON
.stringify([messageType
, messageId
, commandName
, commandParams
]);
864 case MessageType
.CALL_RESULT_MESSAGE
:
866 messageToSend
= JSON
.stringify([messageType
, messageId
, commandParams
]);
869 case MessageType
.CALL_ERROR_MESSAGE
:
870 // Build Error Message
871 messageToSend
= JSON
.stringify([messageType
, messageId
, commandParams
.code
? commandParams
.code
: ErrorType
.GENERIC_ERROR
, commandParams
.message
? commandParams
.message
: '', commandParams
.details
? commandParams
.details
: {}]);
874 // Check if wsConnection opened and charging station registered
875 if (this._isWebSocketOpen() && (this._isRegistered() || commandName
=== RequestCommand
.BOOT_NOTIFICATION
)) {
876 if (this.getEnableStatistics()) {
877 this._statistics
.addMessage(commandName
, messageType
);
880 this._wsConnection
.send(messageToSend
);
881 } else if (commandName
!== RequestCommand
.BOOT_NOTIFICATION
) {
883 // Handle dups in buffer
884 for (const message
of this._messageQueue
) {
886 if (messageToSend
=== message
) {
893 this._messageQueue
.push(messageToSend
);
896 return rejectCallback(new OCPPError(commandParams
.code
? commandParams
.code
: ErrorType
.GENERIC_ERROR
, commandParams
.message
? commandParams
.message
: `WebSocket closed for message id '${messageId}' with content '${messageToSend}', message buffered`, commandParams
.details
? commandParams
.details
: {}));
899 if (messageType
=== MessageType
.CALL_RESULT_MESSAGE
) {
902 } else if (messageType
=== MessageType
.CALL_ERROR_MESSAGE
) {
904 setTimeout(() => rejectCallback(new OCPPError(commandParams
.code
? commandParams
.code
: ErrorType
.GENERIC_ERROR
, commandParams
.message
? commandParams
.message
: `Timeout for message id '${messageId}' with content '${messageToSend}'`, commandParams
.details
? commandParams
.details
: {})), Constants
.OCPP_ERROR_TIMEOUT
);
907 // Function that will receive the request's response
908 async function responseCallback(payload
: Record
<string, unknown
> | string, requestPayload
: Record
<string, unknown
>): Promise
<void> {
909 if (self.getEnableStatistics()) {
910 self._statistics
.addMessage(commandName
, messageType
);
913 await self.handleResponse(commandName
as RequestCommand
, payload
, requestPayload
);
917 // Function that will receive the request's rejection
918 function rejectCallback(error
: OCPPError
): void {
919 if (self.getEnableStatistics()) {
920 self._statistics
.addMessage(commandName
, messageType
);
922 logger
.debug(`${self._logPrefix()} Error: %j occurred when calling command %s with parameters: %j`, error
, commandName
, commandParams
);
924 // eslint-disable-next-line no-empty-function
925 self._requests
[messageId
] = [() => { }, () => { }, {}]; // Properly format the request
932 async handleResponse(commandName
: RequestCommand
, payload
: Record
<string, unknown
> | string, requestPayload
: Record
<string, unknown
>): Promise
<void> {
933 const responseCallbackFn
= 'handleResponse' + commandName
;
934 if (typeof this[responseCallbackFn
] === 'function') {
935 await this[responseCallbackFn
](payload
, requestPayload
);
937 logger
.error(this._logPrefix() + ' Trying to call an undefined response callback function: ' + responseCallbackFn
);
941 handleResponseBootNotification(payload
: BootNotificationResponse
, requestPayload
: BootNotificationRequest
): void {
942 if (payload
.status === RegistrationStatus
.ACCEPTED
) {
943 this._heartbeatSetInterval
? this._restartHeartbeat() : this._startHeartbeat();
944 this._addConfigurationKey(StandardParametersKey
.HeartBeatInterval
, payload
.interval
.toString());
945 this._addConfigurationKey(StandardParametersKey
.HeartbeatInterval
, payload
.interval
.toString(), false, false);
946 this._hasStopped
&& (this._hasStopped
= false);
947 } else if (payload
.status === RegistrationStatus
.PENDING
) {
948 logger
.info(this._logPrefix() + ' Charging station in pending state on the central server');
950 logger
.info(this._logPrefix() + ' Charging station rejected by the central server');
954 _initTransactionOnConnector(connectorId
: number): void {
955 this.getConnector(connectorId
).transactionStarted
= false;
956 this.getConnector(connectorId
).transactionId
= null;
957 this.getConnector(connectorId
).idTag
= null;
958 this.getConnector(connectorId
).lastEnergyActiveImportRegisterValue
= -1;
961 _resetTransactionOnConnector(connectorId
: number): void {
962 this._initTransactionOnConnector(connectorId
);
963 if (this.getConnector(connectorId
)?.transactionSetInterval
) {
964 clearInterval(this.getConnector(connectorId
).transactionSetInterval
);
968 async handleResponseStartTransaction(payload
: StartTransactionResponse
, requestPayload
: StartTransactionRequest
): Promise
<void> {
969 const connectorId
= requestPayload
.connectorId
;
971 let transactionConnectorId
: number;
972 for (const connector
in this._connectors
) {
973 if (Utils
.convertToInt(connector
) > 0 && Utils
.convertToInt(connector
) === connectorId
) {
974 transactionConnectorId
= Utils
.convertToInt(connector
);
978 if (!transactionConnectorId
) {
979 logger
.error(this._logPrefix() + ' Trying to start a transaction on a non existing connector Id ' + connectorId
.toString());
982 if (this.getConnector(connectorId
)?.transactionStarted
) {
983 logger
.debug(this._logPrefix() + ' Trying to start a transaction on an already used connector ' + connectorId
.toString() + ': %j', this.getConnector(connectorId
));
987 if (payload
.idTagInfo
.status === AuthorizationStatus
.ACCEPTED
) {
988 this.getConnector(connectorId
).transactionStarted
= true;
989 this.getConnector(connectorId
).transactionId
= payload
.transactionId
;
990 this.getConnector(connectorId
).idTag
= requestPayload
.idTag
;
991 this.getConnector(connectorId
).lastEnergyActiveImportRegisterValue
= 0;
992 await this.sendStatusNotification(connectorId
, ChargePointStatus
.CHARGING
);
993 logger
.info(this._logPrefix() + ' Transaction ' + payload
.transactionId
.toString() + ' STARTED on ' + this._stationInfo
.name
+ '#' + connectorId
.toString() + ' for idTag ' + requestPayload
.idTag
);
994 if (this._stationInfo
.powerSharedByConnectors
) {
995 this._stationInfo
.powerDivider
++;
997 const configuredMeterValueSampleInterval
= this._getConfigurationKey(StandardParametersKey
.MeterValueSampleInterval
);
998 this._startMeterValues(connectorId
,
999 configuredMeterValueSampleInterval
? Utils
.convertToInt(configuredMeterValueSampleInterval
.value
) * 1000 : 60000);
1001 logger
.error(this._logPrefix() + ' Starting transaction id ' + payload
.transactionId
.toString() + ' REJECTED with status ' + payload
.idTagInfo
.status + ', idTag ' + requestPayload
.idTag
);
1002 this._resetTransactionOnConnector(connectorId
);
1003 await this.sendStatusNotification(connectorId
, ChargePointStatus
.AVAILABLE
);
1007 async handleResponseStopTransaction(payload
: StopTransactionResponse
, requestPayload
: StopTransactionRequest
): Promise
<void> {
1008 let transactionConnectorId
: number;
1009 for (const connector
in this._connectors
) {
1010 if (Utils
.convertToInt(connector
) > 0 && this.getConnector(Utils
.convertToInt(connector
))?.transactionId
=== requestPayload
.transactionId
) {
1011 transactionConnectorId
= Utils
.convertToInt(connector
);
1015 if (!transactionConnectorId
) {
1016 logger
.error(this._logPrefix() + ' Trying to stop a non existing transaction ' + requestPayload
.transactionId
.toString());
1019 if (payload
.idTagInfo
?.status === AuthorizationStatus
.ACCEPTED
) {
1020 if (!this._isChargingStationAvailable() || !this._isConnectorAvailable(transactionConnectorId
)) {
1021 await this.sendStatusNotification(transactionConnectorId
, ChargePointStatus
.UNAVAILABLE
);
1023 await this.sendStatusNotification(transactionConnectorId
, ChargePointStatus
.AVAILABLE
);
1025 if (this._stationInfo
.powerSharedByConnectors
) {
1026 this._stationInfo
.powerDivider
--;
1028 logger
.info(this._logPrefix() + ' Transaction ' + requestPayload
.transactionId
.toString() + ' STOPPED on ' + this._stationInfo
.name
+ '#' + transactionConnectorId
.toString());
1029 this._resetTransactionOnConnector(transactionConnectorId
);
1031 logger
.error(this._logPrefix() + ' Stopping transaction id ' + requestPayload
.transactionId
.toString() + ' REJECTED with status ' + payload
.idTagInfo
?.status);
1035 handleResponseStatusNotification(payload
: StatusNotificationRequest
, requestPayload
: StatusNotificationResponse
): void {
1036 logger
.debug(this._logPrefix() + ' Status notification response received: %j to StatusNotification request: %j', payload
, requestPayload
);
1039 handleResponseMeterValues(payload
: MeterValuesRequest
, requestPayload
: MeterValuesResponse
): void {
1040 logger
.debug(this._logPrefix() + ' MeterValues response received: %j to MeterValues request: %j', payload
, requestPayload
);
1043 handleResponseHeartbeat(payload
: HeartbeatResponse
, requestPayload
: HeartbeatRequest
): void {
1044 logger
.debug(this._logPrefix() + ' Heartbeat response received: %j to Heartbeat request: %j', payload
, requestPayload
);
1047 async handleRequest(messageId
: string, commandName
: IncomingRequestCommand
, commandPayload
: Record
<string, unknown
>): Promise
<void> {
1050 if (typeof this['handleRequest' + commandName
] === 'function') {
1052 // Call the method to build the response
1053 response
= await this['handleRequest' + commandName
](commandPayload
);
1056 logger
.error(this._logPrefix() + ' Handle request error: %j', error
);
1057 // Send back response to inform backend
1058 await this.sendError(messageId
, error
, commandName
);
1063 await this.sendError(messageId
, new OCPPError(ErrorType
.NOT_IMPLEMENTED
, `${commandName} is not implemented`, {}), commandName
);
1064 throw new Error(`${commandName} is not implemented ${JSON.stringify(commandPayload, null, ' ')}`);
1067 await this.sendMessage(messageId
, response
, MessageType
.CALL_RESULT_MESSAGE
, commandName
);
1070 // Simulate charging station restart
1071 handleRequestReset(commandPayload
: ResetRequest
): DefaultResponse
{
1072 setImmediate(async () => {
1073 await this.stop(commandPayload
.type + 'Reset' as StopTransactionReason
);
1074 await Utils
.sleep(this._stationInfo
.resetTime
);
1077 logger
.info(`${this._logPrefix()} ${commandPayload.type} reset command received, simulating it. The station will be back online in ${Utils.milliSecondsToHHMMSS(this._stationInfo.resetTime)}`);
1078 return Constants
.OCPP_RESPONSE_ACCEPTED
;
1081 handleRequestClearCache(): DefaultResponse
{
1082 return Constants
.OCPP_RESPONSE_ACCEPTED
;
1085 async handleRequestUnlockConnector(commandPayload
: UnlockConnectorRequest
): Promise
<UnlockConnectorResponse
> {
1086 const connectorId
= commandPayload
.connectorId
;
1087 if (connectorId
=== 0) {
1088 logger
.error(this._logPrefix() + ' Trying to unlock connector ' + connectorId
.toString());
1089 return Constants
.OCPP_RESPONSE_UNLOCK_NOT_SUPPORTED
;
1091 if (this.getConnector(connectorId
)?.transactionStarted
) {
1092 const stopResponse
= await this.sendStopTransaction(this.getConnector(connectorId
).transactionId
, StopTransactionReason
.UNLOCK_COMMAND
);
1093 if (stopResponse
.idTagInfo
?.status === AuthorizationStatus
.ACCEPTED
) {
1094 return Constants
.OCPP_RESPONSE_UNLOCKED
;
1096 return Constants
.OCPP_RESPONSE_UNLOCK_FAILED
;
1098 await this.sendStatusNotification(connectorId
, ChargePointStatus
.AVAILABLE
);
1099 return Constants
.OCPP_RESPONSE_UNLOCKED
;
1102 _getConfigurationKey(key
: string | StandardParametersKey
, caseInsensitive
= false): ConfigurationKey
{
1103 const configurationKey
: ConfigurationKey
= this._configuration
.configurationKey
.find((configElement
) => {
1104 if (caseInsensitive
) {
1105 return configElement
.key
.toLowerCase() === key
.toLowerCase();
1107 return configElement
.key
=== key
;
1109 return configurationKey
;
1112 _addConfigurationKey(key
: string | StandardParametersKey
, value
: string, readonly = false, visible
= true, reboot
= false): void {
1113 const keyFound
= this._getConfigurationKey(key
);
1115 this._configuration
.configurationKey
.push({
1123 logger
.error(`${this._logPrefix()} Trying to add an already existing configuration key: %j`, keyFound
);
1127 _setConfigurationKeyValue(key
: string | StandardParametersKey
, value
: string): void {
1128 const keyFound
= this._getConfigurationKey(key
);
1130 const keyIndex
= this._configuration
.configurationKey
.indexOf(keyFound
);
1131 this._configuration
.configurationKey
[keyIndex
].value
= value
;
1133 logger
.error(`${this._logPrefix()} Trying to set a value on a non existing configuration key: %j`, { key
, value
});
1137 handleRequestGetConfiguration(commandPayload
: GetConfigurationRequest
): GetConfigurationResponse
{
1138 const configurationKey
: OCPPConfigurationKey
[] = [];
1139 const unknownKey
: string[] = [];
1140 if (Utils
.isEmptyArray(commandPayload
.key
)) {
1141 for (const configuration
of this._configuration
.configurationKey
) {
1142 if (Utils
.isUndefined(configuration
.visible
)) {
1143 configuration
.visible
= true;
1145 if (!configuration
.visible
) {
1148 configurationKey
.push({
1149 key
: configuration
.key
,
1150 readonly: configuration
.readonly,
1151 value
: configuration
.value
,
1155 for (const key
of commandPayload
.key
) {
1156 const keyFound
= this._getConfigurationKey(key
);
1158 if (Utils
.isUndefined(keyFound
.visible
)) {
1159 keyFound
.visible
= true;
1161 if (!keyFound
.visible
) {
1164 configurationKey
.push({
1166 readonly: keyFound
.readonly,
1167 value
: keyFound
.value
,
1170 unknownKey
.push(key
);
1180 handleRequestChangeConfiguration(commandPayload
: ChangeConfigurationRequest
): ChangeConfigurationResponse
{
1181 // JSON request fields type sanity check
1182 if (!Utils
.isString(commandPayload
.key
)) {
1183 logger
.error(`${this._logPrefix()} ChangeConfiguration request key field is not a string:`, commandPayload
);
1185 if (!Utils
.isString(commandPayload
.value
)) {
1186 logger
.error(`${this._logPrefix()} ChangeConfiguration request value field is not a string:`, commandPayload
);
1188 const keyToChange
= this._getConfigurationKey(commandPayload
.key
, true);
1190 return Constants
.OCPP_CONFIGURATION_RESPONSE_NOT_SUPPORTED
;
1191 } else if (keyToChange
&& keyToChange
.readonly) {
1192 return Constants
.OCPP_CONFIGURATION_RESPONSE_REJECTED
;
1193 } else if (keyToChange
&& !keyToChange
.readonly) {
1194 const keyIndex
= this._configuration
.configurationKey
.indexOf(keyToChange
);
1195 let valueChanged
= false;
1196 if (this._configuration
.configurationKey
[keyIndex
].value
!== commandPayload
.value
) {
1197 this._configuration
.configurationKey
[keyIndex
].value
= commandPayload
.value
;
1198 valueChanged
= true;
1200 let triggerHeartbeatRestart
= false;
1201 if (keyToChange
.key
=== StandardParametersKey
.HeartBeatInterval
&& valueChanged
) {
1202 this._setConfigurationKeyValue(StandardParametersKey
.HeartbeatInterval
, commandPayload
.value
);
1203 triggerHeartbeatRestart
= true;
1205 if (keyToChange
.key
=== StandardParametersKey
.HeartbeatInterval
&& valueChanged
) {
1206 this._setConfigurationKeyValue(StandardParametersKey
.HeartBeatInterval
, commandPayload
.value
);
1207 triggerHeartbeatRestart
= true;
1209 if (triggerHeartbeatRestart
) {
1210 this._restartHeartbeat();
1212 if (keyToChange
.key
=== StandardParametersKey
.WebSocketPingInterval
&& valueChanged
) {
1213 this._restartWebSocketPing();
1215 if (keyToChange
.reboot
) {
1216 return Constants
.OCPP_CONFIGURATION_RESPONSE_REBOOT_REQUIRED
;
1218 return Constants
.OCPP_CONFIGURATION_RESPONSE_ACCEPTED
;
1222 handleRequestSetChargingProfile(commandPayload
: SetChargingProfileRequest
): SetChargingProfileResponse
{
1223 if (!this.getConnector(commandPayload
.connectorId
)) {
1224 logger
.error(`${this._logPrefix()} Trying to set a charging profile to a non existing connector Id ${commandPayload.connectorId}`);
1225 return Constants
.OCPP_CHARGING_PROFILE_RESPONSE_REJECTED
;
1227 if (commandPayload
.csChargingProfiles
.chargingProfilePurpose
=== ChargingProfilePurposeType
.TX_PROFILE
&& !this.getConnector(commandPayload
.connectorId
)?.transactionStarted
) {
1228 return Constants
.OCPP_CHARGING_PROFILE_RESPONSE_REJECTED
;
1230 this.getConnector(commandPayload
.connectorId
).chargingProfiles
.forEach((chargingProfile
: ChargingProfile
, index
: number) => {
1231 if (chargingProfile
.chargingProfileId
=== commandPayload
.csChargingProfiles
.chargingProfileId
1232 || (chargingProfile
.stackLevel
=== commandPayload
.csChargingProfiles
.stackLevel
&& chargingProfile
.chargingProfilePurpose
=== commandPayload
.csChargingProfiles
.chargingProfilePurpose
)) {
1233 this.getConnector(commandPayload
.connectorId
).chargingProfiles
[index
] = chargingProfile
;
1234 return Constants
.OCPP_CHARGING_PROFILE_RESPONSE_ACCEPTED
;
1237 this.getConnector(commandPayload
.connectorId
).chargingProfiles
.push(commandPayload
.csChargingProfiles
);
1238 return Constants
.OCPP_CHARGING_PROFILE_RESPONSE_ACCEPTED
;
1241 handleRequestChangeAvailability(commandPayload
: ChangeAvailabilityRequest
): ChangeAvailabilityResponse
{
1242 const connectorId
: number = commandPayload
.connectorId
;
1243 if (!this.getConnector(connectorId
)) {
1244 logger
.error(`${this._logPrefix()} Trying to change the availability of a non existing connector Id ${connectorId.toString()}`);
1245 return Constants
.OCPP_AVAILABILITY_RESPONSE_REJECTED
;
1247 const chargePointStatus
: ChargePointStatus
= commandPayload
.type === AvailabilityType
.OPERATIVE
? ChargePointStatus
.AVAILABLE
: ChargePointStatus
.UNAVAILABLE
;
1248 if (connectorId
=== 0) {
1249 let response
: ChangeAvailabilityResponse
= Constants
.OCPP_AVAILABILITY_RESPONSE_ACCEPTED
;
1250 for (const connector
in this._connectors
) {
1251 if (this.getConnector(Utils
.convertToInt(connector
)).transactionStarted
) {
1252 response
= Constants
.OCPP_AVAILABILITY_RESPONSE_SCHEDULED
;
1254 this.getConnector(Utils
.convertToInt(connector
)).availability
= commandPayload
.type;
1255 response
=== Constants
.OCPP_AVAILABILITY_RESPONSE_ACCEPTED
&& this.sendStatusNotification(Utils
.convertToInt(connector
), chargePointStatus
);
1258 } else if (connectorId
> 0 && (this.getConnector(0).availability
=== AvailabilityType
.OPERATIVE
|| (this.getConnector(0).availability
=== AvailabilityType
.INOPERATIVE
&& commandPayload
.type === AvailabilityType
.INOPERATIVE
))) {
1259 if (this.getConnector(connectorId
)?.transactionStarted
) {
1260 this.getConnector(connectorId
).availability
= commandPayload
.type;
1261 return Constants
.OCPP_AVAILABILITY_RESPONSE_SCHEDULED
;
1263 this.getConnector(connectorId
).availability
= commandPayload
.type;
1264 void this.sendStatusNotification(connectorId
, chargePointStatus
);
1265 return Constants
.OCPP_AVAILABILITY_RESPONSE_ACCEPTED
;
1267 return Constants
.OCPP_AVAILABILITY_RESPONSE_REJECTED
;
1270 async handleRequestRemoteStartTransaction(commandPayload
: RemoteStartTransactionRequest
): Promise
<DefaultResponse
> {
1271 const transactionConnectorID
: number = commandPayload
.connectorId
? commandPayload
.connectorId
: 1;
1272 if (this._isChargingStationAvailable() && this._isConnectorAvailable(transactionConnectorID
)) {
1273 if (this._getAuthorizeRemoteTxRequests() && this._getLocalAuthListEnabled() && this.hasAuthorizedTags()) {
1274 // Check if authorized
1275 if (this._authorizedTags
.find((value
) => value
=== commandPayload
.idTag
)) {
1276 await this.sendStatusNotification(transactionConnectorID
, ChargePointStatus
.PREPARING
);
1277 // Authorization successful start transaction
1278 await this.sendStartTransaction(transactionConnectorID
, commandPayload
.idTag
);
1279 logger
.debug(this._logPrefix() + ' Transaction remotely STARTED on ' + this._stationInfo
.name
+ '#' + transactionConnectorID
.toString() + ' for idTag ' + commandPayload
.idTag
);
1280 return Constants
.OCPP_RESPONSE_ACCEPTED
;
1282 logger
.error(this._logPrefix() + ' Remote starting transaction REJECTED on connector Id ' + transactionConnectorID
.toString() + ', idTag ' + commandPayload
.idTag
);
1283 return Constants
.OCPP_RESPONSE_REJECTED
;
1285 await this.sendStatusNotification(transactionConnectorID
, ChargePointStatus
.PREPARING
);
1286 // No local authorization check required => start transaction
1287 await this.sendStartTransaction(transactionConnectorID
, commandPayload
.idTag
);
1288 logger
.debug(this._logPrefix() + ' Transaction remotely STARTED on ' + this._stationInfo
.name
+ '#' + transactionConnectorID
.toString() + ' for idTag ' + commandPayload
.idTag
);
1289 return Constants
.OCPP_RESPONSE_ACCEPTED
;
1291 logger
.error(this._logPrefix() + ' Remote starting transaction REJECTED on unavailable connector Id ' + transactionConnectorID
.toString() + ', idTag ' + commandPayload
.idTag
);
1292 return Constants
.OCPP_RESPONSE_REJECTED
;
1295 async handleRequestRemoteStopTransaction(commandPayload
: RemoteStopTransactionRequest
): Promise
<DefaultResponse
> {
1296 const transactionId
= commandPayload
.transactionId
;
1297 for (const connector
in this._connectors
) {
1298 if (Utils
.convertToInt(connector
) > 0 && this.getConnector(Utils
.convertToInt(connector
))?.transactionId
=== transactionId
) {
1299 await this.sendStatusNotification(Utils
.convertToInt(connector
), ChargePointStatus
.FINISHING
);
1300 await this.sendStopTransaction(transactionId
);
1301 return Constants
.OCPP_RESPONSE_ACCEPTED
;
1304 logger
.info(this._logPrefix() + ' Trying to remote stop a non existing transaction ' + transactionId
.toString());
1305 return Constants
.OCPP_RESPONSE_REJECTED
;
1308 // eslint-disable-next-line consistent-this
1309 private async sendMeterValues(connectorId
: number, interval
: number, self: ChargingStation
, debug
= false): Promise
<void> {
1311 const meterValue
: MeterValue
= {
1312 timestamp
: new Date().toISOString(),
1315 const meterValuesTemplate
: SampledValue
[] = self.getConnector(connectorId
).MeterValues
;
1316 for (let index
= 0; index
< meterValuesTemplate
.length
; index
++) {
1317 const connector
= self.getConnector(connectorId
);
1319 if (meterValuesTemplate
[index
].measurand
&& meterValuesTemplate
[index
].measurand
=== MeterValueMeasurand
.STATE_OF_CHARGE
&& self._getConfigurationKey(StandardParametersKey
.MeterValuesSampledData
).value
.includes(MeterValueMeasurand
.STATE_OF_CHARGE
)) {
1320 meterValue
.sampledValue
.push({
1321 ...!Utils
.isUndefined(meterValuesTemplate
[index
].unit
) ? { unit
: meterValuesTemplate
[index
].unit
} : { unit
: MeterValueUnit
.PERCENT
},
1322 ...!Utils
.isUndefined(meterValuesTemplate
[index
].context
) && { context
: meterValuesTemplate
[index
].context
},
1323 measurand
: meterValuesTemplate
[index
].measurand
,
1324 ...!Utils
.isUndefined(meterValuesTemplate
[index
].location
) ? { location
: meterValuesTemplate
[index
].location
} : { location
: MeterValueLocation
.EV
},
1325 ...!Utils
.isUndefined(meterValuesTemplate
[index
].value
) ? { value
: meterValuesTemplate
[index
].value
} : { value
: Utils
.getRandomInt(100).toString() },
1327 const sampledValuesIndex
= meterValue
.sampledValue
.length
- 1;
1328 if (Utils
.convertToInt(meterValue
.sampledValue
[sampledValuesIndex
].value
) > 100 || debug
) {
1329 logger
.error(`${self._logPrefix()} MeterValues measurand ${meterValue.sampledValue[sampledValuesIndex].measurand ? meterValue.sampledValue[sampledValuesIndex].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${meterValue.sampledValue[sampledValuesIndex].value}/100`);
1331 // Voltage measurand
1332 } else if (meterValuesTemplate
[index
].measurand
&& meterValuesTemplate
[index
].measurand
=== MeterValueMeasurand
.VOLTAGE
&& self._getConfigurationKey(StandardParametersKey
.MeterValuesSampledData
).value
.includes(MeterValueMeasurand
.VOLTAGE
)) {
1333 const voltageMeasurandValue
= Utils
.getRandomFloatRounded(self._getVoltageOut() + self._getVoltageOut() * 0.1, self._getVoltageOut() - self._getVoltageOut() * 0.1);
1334 meterValue
.sampledValue
.push({
1335 ...!Utils
.isUndefined(meterValuesTemplate
[index
].unit
) ? { unit
: meterValuesTemplate
[index
].unit
} : { unit
: MeterValueUnit
.VOLT
},
1336 ...!Utils
.isUndefined(meterValuesTemplate
[index
].context
) && { context
: meterValuesTemplate
[index
].context
},
1337 measurand
: meterValuesTemplate
[index
].measurand
,
1338 ...!Utils
.isUndefined(meterValuesTemplate
[index
].location
) && { location
: meterValuesTemplate
[index
].location
},
1339 ...!Utils
.isUndefined(meterValuesTemplate
[index
].value
) ? { value
: meterValuesTemplate
[index
].value
} : { value
: voltageMeasurandValue
.toString() },
1341 for (let phase
= 1; self._getNumberOfPhases() === 3 && phase
<= self._getNumberOfPhases(); phase
++) {
1342 let phaseValue
: string;
1343 if (self._getVoltageOut() >= 0 && self._getVoltageOut() <= 250) {
1344 phaseValue
= `L${phase}-N`;
1345 } else if (self._getVoltageOut() > 250) {
1346 phaseValue
= `L${phase}-L${(phase + 1) % self._getNumberOfPhases() !== 0 ? (phase + 1) % self._getNumberOfPhases() : self._getNumberOfPhases()}`;
1348 meterValue
.sampledValue
.push({
1349 ...!Utils
.isUndefined(meterValuesTemplate
[index
].unit
) ? { unit
: meterValuesTemplate
[index
].unit
} : { unit
: MeterValueUnit
.VOLT
},
1350 ...!Utils
.isUndefined(meterValuesTemplate
[index
].context
) && { context
: meterValuesTemplate
[index
].context
},
1351 measurand
: meterValuesTemplate
[index
].measurand
,
1352 ...!Utils
.isUndefined(meterValuesTemplate
[index
].location
) && { location
: meterValuesTemplate
[index
].location
},
1353 ...!Utils
.isUndefined(meterValuesTemplate
[index
].value
) ? { value
: meterValuesTemplate
[index
].value
} : { value
: voltageMeasurandValue
.toString() },
1354 phase
: phaseValue
as MeterValuePhase
,
1357 // Power.Active.Import measurand
1358 } else if (meterValuesTemplate
[index
].measurand
&& meterValuesTemplate
[index
].measurand
=== MeterValueMeasurand
.POWER_ACTIVE_IMPORT
&& self._getConfigurationKey(StandardParametersKey
.MeterValuesSampledData
).value
.includes(MeterValueMeasurand
.POWER_ACTIVE_IMPORT
)) {
1359 // FIXME: factor out powerDivider checks
1360 if (Utils
.isUndefined(self._stationInfo
.powerDivider
)) {
1361 const errMsg
= `${self._logPrefix()} MeterValues measurand ${meterValuesTemplate[index].measurand ? meterValuesTemplate[index].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: powerDivider is undefined`;
1362 logger
.error(errMsg
);
1363 throw Error(errMsg
);
1364 } else if (self._stationInfo
.powerDivider
&& self._stationInfo
.powerDivider
<= 0) {
1365 const errMsg
= `${self._logPrefix()} MeterValues measurand ${meterValuesTemplate[index].measurand ? meterValuesTemplate[index].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: powerDivider have zero or below value ${self._stationInfo.powerDivider}`;
1366 logger
.error(errMsg
);
1367 throw Error(errMsg
);
1369 const errMsg
= `${self._logPrefix()} MeterValues measurand ${meterValuesTemplate[index].measurand ? meterValuesTemplate[index].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: Unknown ${self._getPowerOutType()} powerOutType in template file ${self._stationTemplateFile}, cannot calculate ${meterValuesTemplate[index].measurand ? meterValuesTemplate[index].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER} measurand value`;
1370 const powerMeasurandValues
= {} as MeasurandValues
;
1371 const maxPower
= Math.round(self._stationInfo
.maxPower
/ self._stationInfo
.powerDivider
);
1372 const maxPowerPerPhase
= Math.round((self._stationInfo
.maxPower
/ self._stationInfo
.powerDivider
) / self._getNumberOfPhases());
1373 switch (self._getPowerOutType()) {
1374 case PowerOutType
.AC
:
1375 if (Utils
.isUndefined(meterValuesTemplate
[index
].value
)) {
1376 powerMeasurandValues
.L1
= Utils
.getRandomFloatRounded(maxPowerPerPhase
);
1377 powerMeasurandValues
.L2
= 0;
1378 powerMeasurandValues
.L3
= 0;
1379 if (self._getNumberOfPhases() === 3) {
1380 powerMeasurandValues
.L2
= Utils
.getRandomFloatRounded(maxPowerPerPhase
);
1381 powerMeasurandValues
.L3
= Utils
.getRandomFloatRounded(maxPowerPerPhase
);
1383 powerMeasurandValues
.allPhases
= Utils
.roundTo(powerMeasurandValues
.L1
+ powerMeasurandValues
.L2
+ powerMeasurandValues
.L3
, 2);
1386 case PowerOutType
.DC
:
1387 if (Utils
.isUndefined(meterValuesTemplate
[index
].value
)) {
1388 powerMeasurandValues
.allPhases
= Utils
.getRandomFloatRounded(maxPower
);
1392 logger
.error(errMsg
);
1393 throw Error(errMsg
);
1395 meterValue
.sampledValue
.push({
1396 ...!Utils
.isUndefined(meterValuesTemplate
[index
].unit
) ? { unit
: meterValuesTemplate
[index
].unit
} : { unit
: MeterValueUnit
.WATT
},
1397 ...!Utils
.isUndefined(meterValuesTemplate
[index
].context
) && { context
: meterValuesTemplate
[index
].context
},
1398 measurand
: meterValuesTemplate
[index
].measurand
,
1399 ...!Utils
.isUndefined(meterValuesTemplate
[index
].location
) && { location
: meterValuesTemplate
[index
].location
},
1400 ...!Utils
.isUndefined(meterValuesTemplate
[index
].value
) ? { value
: meterValuesTemplate
[index
].value
} : { value
: powerMeasurandValues
.allPhases
.toString() },
1402 const sampledValuesIndex
= meterValue
.sampledValue
.length
- 1;
1403 if (Utils
.convertToFloat(meterValue
.sampledValue
[sampledValuesIndex
].value
) > maxPower
|| debug
) {
1404 logger
.error(`${self._logPrefix()} MeterValues measurand ${meterValue.sampledValue[sampledValuesIndex].measurand ? meterValue.sampledValue[sampledValuesIndex].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${meterValue.sampledValue[sampledValuesIndex].value}/${maxPower}`);
1406 for (let phase
= 1; self._getNumberOfPhases() === 3 && phase
<= self._getNumberOfPhases(); phase
++) {
1407 const phaseValue
= `L${phase}-N`;
1408 meterValue
.sampledValue
.push({
1409 ...!Utils
.isUndefined(meterValuesTemplate
[index
].unit
) ? { unit
: meterValuesTemplate
[index
].unit
} : { unit
: MeterValueUnit
.WATT
},
1410 ...!Utils
.isUndefined(meterValuesTemplate
[index
].context
) && { context
: meterValuesTemplate
[index
].context
},
1411 ...!Utils
.isUndefined(meterValuesTemplate
[index
].measurand
) && { measurand
: meterValuesTemplate
[index
].measurand
},
1412 ...!Utils
.isUndefined(meterValuesTemplate
[index
].location
) && { location
: meterValuesTemplate
[index
].location
},
1413 ...!Utils
.isUndefined(meterValuesTemplate
[index
].value
) ? { value
: meterValuesTemplate
[index
].value
} : { value
: powerMeasurandValues
[`L${phase}`] as string },
1414 phase
: phaseValue
as MeterValuePhase
,
1417 // Current.Import measurand
1418 } else if (meterValuesTemplate
[index
].measurand
&& meterValuesTemplate
[index
].measurand
=== MeterValueMeasurand
.CURRENT_IMPORT
&& self._getConfigurationKey(StandardParametersKey
.MeterValuesSampledData
).value
.includes(MeterValueMeasurand
.CURRENT_IMPORT
)) {
1419 // FIXME: factor out powerDivider checks
1420 if (Utils
.isUndefined(self._stationInfo
.powerDivider
)) {
1421 const errMsg
= `${self._logPrefix()} MeterValues measurand ${meterValuesTemplate[index].measurand ? meterValuesTemplate[index].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: powerDivider is undefined`;
1422 logger
.error(errMsg
);
1423 throw Error(errMsg
);
1424 } else if (self._stationInfo
.powerDivider
&& self._stationInfo
.powerDivider
<= 0) {
1425 const errMsg
= `${self._logPrefix()} MeterValues measurand ${meterValuesTemplate[index].measurand ? meterValuesTemplate[index].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: powerDivider have zero or below value ${self._stationInfo.powerDivider}`;
1426 logger
.error(errMsg
);
1427 throw Error(errMsg
);
1429 const errMsg
= `${self._logPrefix()} MeterValues measurand ${meterValuesTemplate[index].measurand ? meterValuesTemplate[index].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: Unknown ${self._getPowerOutType()} powerOutType in template file ${self._stationTemplateFile}, cannot calculate ${meterValuesTemplate[index].measurand ? meterValuesTemplate[index].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER} measurand value`;
1430 const currentMeasurandValues
: MeasurandValues
= {} as MeasurandValues
;
1431 let maxAmperage
: number;
1432 switch (self._getPowerOutType()) {
1433 case PowerOutType
.AC
:
1434 maxAmperage
= ElectricUtils
.ampPerPhaseFromPower(self._getNumberOfPhases(), self._stationInfo
.maxPower
/ self._stationInfo
.powerDivider
, self._getVoltageOut());
1435 if (Utils
.isUndefined(meterValuesTemplate
[index
].value
)) {
1436 currentMeasurandValues
.L1
= Utils
.getRandomFloatRounded(maxAmperage
);
1437 currentMeasurandValues
.L2
= 0;
1438 currentMeasurandValues
.L3
= 0;
1439 if (self._getNumberOfPhases() === 3) {
1440 currentMeasurandValues
.L2
= Utils
.getRandomFloatRounded(maxAmperage
);
1441 currentMeasurandValues
.L3
= Utils
.getRandomFloatRounded(maxAmperage
);
1443 currentMeasurandValues
.allPhases
= Utils
.roundTo((currentMeasurandValues
.L1
+ currentMeasurandValues
.L2
+ currentMeasurandValues
.L3
) / self._getNumberOfPhases(), 2);
1446 case PowerOutType
.DC
:
1447 maxAmperage
= ElectricUtils
.ampTotalFromPower(self._stationInfo
.maxPower
/ self._stationInfo
.powerDivider
, self._getVoltageOut());
1448 if (Utils
.isUndefined(meterValuesTemplate
[index
].value
)) {
1449 currentMeasurandValues
.allPhases
= Utils
.getRandomFloatRounded(maxAmperage
);
1453 logger
.error(errMsg
);
1454 throw Error(errMsg
);
1456 meterValue
.sampledValue
.push({
1457 ...!Utils
.isUndefined(meterValuesTemplate
[index
].unit
) ? { unit
: meterValuesTemplate
[index
].unit
} : { unit
: MeterValueUnit
.AMP
},
1458 ...!Utils
.isUndefined(meterValuesTemplate
[index
].context
) && { context
: meterValuesTemplate
[index
].context
},
1459 measurand
: meterValuesTemplate
[index
].measurand
,
1460 ...!Utils
.isUndefined(meterValuesTemplate
[index
].location
) && { location
: meterValuesTemplate
[index
].location
},
1461 ...!Utils
.isUndefined(meterValuesTemplate
[index
].value
) ? { value
: meterValuesTemplate
[index
].value
} : { value
: currentMeasurandValues
.allPhases
.toString() },
1463 const sampledValuesIndex
= meterValue
.sampledValue
.length
- 1;
1464 if (Utils
.convertToFloat(meterValue
.sampledValue
[sampledValuesIndex
].value
) > maxAmperage
|| debug
) {
1465 logger
.error(`${self._logPrefix()} MeterValues measurand ${meterValue.sampledValue[sampledValuesIndex].measurand ? meterValue.sampledValue[sampledValuesIndex].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${meterValue.sampledValue[sampledValuesIndex].value}/${maxAmperage}`);
1467 for (let phase
= 1; self._getNumberOfPhases() === 3 && phase
<= self._getNumberOfPhases(); phase
++) {
1468 const phaseValue
= `L${phase}`;
1469 meterValue
.sampledValue
.push({
1470 ...!Utils
.isUndefined(meterValuesTemplate
[index
].unit
) ? { unit
: meterValuesTemplate
[index
].unit
} : { unit
: MeterValueUnit
.AMP
},
1471 ...!Utils
.isUndefined(meterValuesTemplate
[index
].context
) && { context
: meterValuesTemplate
[index
].context
},
1472 ...!Utils
.isUndefined(meterValuesTemplate
[index
].measurand
) && { measurand
: meterValuesTemplate
[index
].measurand
},
1473 ...!Utils
.isUndefined(meterValuesTemplate
[index
].location
) && { location
: meterValuesTemplate
[index
].location
},
1474 ...!Utils
.isUndefined(meterValuesTemplate
[index
].value
) ? { value
: meterValuesTemplate
[index
].value
} : { value
: currentMeasurandValues
[phaseValue
] as string },
1475 phase
: phaseValue
as MeterValuePhase
,
1478 // Energy.Active.Import.Register measurand (default)
1479 } else if (!meterValuesTemplate
[index
].measurand
|| meterValuesTemplate
[index
].measurand
=== MeterValueMeasurand
.ENERGY_ACTIVE_IMPORT_REGISTER
) {
1480 // FIXME: factor out powerDivider checks
1481 if (Utils
.isUndefined(self._stationInfo
.powerDivider
)) {
1482 const errMsg
= `${self._logPrefix()} MeterValues measurand ${meterValuesTemplate[index].measurand ? meterValuesTemplate[index].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: powerDivider is undefined`;
1483 logger
.error(errMsg
);
1484 throw Error(errMsg
);
1485 } else if (self._stationInfo
.powerDivider
&& self._stationInfo
.powerDivider
<= 0) {
1486 const errMsg
= `${self._logPrefix()} MeterValues measurand ${meterValuesTemplate[index].measurand ? meterValuesTemplate[index].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: powerDivider have zero or below value ${self._stationInfo.powerDivider}`;
1487 logger
.error(errMsg
);
1488 throw Error(errMsg
);
1490 if (Utils
.isUndefined(meterValuesTemplate
[index
].value
)) {
1491 const measurandValue
= Utils
.getRandomInt(self._stationInfo
.maxPower
/ (self._stationInfo
.powerDivider
* 3600000) * interval
);
1492 // Persist previous value in connector
1493 if (connector
&& !Utils
.isNullOrUndefined(connector
.lastEnergyActiveImportRegisterValue
) && connector
.lastEnergyActiveImportRegisterValue
>= 0) {
1494 connector
.lastEnergyActiveImportRegisterValue
+= measurandValue
;
1496 connector
.lastEnergyActiveImportRegisterValue
= 0;
1499 meterValue
.sampledValue
.push({
1500 ...!Utils
.isUndefined(meterValuesTemplate
[index
].unit
) ? { unit
: meterValuesTemplate
[index
].unit
} : { unit
: MeterValueUnit
.WATT_HOUR
},
1501 ...!Utils
.isUndefined(meterValuesTemplate
[index
].context
) && { context
: meterValuesTemplate
[index
].context
},
1502 ...!Utils
.isUndefined(meterValuesTemplate
[index
].measurand
) && { measurand
: meterValuesTemplate
[index
].measurand
},
1503 ...!Utils
.isUndefined(meterValuesTemplate
[index
].location
) && { location
: meterValuesTemplate
[index
].location
},
1504 ...!Utils
.isUndefined(meterValuesTemplate
[index
].value
) ? { value
: meterValuesTemplate
[index
].value
} :
1505 { value
: connector
.lastEnergyActiveImportRegisterValue
.toString() },
1507 const sampledValuesIndex
= meterValue
.sampledValue
.length
- 1;
1508 const maxConsumption
= Math.round(self._stationInfo
.maxPower
* 3600 / (self._stationInfo
.powerDivider
* interval
));
1509 if (Utils
.convertToFloat(meterValue
.sampledValue
[sampledValuesIndex
].value
) > maxConsumption
|| debug
) {
1510 logger
.error(`${self._logPrefix()} MeterValues measurand ${meterValue.sampledValue[sampledValuesIndex].measurand ? meterValue.sampledValue[sampledValuesIndex].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER}: connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${meterValue.sampledValue[sampledValuesIndex].value}/${maxConsumption}`);
1512 // Unsupported measurand
1514 logger
.info(`${self._logPrefix()} Unsupported MeterValues measurand ${meterValuesTemplate[index].measurand ? meterValuesTemplate[index].measurand : MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER} on connectorId ${connectorId}`);
1517 const payload
: MeterValuesRequest
= {
1519 transactionId
: self.getConnector(connectorId
).transactionId
,
1520 meterValue
: meterValue
,
1522 await self.sendMessage(Utils
.generateUUID(), payload
, MessageType
.CALL_MESSAGE
, RequestCommand
.METERVALUES
);
1524 this.handleRequestError(RequestCommand
.METERVALUES
, error
);
1528 private handleRequestError(commandName
: RequestCommand
, error
: Error) {
1529 logger
.error(this._logPrefix() + ' Send ' + commandName
+ ' error: %j', error
);