1 const Configuration
= require('../utils/Configuration');
2 const logger
= require('../utils/Logger');
3 const WebSocket
= require('ws');
4 const Constants
= require('../utils/Constants');
5 const Utils
= require('../utils/Utils');
6 const OCPPError
= require('./OcppError');
7 const AutomaticTransactionGenerator
= require('./AutomaticTransactionGenerator');
8 const Statistics
= require('../utils/Statistics');
9 const fs
= require('fs');
10 const {performance
, PerformanceObserver
} = require('perf_hooks');
12 class ChargingStation
{
13 constructor(index
, stationTemplateFile
) {
15 this._stationTemplateFile
= stationTemplateFile
;
18 this._isSocketRestart
= false;
19 this._autoReconnectRetryCount
= 0;
20 this._autoReconnectMaxRetries
= Configuration
.getAutoReconnectMaxRetries(); // -1 for unlimited
21 this._autoReconnectTimeout
= Configuration
.getAutoReconnectTimeout() * 1000; // ms, zero for disabling
24 this._messageQueue
= [];
26 this._authorizedTags
= this._loadAndGetAuthorizedTags();
29 _getStationName(stationTemplate
) {
30 return stationTemplate
.fixedName
? stationTemplate
.baseName
: stationTemplate
.baseName
+ '-' + ('000000000' + this._index
).substr(('000000000' + this._index
).length
- 4);
34 let stationTemplateFromFile
;
37 const fileDescriptor
= fs
.openSync(this._stationTemplateFile
, 'r');
38 stationTemplateFromFile
= JSON
.parse(fs
.readFileSync(fileDescriptor
, 'utf8'));
39 fs
.closeSync(fileDescriptor
);
41 logger
.error(this._basicFormatLog() + ' Template file loading error: ' + error
);
43 const stationTemplate
= stationTemplateFromFile
|| {};
44 if (!Utils
.isEmptyArray(stationTemplateFromFile
.power
)) {
45 stationTemplate
.maxPower
= stationTemplateFromFile
.power
[Math
.floor(Math
.random() * stationTemplateFromFile
.power
.length
)];
47 stationTemplate
.maxPower
= stationTemplateFromFile
.power
;
49 stationTemplate
.name
= this._getStationName(stationTemplateFromFile
);
50 stationTemplate
.resetTime
= stationTemplateFromFile
.resetTime
? stationTemplateFromFile
.resetTime
* 1000 : Constants
.CHARGING_STATION_DEFAULT_RESET_TIME
;
51 return stationTemplate
;
55 this._stationInfo
= this._buildStationInfo();
56 this._bootNotificationMessage
= {
57 chargePointModel
: this._stationInfo
.chargePointModel
,
58 chargePointVendor
: this._stationInfo
.chargePointVendor
,
59 chargePointSerialNumber
: this._stationInfo
.chargePointSerialNumberPrefix
? this._stationInfo
.chargePointSerialNumberPrefix
: '',
60 firmwareVersion
: this._stationInfo
.firmwareVersion
? this._stationInfo
.firmwareVersion
: '',
62 this._configuration
= this._getConfiguration();
63 this._supervisionUrl
= this._getSupervisionURL();
64 this._wsConnectionUrl
= this._supervisionUrl
+ '/' + this._stationInfo
.name
;
65 // Build connectors if needed
66 const maxConnectors
= this._getMaxConnectors();
67 const connectorsConfig
= Utils
.cloneJSonDocument(this._stationInfo
.Connectors
);
68 const connectorsConfigLength
= Utils
.convertToBoolean(this._stationInfo
.useConnectorId0
) && Object
.keys(connectorsConfig
).includes('0') ? Object
.keys(connectorsConfig
).length
: Object
.keys(connectorsConfig
).length
- 1;
69 if (!this._connectors
|| (this._connectors
&& Object
.keys(this._connectors
).length
!== connectorsConfigLength
)) {
70 this._connectors
= {};
71 // Determine number of customized connectors
73 for (lastConnector
in connectorsConfig
) {
74 // Add connector 0, OCPP specification violation that for example KEBA have
75 if (Utils
.convertToInt(lastConnector
) === 0 && Utils
.convertToBoolean(this._stationInfo
.useConnectorId0
) &&
76 connectorsConfig
[lastConnector
]) {
77 this._connectors
[lastConnector
] = connectorsConfig
[lastConnector
];
80 this._addConfigurationKey('NumberOfConnectors', maxConnectors
, true);
81 // Generate all connectors
82 for (let index
= 1; index
<= maxConnectors
; index
++) {
83 const randConnectorID
= Utils
.convertToBoolean(this._stationInfo
.randomConnectors
) ? Utils
.getRandomInt(lastConnector
, 1) : index
;
84 this._connectors
[index
] = connectorsConfig
[randConnectorID
];
87 // Initialize transaction attributes on connectors
88 for (const connector
in this._connectors
) {
89 if (!this._connectors
[connector
].transactionStarted
) {
90 this._initTransactionOnConnector(connector
);
93 this._statistics
= new Statistics(this._stationInfo
.name
);
94 this._performanceObserver
= new PerformanceObserver((list
) => {
95 const entry
= list
.getEntries()[0];
96 this._statistics
.logPerformance(entry
, 'ChargingStation');
97 this._performanceObserver
.disconnect();
102 return Utils
.basicFormatLog(` ${this._stationInfo.name}:`);
105 _getConfiguration() {
106 return this._stationInfo
.Configuration
? this._stationInfo
.Configuration
: {};
109 _getAuthorizationFile() {
110 return this._stationInfo
.authorizationFile
? this._stationInfo
.authorizationFile
: '';
113 _loadAndGetAuthorizedTags() {
114 let authorizedTags
= [];
115 const authorizationFile
= this._getAuthorizationFile();
116 if (authorizationFile
) {
118 // Load authorization file
119 const fileDescriptor
= fs
.openSync(authorizationFile
, 'r');
120 authorizedTags
= JSON
.parse(fs
.readFileSync(fileDescriptor
, 'utf8'));
121 fs
.closeSync(fileDescriptor
);
123 logger
.error(this._basicFormatLog() + ' Authorization file loading error: ' + error
);
126 logger
.info(this._basicFormatLog() + ' No authorization file given in template file ' + this._stationTemplateFile
);
128 return authorizedTags
;
132 const index
= Math
.floor(Math
.random() * this._authorizedTags
.length
);
133 return this._authorizedTags
[index
];
136 hasAuthorizedTags() {
137 return !Utils
.isEmptyArray(this._authorizedTags
);
140 _getConnector(number
) {
141 return this._stationInfo
.Connectors
[number
];
144 _getMaxConnectors() {
145 let maxConnectors
= 0;
146 if (!Utils
.isEmptyArray(this._stationInfo
.numberOfConnectors
)) {
147 // Get evenly the number of connectors
148 maxConnectors
= this._stationInfo
.numberOfConnectors
[(this._index
- 1) % this._stationInfo
.numberOfConnectors
.length
];
150 maxConnectors
= this._stationInfo
.numberOfConnectors
;
152 return maxConnectors
;
155 _getSupervisionURL() {
156 const supervisionUrls
= Utils
.cloneJSonDocument(this._stationInfo
.supervisionURL
? this._stationInfo
.supervisionURL
: Configuration
.getSupervisionURLs());
158 if (!Utils
.isEmptyArray(supervisionUrls
)) {
159 if (Configuration
.getDistributeStationToTenantEqually()) {
160 indexUrl
= this._index
% supervisionUrls
.length
;
163 indexUrl
= Math
.floor(Math
.random() * supervisionUrls
.length
);
165 return supervisionUrls
[indexUrl
];
167 return supervisionUrls
;
170 _getAuthorizeRemoteTxRequests() {
171 const authorizeRemoteTxRequests
= this._getConfigurationKey('AuthorizeRemoteTxRequests');
172 return authorizeRemoteTxRequests
? Utils
.convertToBoolean(authorizeRemoteTxRequests
.value
) : false;
175 _getLocalAuthListEnabled() {
176 const localAuthListEnabled
= this._getConfigurationKey('LocalAuthListEnabled');
177 return localAuthListEnabled
? Utils
.convertToBoolean(localAuthListEnabled
.value
) : false;
180 async
_basicStartMessageSequence() {
182 this._startHeartbeat(this);
183 // Initialize connectors status
184 for (const connector
in this._connectors
) {
185 if (!this._connectors
[connector
].transactionStarted
) {
186 if (this._connectors
[connector
].bootStatus
) {
187 this.sendStatusNotificationWithTimeout(connector
, this._connectors
[connector
].bootStatus
);
189 this.sendStatusNotificationWithTimeout(connector
, 'Available');
192 this.sendStatusNotificationWithTimeout(connector
, 'Charging');
196 if (Utils
.convertToBoolean(this._stationInfo
.AutomaticTransactionGenerator
.enable
)) {
197 if (!this._automaticTransactionGeneration
) {
198 this._automaticTransactionGeneration
= new AutomaticTransactionGenerator(this);
200 if (this._automaticTransactionGeneration
.timeToStop
) {
201 this._automaticTransactionGeneration
.start();
204 this._statistics
.start();
207 // eslint-disable-next-line class-methods-use-this
208 async
_startHeartbeat(self
) {
209 if (self
._heartbeatInterval
&& self
._heartbeatInterval
> 0 && !self
._heartbeatSetInterval
) {
210 self
._heartbeatSetInterval
= setInterval(() => {
211 this.sendHeartbeat();
212 }, self
._heartbeatInterval
);
213 logger
.info(self
._basicFormatLog() + ' Heartbeat started every ' + self
._heartbeatInterval
+ 'ms');
215 logger
.error(`${self._basicFormatLog()} Heartbeat interval set to ${self._heartbeatInterval}, not starting the heartbeat`);
219 async
_stopHeartbeat() {
220 if (this._heartbeatSetInterval
) {
221 clearInterval(this._heartbeatSetInterval
);
222 this._heartbeatSetInterval
= null;
226 _startAuthorizationFileMonitoring() {
227 // eslint-disable-next-line no-unused-vars
228 fs
.watchFile(this._getAuthorizationFile(), (current
, previous
) => {
230 logger
.debug(this._basicFormatLog() + ' Authorization file ' + this._getAuthorizationFile() + ' have changed, reload');
231 // Initialize _authorizedTags
232 this._authorizedTags
= this._loadAndGetAuthorizedTags();
234 logger
.error(this._basicFormatLog() + ' Authorization file monitoring error: ' + error
);
239 _startStationTemplateFileMonitoring() {
240 // eslint-disable-next-line no-unused-vars
241 fs
.watchFile(this._stationTemplateFile
, (current
, previous
) => {
243 logger
.debug(this._basicFormatLog() + ' Template file ' + this._stationTemplateFile
+ ' have changed, reload');
246 this._addConfigurationKey('HeartBeatInterval', Utils
.convertToInt(this._heartbeatInterval
? this._heartbeatInterval
/ 1000 : 0));
247 this._addConfigurationKey('HeartbeatInterval', Utils
.convertToInt(this._heartbeatInterval
? this._heartbeatInterval
/ 1000 : 0), false, false);
249 logger
.error(this._basicFormatLog() + ' Charging station template file monitoring error: ' + error
);
254 async
_startMeterValues(connectorID
, interval
) {
255 if (!this._connectors
[connectorID
].transactionStarted
) {
256 logger
.error(`${this._basicFormatLog()} Trying to start MeterValues on connector ID ${connectorID} with no transaction started`);
258 } else if (this._connectors
[connectorID
].transactionStarted
&& !this._connectors
[connectorID
].transactionId
) {
259 logger
.error(`${this._basicFormatLog()} Trying to start MeterValues on connector ID ${connectorID} with no transaction id`);
263 this._connectors
[connectorID
].transactionSetInterval
= setInterval(async () => {
264 const sendMeterValues
= performance
.timerify(this.sendMeterValues
);
265 this._performanceObserver
.observe({
266 entryTypes
: ['function'],
268 await
sendMeterValues(connectorID
, interval
, this);
271 logger
.info(`${this._basicFormatLog()} Charging station MeterValueSampleInterval configuration set to ${interval}ms, not sending MeterValues`);
276 if (!this._wsConnectionUrl
) {
277 this._wsConnectionUrl
= this._supervisionUrl
+ '/' + this._stationInfo
.name
;
279 this._wsConnection
= new WebSocket(this._wsConnectionUrl
, 'ocpp' + Constants
.OCPP_VERSION_16
);
280 logger
.info(this._basicFormatLog() + ' Will communicate with ' + this._supervisionUrl
);
281 // Monitor authorization file
282 this._startAuthorizationFileMonitoring();
283 // Monitor station template file
284 this._startStationTemplateFileMonitoring();
285 // Handle Socket incoming messages
286 this._wsConnection
.on('message', this.onMessage
.bind(this));
287 // Handle Socket error
288 this._wsConnection
.on('error', this.onError
.bind(this));
289 // Handle Socket close
290 this._wsConnection
.on('close', this.onClose
.bind(this));
291 // Handle Socket opening connection
292 this._wsConnection
.on('open', this.onOpen
.bind(this));
293 // Handle Socket ping
294 this._wsConnection
.on('ping', this.onPing
.bind(this));
297 async
stop(type
= '') {
299 await
this._stopHeartbeat();
301 if (Utils
.convertToBoolean(this._stationInfo
.AutomaticTransactionGenerator
.enable
) &&
302 this._automaticTransactionGeneration
&&
303 !this._automaticTransactionGeneration
.timeToStop
) {
304 await
this._automaticTransactionGeneration
.stop(type
? type
+ 'Reset' : '');
306 for (const connector
in this._connectors
) {
307 if (this._connectors
[connector
].transactionStarted
) {
308 await
this.sendStopTransaction(this._connectors
[connector
].transactionId
, type
? type
+ 'Reset' : '');
312 // eslint-disable-next-line guard-for-in
313 for (const connector
in this._connectors
) {
314 await
this.sendStatusNotification(connector
, 'Unavailable');
316 if (this._wsConnection
&& this._wsConnection
.readyState
=== WebSocket
.OPEN
) {
317 await
this._wsConnection
.close();
322 logger
.error(this._basicFormatLog() + ' Socket: abnormally closed', error
);
323 // Stop the ATG if needed
324 if (Utils
.convertToBoolean(this._stationInfo
.AutomaticTransactionGenerator
.enable
) &&
325 Utils
.convertToBoolean(this._stationInfo
.AutomaticTransactionGenerator
.stopOnConnectionFailure
) &&
326 this._automaticTransactionGeneration
&&
327 !this._automaticTransactionGeneration
.timeToStop
) {
328 this._automaticTransactionGeneration
.stop();
331 this._stopHeartbeat();
332 if (this._autoReconnectTimeout
!== 0 &&
333 (this._autoReconnectRetryCount
< this._autoReconnectMaxRetries
|| this._autoReconnectMaxRetries
=== -1)) {
334 logger
.error(`${this._basicFormatLog()} Socket: connection retry with timeout ${this._autoReconnectTimeout}ms`);
335 this._autoReconnectRetryCount
++;
337 logger
.error(this._basicFormatLog() + ' Socket: reconnecting try #' + this._autoReconnectRetryCount
);
339 }, this._autoReconnectTimeout
);
340 } else if (this._autoReconnectTimeout
!== 0 || this._autoReconnectMaxRetries
!== -1) {
341 logger
.error(`${this._basicFormatLog()} Socket: max retries reached (${this._autoReconnectRetryCount}) or retry disabled (${this._autoReconnectTimeout})`);
346 logger
.info(`${this._basicFormatLog()} Is connected to server through ${this._wsConnectionUrl}`);
347 if (!this._isSocketRestart
) {
348 // Send BootNotification
349 this.sendBootNotification();
351 if (this._isSocketRestart
) {
352 this._basicStartMessageSequence();
353 if (this._messageQueue
.length
> 0) {
354 this._messageQueue
.forEach((message
) => {
355 if (this._wsConnection
&& this._wsConnection
.readyState
=== WebSocket
.OPEN
) {
356 this._wsConnection
.send(message
);
361 this._autoReconnectRetryCount
= 0;
362 this._isSocketRestart
= false;
368 this._isSocketRestart
= true;
369 this._reconnect(error
);
372 logger
.error(this._basicFormatLog() + ' Socket error: ' + error
);
379 case 1000: // Normal close
381 logger
.info(this._basicFormatLog() + ' Socket normally closed ' + error
);
382 this._autoReconnectRetryCount
= 0;
384 default: // Abnormal close
385 this._isSocketRestart
= true;
386 this._reconnect(error
);
392 logger
.debug(this._basicFormatLog() + ' Has received a WS ping (rfc6455) from the server');
395 async
onMessage(message
) {
396 let [messageType
, messageId
, commandName
, commandPayload
, errorDetails
] = [0, '', Constants
.ENTITY_CHARGING_STATION
, '', ''];
399 [messageType
, messageId
, commandName
, commandPayload
, errorDetails
] = JSON
.parse(message
);
401 // Check the Type of message
402 switch (messageType
) {
404 case Constants
.OCPP_JSON_CALL_MESSAGE
:
406 await
this.handleRequest(messageId
, commandName
, commandPayload
);
409 case Constants
.OCPP_JSON_CALL_RESULT_MESSAGE
:
411 // eslint-disable-next-line no-case-declarations
412 let responseCallback
; let requestPayload
;
413 if (Utils
.isIterable(this._requests
[messageId
])) {
414 [responseCallback
, , requestPayload
] = this._requests
[messageId
];
416 throw new Error(`Response request for unknown message id ${messageId} is not iterable`);
418 if (!responseCallback
) {
420 throw new Error(`Response for unknown message id ${messageId}`);
422 delete this._requests
[messageId
];
423 responseCallback(commandName
, requestPayload
);
426 case Constants
.OCPP_JSON_CALL_ERROR_MESSAGE
:
427 if (!this._requests
[messageId
]) {
429 throw new Error(`Error for unknown message id ${messageId}`);
431 // eslint-disable-next-line no-case-declarations
433 if (Utils
.isIterable(this._requests
[messageId
])) {
434 [, rejectCallback
] = this._requests
[messageId
];
436 throw new Error(`Error request for unknown message id ${messageId} is not iterable`);
438 delete this._requests
[messageId
];
439 rejectCallback(new OCPPError(commandName
, commandPayload
, errorDetails
));
443 throw new Error(`Wrong message type ${messageType}`);
447 logger
.error('%s Incoming message %j processing error %s on request content %s', this._basicFormatLog(), message
, error
, this._requests
[messageId
]);
449 // await this.sendError(messageId, error);
456 currentTime
: new Date().toISOString(),
458 this.sendMessage(Utils
.generateUUID(), payload
, Constants
.OCPP_JSON_CALL_MESSAGE
, 'Heartbeat');
460 logger
.error(this._basicFormatLog() + ' Send Heartbeat error: ' + error
);
465 sendBootNotification() {
467 this.sendMessage(Utils
.generateUUID(), this._bootNotificationMessage
, Constants
.OCPP_JSON_CALL_MESSAGE
, 'BootNotification');
469 logger
.error(this._basicFormatLog() + ' Send BootNotification error: ' + error
);
474 async
sendStatusNotification(connectorId
, status
, errorCode
= 'NoError') {
481 await
this.sendMessage(Utils
.generateUUID(), payload
, Constants
.OCPP_JSON_CALL_MESSAGE
, 'StatusNotification');
483 logger
.error(this._basicFormatLog() + ' Send StatusNotification error: ' + error
);
488 sendStatusNotificationWithTimeout(connectorId
, status
, errorCode
= 'NoError', timeout
= Constants
.STATUS_NOTIFICATION_TIMEOUT
) {
489 setTimeout(() => this.sendStatusNotification(connectorId
, status
, errorCode
), timeout
);
492 async
sendStartTransaction(connectorID
, idTag
) {
495 connectorId
: connectorID
,
498 timestamp
: new Date().toISOString(),
500 return await
this.sendMessage(Utils
.generateUUID(), payload
, Constants
.OCPP_JSON_CALL_MESSAGE
, 'StartTransaction');
502 logger
.error(this._basicFormatLog() + ' Send StartTransaction error: ' + error
);
507 sendStartTransactionWithTimeout(connectorID
, idTag
, timeout
) {
508 setTimeout(() => this.sendStartTransaction(connectorID
, idTag
), timeout
);
511 async
sendStopTransaction(transactionId
, reason
= '') {
516 timestamp
: new Date().toISOString(),
519 await
this.sendMessage(Utils
.generateUUID(), payload
, Constants
.OCPP_JSON_CALL_MESSAGE
, 'StopTransaction');
521 logger
.error(this._basicFormatLog() + ' Send StopTransaction error: ' + error
);
526 // eslint-disable-next-line class-methods-use-this
527 async
sendMeterValues(connectorID
, interval
, self
, debug
= false) {
529 const sampledValueLcl
= {
530 timestamp
: new Date().toISOString(),
532 const meterValuesClone
= Utils
.cloneJSonDocument(self
._getConnector(connectorID
).MeterValues
);
533 if (!Utils
.isEmptyArray(meterValuesClone
)) {
534 sampledValueLcl
.sampledValue
= meterValuesClone
;
536 sampledValueLcl
.sampledValue
= [meterValuesClone
];
538 for (let index
= 0; index
< sampledValueLcl
.sampledValue
.length
; index
++) {
539 const connector
= self
._connectors
[connectorID
];
541 if (sampledValueLcl
.sampledValue
[index
].measurand
&& sampledValueLcl
.sampledValue
[index
].measurand
=== 'SoC') {
542 sampledValueLcl
.sampledValue
[index
].value
= Utils
.getRandomInt(100);
543 if (sampledValueLcl
.sampledValue
[index
].value
> 100 || debug
) {
544 logger
.error(`${self._basicFormatLog()} MeterValues measurand ${sampledValueLcl.sampledValue[index].measurand ? sampledValueLcl.sampledValue[index].measurand : 'Energy.Active.Import.Register'}: connectorID ${connectorID}, transaction ${connector.transactionId}, value: ${sampledValueLcl.sampledValue[index].value}`);
547 } else if (sampledValueLcl
.sampledValue
[index
].measurand
&& sampledValueLcl
.sampledValue
[index
].measurand
=== 'Voltage') {
548 sampledValueLcl
.sampledValue
[index
].value
= 230;
549 // Energy.Active.Import.Register measurand (default)
550 } else if (!sampledValueLcl
.sampledValue
[index
].measurand
|| sampledValueLcl
.sampledValue
[index
].measurand
=== 'Energy.Active.Import.Register') {
551 // Persist previous value in connector
552 const consumption
= Utils
.getRandomInt(self
._stationInfo
.maxPower
/ 3600000 * interval
);
553 if (connector
&& connector
.lastConsumptionValue
&& connector
.lastConsumptionValue
>= 0) {
554 connector
.lastConsumptionValue
+= consumption
;
556 connector
.lastConsumptionValue
= 0;
558 const maxConsumption
= self
._stationInfo
.maxPower
* 3600 / interval
;
559 logger
.info(`${self._basicFormatLog()} MeterValues measurand ${sampledValueLcl.sampledValue[index].measurand ? sampledValueLcl.sampledValue[index].measurand : 'Energy.Active.Import.Register'}: connectorID ${connectorID}, transaction ${connector.transactionId}, value ${connector.lastConsumptionValue}`);
560 sampledValueLcl
.sampledValue
[index
].value
= connector
.lastConsumptionValue
;
561 if (sampledValueLcl
.sampledValue
[index
].value
> maxConsumption
|| debug
) {
562 logger
.error(`${self._basicFormatLog()} MeterValues measurand ${sampledValueLcl.sampledValue[index].measurand ? sampledValueLcl.sampledValue[index].measurand : 'Energy.Active.Import.Register'}: connectorID ${connectorID}, transaction ${connector.transactionId}, value: ${sampledValueLcl.sampledValue[index].value}/${maxConsumption}`);
564 // Unsupported measurand
566 logger
.info(`${self._basicFormatLog()} Unsupported MeterValues measurand ${sampledValueLcl.sampledValue[index].measurand ? sampledValueLcl.sampledValue[index].measurand : 'Energy.Active.Import.Register'} on connectorID ${connectorID}`);
571 connectorId
: connectorID
,
572 transactionId
: self
._connectors
[connectorID
].transactionId
,
573 meterValue
: [sampledValueLcl
],
575 await self
.sendMessage(Utils
.generateUUID(), payload
, Constants
.OCPP_JSON_CALL_MESSAGE
, 'MeterValues');
577 logger
.error(self
._basicFormatLog() + ' Send MeterValues error: ' + error
);
582 sendError(messageId
, err
) {
583 // Check exception: only OCPP error are accepted
584 const error
= err
instanceof OCPPError
? err
: new OCPPError(Constants
.OCPP_ERROR_INTERNAL_ERROR
, err
.message
);
586 return this.sendMessage(messageId
, error
, Constants
.OCPP_JSON_CALL_ERROR_MESSAGE
);
589 sendMessage(messageId
, command
, messageType
= Constants
.OCPP_JSON_CALL_RESULT_MESSAGE
, commandName
= '') {
590 // Send a message through wsConnection
593 return new Promise((resolve
, reject
) => {
596 switch (messageType
) {
598 case Constants
.OCPP_JSON_CALL_MESSAGE
:
599 this._statistics
.addMessage(commandName
);
601 this._requests
[messageId
] = [responseCallback
, rejectCallback
, command
];
602 messageToSend
= JSON
.stringify([messageType
, messageId
, commandName
, command
]);
605 case Constants
.OCPP_JSON_CALL_RESULT_MESSAGE
:
606 this._statistics
.addMessage(commandName
);
608 messageToSend
= JSON
.stringify([messageType
, messageId
, command
]);
611 case Constants
.OCPP_JSON_CALL_ERROR_MESSAGE
:
613 this._statistics
.addMessage(`Error ${command.code ? command.code : Constants.OCPP_ERROR_GENERIC_ERROR} on ${commandName || ''}`);
614 messageToSend
= JSON
.stringify([messageType
, messageId
, command
.code
? command
.code
: Constants
.OCPP_ERROR_GENERIC_ERROR
, command
.message
? command
.message
: '', command
.details
? command
.details
: {}]);
617 // Check if wsConnection is ready
618 if (this._wsConnection
&& this._wsConnection
.readyState
=== WebSocket
.OPEN
) {
620 this._wsConnection
.send(messageToSend
);
622 // Buffer message until connection is back
623 this._messageQueue
.push(messageToSend
);
626 if (messageType
!== Constants
.OCPP_JSON_CALL_MESSAGE
) {
629 } else if (this._wsConnection
&& this._wsConnection
.readyState
=== WebSocket
.OPEN
) {
630 // Send timeout in case connection is open otherwise wait for ever
631 // FIXME: Handle message on timeout
632 setTimeout(() => rejectCallback(`Timeout for message ${messageId}`), Constants
.OCPP_SOCKET_TIMEOUT
);
635 // Function that will receive the request's response
636 function responseCallback(payload
, requestPayload
) {
637 self
._statistics
.addMessage(commandName
, true);
638 const responseCallbackFn
= 'handleResponse' + commandName
;
639 if (typeof self
[responseCallbackFn
] === 'function') {
640 self
[responseCallbackFn
](payload
, requestPayload
, self
);
642 logger
.debug(self
._basicFormatLog() + ' Trying to call an undefined response callback function: ' + responseCallbackFn
);
648 // Function that will receive the request's rejection
649 function rejectCallback(reason
) {
650 self
._statistics
.addMessage(`Error ${command.code ? command.code : Constants.OCPP_ERROR_GENERIC_ERROR} on ${commandName || ''}`, true);
652 // eslint-disable-next-line no-empty-function
653 self
._requests
[messageId
] = [() => { }, () => { }, '']; // Properly format the request
654 const error
= reason
instanceof OCPPError
? reason
: new Error(reason
);
661 handleResponseBootNotification(payload
) {
662 if (payload
.status
=== 'Accepted') {
663 this._heartbeatInterval
= payload
.interval
* 1000;
664 this._addConfigurationKey('HeartBeatInterval', Utils
.convertToInt(payload
.interval
));
665 this._addConfigurationKey('HeartbeatInterval', Utils
.convertToInt(payload
.interval
), false, false);
666 this._basicStartMessageSequence();
667 } else if (payload
.status
=== 'Pending') {
668 logger
.info(this._basicFormatLog() + ' Charging station pending on the central server');
670 logger
.info(this._basicFormatLog() + ' Charging station rejected by the central server');
674 _initTransactionOnConnector(connectorID
) {
675 this._connectors
[connectorID
].transactionStarted
= false;
676 this._connectors
[connectorID
].transactionId
= null;
677 this._connectors
[connectorID
].idTag
= null;
678 this._connectors
[connectorID
].lastConsumptionValue
= -1;
681 _resetTransactionOnConnector(connectorID
) {
682 this._initTransactionOnConnector(connectorID
);
683 if (this._connectors
[connectorID
].transactionSetInterval
) {
684 clearInterval(this._connectors
[connectorID
].transactionSetInterval
);
688 handleResponseStartTransaction(payload
, requestPayload
) {
689 if (this._connectors
[requestPayload
.connectorId
].transactionStarted
) {
690 logger
.debug(this._basicFormatLog() + ' Try to start a transaction on an already used connector ' + requestPayload
.connectorId
+ ' by transaction ' + this._connectors
[requestPayload
.connectorId
].transactionId
);
693 let transactionConnectorId
;
694 for (const connector
in this._connectors
) {
695 if (Utils
.convertToInt(connector
) === Utils
.convertToInt(requestPayload
.connectorId
)) {
696 transactionConnectorId
= connector
;
700 if (!transactionConnectorId
) {
701 logger
.error(this._basicFormatLog() + ' Try to start a transaction on a non existing connector Id ' + requestPayload
.connectorId
);
704 if (payload
.idTagInfo
&& payload
.idTagInfo
.status
=== 'Accepted') {
705 this._connectors
[transactionConnectorId
].transactionStarted
= true;
706 this._connectors
[transactionConnectorId
].transactionId
= payload
.transactionId
;
707 this._connectors
[transactionConnectorId
].idTag
= requestPayload
.idTag
;
708 this._connectors
[transactionConnectorId
].lastConsumptionValue
= 0;
709 this.sendStatusNotification(requestPayload
.connectorId
, 'Charging');
710 logger
.info(this._basicFormatLog() + ' Transaction ' + this._connectors
[transactionConnectorId
].transactionId
+ ' STARTED on ' + this._stationInfo
.name
+ '#' + requestPayload
.connectorId
+ ' for idTag ' + requestPayload
.idTag
);
711 const configuredMeterValueSampleInterval
= this._getConfigurationKey('MeterValueSampleInterval');
712 this._startMeterValues(requestPayload
.connectorId
,
713 configuredMeterValueSampleInterval
? configuredMeterValueSampleInterval
.value
* 1000 : 60000);
715 logger
.error(this._basicFormatLog() + ' Starting transaction id ' + payload
.transactionId
+ ' REJECTED with status ' + payload
.idTagInfo
.status
+ ', idTag ' + requestPayload
.idTag
);
716 this._resetTransactionOnConnector(transactionConnectorId
);
717 this.sendStatusNotification(requestPayload
.connectorId
, 'Available');
721 handleResponseStopTransaction(payload
, requestPayload
) {
722 let transactionConnectorId
;
723 for (const connector
in this._connectors
) {
724 if (this._connectors
[connector
].transactionId
=== requestPayload
.transactionId
) {
725 transactionConnectorId
= connector
;
729 if (!transactionConnectorId
) {
730 logger
.error(this._basicFormatLog() + ' Try to stop a non existing transaction ' + requestPayload
.transactionId
);
733 if (payload
.idTagInfo
&& payload
.idTagInfo
.status
=== 'Accepted') {
734 this.sendStatusNotification(transactionConnectorId
, 'Available');
735 logger
.info(this._basicFormatLog() + ' Transaction ' + this._connectors
[transactionConnectorId
].transactionId
+ ' STOPPED on ' + this._stationInfo
.name
+ '#' + transactionConnectorId
);
736 this._resetTransactionOnConnector(transactionConnectorId
);
738 logger
.error(this._basicFormatLog() + ' Stopping transaction id ' + this._connectors
[transactionConnectorId
].transactionId
+ ' REJECTED with status ' + payload
.idTagInfo
.status
);
742 handleResponseStatusNotification(payload
, requestPayload
) {
743 logger
.debug(this._basicFormatLog() + ' Status notification response received: %j to status notification request: %j', payload
, requestPayload
);
746 handleResponseMeterValues(payload
, requestPayload
) {
747 logger
.debug(this._basicFormatLog() + ' MeterValues response received: %j to MeterValues request: %j', payload
, requestPayload
);
750 handleResponseHeartbeat(payload
, requestPayload
) {
751 logger
.debug(this._basicFormatLog() + ' Heartbeat response received: %j to Heartbeat request: %j', payload
, requestPayload
);
754 async
handleRequest(messageId
, commandName
, commandPayload
) {
756 this._statistics
.addMessage(commandName
, true);
758 if (typeof this['handle' + commandName
] === 'function') {
761 result
= await
this['handle' + commandName
](commandPayload
);
764 logger
.error(this._basicFormatLog() + ' Handle request error: ' + error
);
765 // Send back response to inform backend
766 await
this.sendError(messageId
, error
);
770 await
this.sendError(messageId
, new OCPPError(Constants
.OCPP_ERROR_NOT_IMPLEMENTED
, 'Not implemented', {}));
771 throw new Error(`${commandName} is not implemented ${JSON.stringify(commandPayload, null, ' ')}`);
774 await
this.sendMessage(messageId
, result
, Constants
.OCPP_JSON_CALL_RESULT_MESSAGE
);
777 async
handleReset(commandPayload
) {
778 // Simulate charging station restart
779 setImmediate(async () => {
780 await
this.stop(commandPayload
.type
);
781 await Utils
.sleep(this._stationInfo
.resetTime
);
784 logger
.info(`${this._basicFormatLog()} ${commandPayload.type} reset command received, simulating it. The station will be back online in ${this._stationInfo.resetTime}ms`);
785 return Constants
.OCPP_RESPONSE_ACCEPTED
;
788 _getConfigurationKey(key
) {
789 return this._configuration
.configurationKey
.find((configElement
) => configElement
.key
=== key
);
792 _addConfigurationKey(key
, value
, readonly
= false, visible
= true, reboot
= false) {
793 const keyFound
= this._getConfigurationKey(key
);
795 this._configuration
.configurationKey
.push({
805 _setConfigurationKeyValue(key
, value
) {
806 const keyFound
= this._getConfigurationKey(key
);
808 const keyIndex
= this._configuration
.configurationKey
.indexOf(keyFound
);
809 this._configuration
.configurationKey
[keyIndex
].value
= value
;
813 async
handleGetConfiguration(commandPayload
) {
814 const configurationKey
= [];
815 const unknownKey
= [];
816 if (Utils
.isEmptyArray(commandPayload
.key
)) {
817 for (const configuration
of this._configuration
.configurationKey
) {
818 if (Utils
.isUndefined(configuration
.visible
)) {
819 configuration
.visible
= true;
821 configuration
.visible
= Utils
.convertToBoolean(configuration
.visible
);
823 if (!configuration
.visible
) {
826 configurationKey
.push({
827 key
: configuration
.key
,
828 readonly
: configuration
.readonly
,
829 value
: configuration
.value
,
833 for (const configurationKey
of commandPayload
.key
) {
834 const keyFound
= this._getConfigurationKey(configurationKey
);
836 if (Utils
.isUndefined(keyFound
.visible
)) {
837 keyFound
.visible
= true;
839 keyFound
.visible
= Utils
.convertToBoolean(configurationKey
.visible
);
841 if (!keyFound
.visible
) {
844 configurationKey
.push({
846 readonly
: keyFound
.readonly
,
847 value
: keyFound
.value
,
850 unknownKey
.push(configurationKey
);
860 async
handleChangeConfiguration(commandPayload
) {
861 const keyToChange
= this._getConfigurationKey(commandPayload
.key
);
863 return {status
: Constants
.OCPP_ERROR_NOT_SUPPORTED
};
864 } else if (keyToChange
&& Utils
.convertToBoolean(keyToChange
.readonly
)) {
865 return Constants
.OCPP_RESPONSE_REJECTED
;
866 } else if (keyToChange
&& !Utils
.convertToBoolean(keyToChange
.readonly
)) {
867 const keyIndex
= this._configuration
.configurationKey
.indexOf(keyToChange
);
868 this._configuration
.configurationKey
[keyIndex
].value
= commandPayload
.value
;
869 let triggerHeartbeatRestart
= false;
870 if (keyToChange
.key
=== 'HeartBeatInterval') {
871 this._setConfigurationKeyValue('HeartbeatInterval', commandPayload
.value
);
872 triggerHeartbeatRestart
= true;
874 if (keyToChange
.key
=== 'HeartbeatInterval') {
875 this._setConfigurationKeyValue('HeartBeatInterval', commandPayload
.value
);
876 triggerHeartbeatRestart
= true;
878 if (triggerHeartbeatRestart
) {
879 this._heartbeatInterval
= Utils
.convertToInt(commandPayload
.value
) * 1000;
881 this._stopHeartbeat();
883 this._startHeartbeat(this);
885 if (Utils
.convertToBoolean(keyToChange
.reboot
)) {
886 return Constants
.OCPP_RESPONSE_REBOOT_REQUIRED
;
888 return Constants
.OCPP_RESPONSE_ACCEPTED
;
892 async
handleRemoteStartTransaction(commandPayload
) {
893 const transactionConnectorID
= commandPayload
.connectorId
? commandPayload
.connectorId
: '1';
894 if (this.hasAuthorizedTags() && this._getLocalAuthListEnabled() && this._getAuthorizeRemoteTxRequests()) {
895 // Check if authorized
896 if (this._authorizedTags
.find((value
) => value
=== commandPayload
.idTag
)) {
897 // Authorization successful start transaction
898 this.sendStartTransactionWithTimeout(transactionConnectorID
, commandPayload
.idTag
, Constants
.START_TRANSACTION_TIMEOUT
);
899 logger
.debug(this._basicFormatLog() + ' Transaction remotely STARTED on ' + this._stationInfo
.name
+ '#' + transactionConnectorID
+ ' for idTag ' + commandPayload
.idTag
);
900 return Constants
.OCPP_RESPONSE_ACCEPTED
;
902 logger
.error(this._basicFormatLog() + ' Remote starting transaction REJECTED with status ' + commandPayload
.idTagInfo
.status
+ ', idTag ' + commandPayload
.idTag
);
903 return Constants
.OCPP_RESPONSE_REJECTED
;
905 // No local authorization check required => start transaction
906 this.sendStartTransactionWithTimeout(transactionConnectorID
, commandPayload
.idTag
, Constants
.START_TRANSACTION_TIMEOUT
);
907 logger
.debug(this._basicFormatLog() + ' Transaction remotely STARTED on ' + this._stationInfo
.name
+ '#' + transactionConnectorID
+ ' for idTag ' + commandPayload
.idTag
);
908 return Constants
.OCPP_RESPONSE_ACCEPTED
;
911 async
handleRemoteStopTransaction(commandPayload
) {
912 for (const connector
in this._connectors
) {
913 if (this._connectors
[connector
].transactionId
=== commandPayload
.transactionId
) {
914 this.sendStopTransaction(commandPayload
.transactionId
);
915 return Constants
.OCPP_RESPONSE_ACCEPTED
;
918 logger
.info(this._basicFormatLog() + ' Try to stop remotely a non existing transaction ' + commandPayload
.transactionId
);
919 return Constants
.OCPP_RESPONSE_REJECTED
;
923 module
.exports
= ChargingStation
;