X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2FChargingStation.ts;h=6797515f076fc40385f53ca2c6baf1e7de516a38;hb=d0641efac20e7bc7c114a3183574b6cad8667733;hp=e7f8166e38caa679ee366243974138e57cafe775;hpb=03df629e6ac438a6963cf7241ccd767ed1b8530c;p=e-mobility-charging-stations-simulator.git

diff --git a/src/charging-station/ChargingStation.ts b/src/charging-station/ChargingStation.ts
index e7f8166e..6797515f 100644
--- a/src/charging-station/ChargingStation.ts
+++ b/src/charging-station/ChargingStation.ts
@@ -6,7 +6,7 @@ import ChargingStationTemplate, { PowerOutType } from '../types/ChargingStationT
 import Connectors, { Connector } from '../types/Connectors';
 import { MeterValue, MeterValueLocation, MeterValueMeasurand, MeterValuePhase, MeterValueUnit, MeterValuesRequest, MeterValuesResponse, SampledValue } from '../types/ocpp/1.6/MeterValues';
 import { PerformanceObserver, performance } from 'perf_hooks';
-import Requests, { BootNotificationRequest, ChangeConfigurationRequest, GetConfigurationRequest, HeartbeatRequest, RemoteStartTransactionRequest, RemoteStopTransactionRequest, ResetRequest, SetChargingProfileRequest, StatusNotificationRequest, UnlockConnectorRequest } from '../types/ocpp/1.6/Requests';
+import Requests, { BootNotificationRequest, ChangeConfigurationRequest, GetConfigurationRequest, HeartbeatRequest, IncomingRequest, IncomingRequestCommand, RemoteStartTransactionRequest, RemoteStopTransactionRequest, Request, RequestCommand, ResetRequest, SetChargingProfileRequest, StatusNotificationRequest, UnlockConnectorRequest } from '../types/ocpp/1.6/Requests';
 import WebSocket, { MessageEvent } from 'ws';
 
 import AutomaticTransactionGenerator from './AutomaticTransactionGenerator';
@@ -16,10 +16,13 @@ import ChargingStationInfo from '../types/ChargingStationInfo';
 import Configuration from '../utils/Configuration';
 import Constants from '../utils/Constants';
 import ElectricUtils from '../utils/ElectricUtils';
+import { ErrorType } from '../types/ocpp/ErrorType';
 import MeasurandValues from '../types/MeasurandValues';
+import { MessageType } from '../types/ocpp/MessageType';
 import OCPPError from './OcppError';
 import Statistics from '../utils/Statistics';
 import Utils from '../utils/Utils';
+import { WebSocketCloseEventStatusCode } from '../types/WebSocket';
 import crypto from 'crypto';
 import fs from 'fs';
 import logger from '../utils/Logger';
@@ -38,9 +41,7 @@ export default class ChargingStation {
   private _wsConnection: WebSocket;
   private _hasStopped: boolean;
   private _hasSocketRestarted: boolean;
-  private _connectionTimeout: number;
   private _autoReconnectRetryCount: number;
-  private _autoReconnectMaxRetries: number;
   private _requests: Requests;
   private _messageQueue: string[];
   private _automaticTransactionGeneration: AutomaticTransactionGenerator;
@@ -109,8 +110,6 @@ export default class ChargingStation {
     this._configuration = this._getTemplateChargingStationConfiguration();
     this._supervisionUrl = this._getSupervisionURL();
     this._wsConnectionUrl = this._supervisionUrl + '/' + this._stationInfo.name;
-    this._connectionTimeout = this._getConnectionTimeout() * 1000; // Ms, zero for disabling
-    this._autoReconnectMaxRetries = this._getAutoReconnectMaxRetries(); // -1 for unlimited
     // Build connectors if needed
     const maxConnectors = this._getMaxNumberOfConnectors();
     if (maxConnectors <= 0) {
@@ -136,14 +135,14 @@ export default class ChargingStation {
       let lastConnector = '0';
       for (lastConnector in this._stationInfo.Connectors) {
         if (Utils.convertToInt(lastConnector) === 0 && this._getUseConnectorId0() && this._stationInfo.Connectors[lastConnector]) {
-          this._connectors[lastConnector] = Utils.cloneObject(this._stationInfo.Connectors[lastConnector]) as Connector;
+          this._connectors[lastConnector] = Utils.cloneObject<Connector>(this._stationInfo.Connectors[lastConnector]);
         }
       }
       // Generate all connectors
       if ((this._stationInfo.Connectors[0] ? templateMaxConnectors - 1 : templateMaxConnectors) > 0) {
         for (let index = 1; index <= maxConnectors; index++) {
           const randConnectorID = this._stationInfo.randomConnectors ? Utils.getRandomInt(Utils.convertToInt(lastConnector), 1) : index;
-          this._connectors[index] = Utils.cloneObject(this._stationInfo.Connectors[randConnectorID]) as Connector;
+          this._connectors[index] = Utils.cloneObject<Connector>(this._stationInfo.Connectors[randConnectorID]);
         }
       }
     }
@@ -184,6 +183,14 @@ export default class ChargingStation {
     return Utils.logPrefix(` ${this._stationInfo.name}:`);
   }
 
+  _isWebSocketOpen(): boolean {
+    return this._wsConnection?.readyState === WebSocket.OPEN;
+  }
+
+  _isRegistered(): boolean {
+    return this._bootNotificationResponse?.status === RegistrationStatus.ACCEPTED;
+  }
+
   _getTemplateChargingStationConfiguration(): ChargingStationConfiguration {
     return this._stationInfo.Configuration ? this._stationInfo.Configuration : {} as ChargingStationConfiguration;
   }
@@ -231,7 +238,7 @@ export default class ChargingStation {
   _getNumberOfPhases(): number {
     switch (this._getPowerOutType()) {
       case PowerOutType.AC:
-        return !Utils.isUndefined(this._stationInfo.numberOfPhases) ? Utils.convertToInt(this._stationInfo.numberOfPhases) : 3;
+        return !Utils.isUndefined(this._stationInfo.numberOfPhases) ? this._stationInfo.numberOfPhases : 3;
       case PowerOutType.DC:
         return 0;
     }
@@ -247,6 +254,7 @@ export default class ChargingStation {
     return trxCount;
   }
 
+  // 0 for disabling
   _getConnectionTimeout(): number {
     if (!Utils.isUndefined(this._stationInfo.connectionTimeout)) {
       return this._stationInfo.connectionTimeout;
@@ -257,6 +265,7 @@ export default class ChargingStation {
     return 30;
   }
 
+  // -1 for unlimited, 0 for disabling
   _getAutoReconnectMaxRetries(): number {
     if (!Utils.isUndefined(this._stationInfo.autoReconnectMaxRetries)) {
       return this._stationInfo.autoReconnectMaxRetries;
@@ -267,6 +276,14 @@ export default class ChargingStation {
     return -1;
   }
 
+  // 0 for disabling
+  _getRegistrationMaxRetries(): number {
+    if (!Utils.isUndefined(this._stationInfo.registrationMaxRetries)) {
+      return this._stationInfo.registrationMaxRetries;
+    }
+    return -1;
+  }
+
   _getPowerDivider(): number {
     let powerDivider = this._getNumberOfConnectors();
     if (this._stationInfo.powerSharedByConnectors) {
@@ -315,7 +332,7 @@ export default class ChargingStation {
         logger.error(errMsg);
         throw Error(errMsg);
     }
-    return !Utils.isUndefined(this._stationInfo.voltageOut) ? Utils.convertToInt(this._stationInfo.voltageOut) : defaultVoltageOut;
+    return !Utils.isUndefined(this._stationInfo.voltageOut) ? this._stationInfo.voltageOut : defaultVoltageOut;
   }
 
   _getTransactionIdTag(transactionId: number): string {
@@ -339,7 +356,7 @@ export default class ChargingStation {
   }
 
   _getSupervisionURL(): string {
-    const supervisionUrls = Utils.cloneObject(this._stationInfo.supervisionURL ? this._stationInfo.supervisionURL : Configuration.getSupervisionURLs()) as string | string[];
+    const supervisionUrls = Utils.cloneObject<string | string[]>(this._stationInfo.supervisionURL ? this._stationInfo.supervisionURL : Configuration.getSupervisionURLs());
     let indexUrl = 0;
     if (!Utils.isEmptyArray(supervisionUrls)) {
       if (Configuration.getDistributeStationsToTenantsEqually()) {
@@ -427,7 +444,7 @@ export default class ChargingStation {
     const webSocketPingInterval: number = this._getConfigurationKey('WebSocketPingInterval') ? Utils.convertToInt(this._getConfigurationKey('WebSocketPingInterval').value) : 0;
     if (webSocketPingInterval > 0 && !this._webSocketPingSetInterval) {
       this._webSocketPingSetInterval = setInterval(() => {
-        if (this._wsConnection?.readyState === WebSocket.OPEN) {
+        if (this._isWebSocketOpen()) {
           this._wsConnection.ping((): void => { });
         }
       }, webSocketPingInterval * 1000);
@@ -536,12 +553,15 @@ export default class ChargingStation {
     }
   }
 
-  _openWSConnection(options?: WebSocket.ClientOptions): void {
+  _openWSConnection(options?: WebSocket.ClientOptions, forceCloseOpened = false): void {
     if (Utils.isUndefined(options)) {
       options = {} as WebSocket.ClientOptions;
     }
     if (Utils.isUndefined(options.handshakeTimeout)) {
-      options.handshakeTimeout = this._connectionTimeout;
+      options.handshakeTimeout = this._getConnectionTimeout() * 1000;
+    }
+    if (this._isWebSocketOpen() && forceCloseOpened) {
+      this._wsConnection.close();
     }
     this._wsConnection = new WebSocket(this._wsConnectionUrl, 'ocpp' + Constants.OCPP_VERSION_16, options);
     logger.info(this._logPrefix() + ' Will communicate through URL ' + this._supervisionUrl);
@@ -575,7 +595,7 @@ export default class ChargingStation {
         await this.sendStatusNotification(Utils.convertToInt(connector), ChargePointStatus.UNAVAILABLE);
       }
     }
-    if (this._wsConnection?.readyState === WebSocket.OPEN) {
+    if (this._isWebSocketOpen()) {
       this._wsConnection.close();
     }
     this._bootNotificationResponse = null;
@@ -583,7 +603,6 @@ export default class ChargingStation {
   }
 
   async _reconnect(error): Promise<void> {
-    logger.error(this._logPrefix() + ' Socket: abnormally closed: %j', error);
     // Stop heartbeat
     this._stopHeartbeat();
     // Stop the ATG if needed
@@ -593,68 +612,67 @@ export default class ChargingStation {
       !this._automaticTransactionGeneration.timeToStop) {
       this._automaticTransactionGeneration.stop().catch(() => { });
     }
-    if (this._autoReconnectRetryCount < this._autoReconnectMaxRetries || this._autoReconnectMaxRetries === -1) {
+    if (this._autoReconnectRetryCount < this._getAutoReconnectMaxRetries() || this._getAutoReconnectMaxRetries() === -1) {
       this._autoReconnectRetryCount++;
-      const reconnectDelay = (this._getReconnectExponentialDelay() ? Utils.exponentialDelay(this._autoReconnectRetryCount) : this._connectionTimeout);
+      const reconnectDelay = (this._getReconnectExponentialDelay() ? Utils.exponentialDelay(this._autoReconnectRetryCount) : this._getConnectionTimeout() * 1000);
       logger.error(`${this._logPrefix()} Socket: connection retry in ${Utils.roundTo(reconnectDelay, 2)}ms, timeout ${reconnectDelay - 100}ms`);
       await Utils.sleep(reconnectDelay);
       logger.error(this._logPrefix() + ' Socket: reconnecting try #' + this._autoReconnectRetryCount.toString());
       this._openWSConnection({ handshakeTimeout: reconnectDelay - 100 });
-    } else if (this._autoReconnectMaxRetries !== -1) {
-      logger.error(`${this._logPrefix()} Socket: max retries reached (${this._autoReconnectRetryCount}) or retry disabled (${this._autoReconnectMaxRetries})`);
+      this._hasSocketRestarted = true;
+    } else if (this._getAutoReconnectMaxRetries() !== -1) {
+      logger.error(`${this._logPrefix()} Socket reconnect failure: max retries reached (${this._autoReconnectRetryCount}) or retry disabled (${this._getAutoReconnectMaxRetries()})`);
     }
   }
 
   async onOpen(): Promise<void> {
     logger.info(`${this._logPrefix()} Is connected to server through ${this._wsConnectionUrl}`);
-    if (!this._hasSocketRestarted || this._hasStopped) {
+    if (!this._isRegistered()) {
       // Send BootNotification
-      this._bootNotificationResponse = await this.sendBootNotification();
-    }
-    if (this._bootNotificationResponse.status === RegistrationStatus.ACCEPTED) {
-      await this._startMessageSequence();
-    } else {
+      let registrationRetryCount = 0;
       do {
-        await Utils.sleep(Utils.convertToInt(this._bootNotificationResponse.interval) * 1000);
-        // Resend BootNotification
         this._bootNotificationResponse = await this.sendBootNotification();
-      } while (this._bootNotificationResponse.status !== RegistrationStatus.ACCEPTED);
+        if (!this._isRegistered()) {
+          registrationRetryCount++;
+          await Utils.sleep(this._bootNotificationResponse.interval * 1000);
+        }
+      } while (!this._isRegistered() && (registrationRetryCount <= this._getRegistrationMaxRetries() || this._getRegistrationMaxRetries() === -1));
     }
-    if (this._hasSocketRestarted && this._bootNotificationResponse.status === RegistrationStatus.ACCEPTED) {
-      if (!Utils.isEmptyArray(this._messageQueue)) {
-        this._messageQueue.forEach((message, index) => {
-          if (this._wsConnection?.readyState === WebSocket.OPEN) {
+    if (this._isRegistered()) {
+      await this._startMessageSequence();
+      if (this._hasSocketRestarted && this._isWebSocketOpen()) {
+        if (!Utils.isEmptyArray(this._messageQueue)) {
+          this._messageQueue.forEach((message, index) => {
             this._messageQueue.splice(index, 1);
             this._wsConnection.send(message);
-          }
-        });
+          });
+        }
       }
+    } else {
+      logger.error(`${this._logPrefix()} Registration failure: max retries reached (${this._getRegistrationMaxRetries()}) or retry disabled (${this._getRegistrationMaxRetries()})`);
     }
     this._autoReconnectRetryCount = 0;
     this._hasSocketRestarted = false;
   }
 
   async onError(errorEvent): Promise<void> {
-    switch (errorEvent.code) {
-      case 'ECONNREFUSED':
-        this._hasSocketRestarted = true;
-        await this._reconnect(errorEvent);
-        break;
-      default:
-        logger.error(this._logPrefix() + ' Socket error: %j', errorEvent);
-        break;
-    }
+    logger.error(this._logPrefix() + ' Socket error: %j', errorEvent);
+    // pragma switch (errorEvent.code) {
+    //   case 'ECONNREFUSED':
+    //     await this._reconnect(errorEvent);
+    //     break;
+    // }
   }
 
   async onClose(closeEvent): Promise<void> {
     switch (closeEvent) {
-      case 1000: // Normal close
-      case 1005:
-        logger.info(this._logPrefix() + ' Socket normally closed: %j', closeEvent);
+      case WebSocketCloseEventStatusCode.CLOSE_NORMAL: // Normal close
+      case WebSocketCloseEventStatusCode.CLOSE_NO_STATUS:
+        logger.info(`${this._logPrefix()} Socket normally closed with status '${Utils.getWebSocketCloseEventStatusString(closeEvent)}'`);
         this._autoReconnectRetryCount = 0;
         break;
       default: // Abnormal close
-        this._hasSocketRestarted = true;
+        logger.error(`${this._logPrefix()} Socket abnormally closed with status '${Utils.getWebSocketCloseEventStatusString(closeEvent)}'`);
         await this._reconnect(closeEvent);
         break;
     }
@@ -669,15 +687,19 @@ export default class ChargingStation {
   }
 
   async onMessage(messageEvent: MessageEvent): Promise<void> {
-    let [messageType, messageId, commandName, commandPayload, errorDetails] = [0, '', Constants.ENTITY_CHARGING_STATION, '', ''];
+    let [messageType, messageId, commandName, commandPayload, errorDetails]: IncomingRequest = [0, '', '' as IncomingRequestCommand, '', ''];
+    let responseCallback: (payload?, requestPayload?) => void;
+    let rejectCallback: (error: OCPPError) => void;
+    let requestPayload: Record<string, unknown>;
+    let errMsg: string;
     try {
       // Parse the message
-      [messageType, messageId, commandName, commandPayload, errorDetails] = JSON.parse(messageEvent.toString());
+      [messageType, messageId, commandName, commandPayload, errorDetails] = JSON.parse(messageEvent.toString()) as IncomingRequest;
 
       // Check the Type of message
       switch (messageType) {
         // Incoming Message
-        case Constants.OCPP_JSON_CALL_MESSAGE:
+        case MessageType.CALL_MESSAGE:
           if (this.getEnableStatistics()) {
             this._statistics.addMessage(commandName, messageType);
           }
@@ -685,10 +707,8 @@ export default class ChargingStation {
           await this.handleRequest(messageId, commandName, commandPayload);
           break;
         // Outcome Message
-        case Constants.OCPP_JSON_CALL_RESULT_MESSAGE:
+        case MessageType.CALL_RESULT_MESSAGE:
           // Respond
-          // eslint-disable-next-line no-case-declarations
-          let responseCallback; let requestPayload;
           if (Utils.isIterable(this._requests[messageId])) {
             [responseCallback, , requestPayload] = this._requests[messageId];
           } else {
@@ -702,13 +722,11 @@ export default class ChargingStation {
           responseCallback(commandName, requestPayload);
           break;
         // Error Message
-        case Constants.OCPP_JSON_CALL_ERROR_MESSAGE:
+        case MessageType.CALL_ERROR_MESSAGE:
           if (!this._requests[messageId]) {
             // Error
             throw new Error(`Error request for unknown message id ${messageId}`);
           }
-          // eslint-disable-next-line no-case-declarations
-          let rejectCallback;
           if (Utils.isIterable(this._requests[messageId])) {
             [, rejectCallback] = this._requests[messageId];
           } else {
@@ -719,35 +737,32 @@ export default class ChargingStation {
           break;
         // Error
         default:
-          // eslint-disable-next-line no-case-declarations
-          const errMsg = `${this._logPrefix()} Wrong message type ${messageType}`;
+          errMsg = `${this._logPrefix()} Wrong message type ${messageType}`;
           logger.error(errMsg);
           throw new Error(errMsg);
       }
     } catch (error) {
       // Log
-      logger.error('%s Incoming message %j processing error %s on request content type %s', this._logPrefix(), messageEvent, error, this._requests[messageId]);
+      logger.error('%s Incoming message %j processing error %j on request content type %j', this._logPrefix(), messageEvent, error, this._requests[messageId]);
       // Send error
-      messageType !== Constants.OCPP_JSON_CALL_ERROR_MESSAGE && await this.sendError(messageId, error, commandName);
+      messageType !== MessageType.CALL_ERROR_MESSAGE && await this.sendError(messageId, error, commandName);
     }
   }
 
   async sendHeartbeat(): Promise<void> {
     try {
       const payload: HeartbeatRequest = {};
-      await this.sendMessage(Utils.generateUUID(), payload, Constants.OCPP_JSON_CALL_MESSAGE, 'Heartbeat');
+      await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, RequestCommand.HEARTBEAT);
     } catch (error) {
-      logger.error(this._logPrefix() + ' Send Heartbeat error: %j', error);
-      throw error;
+      this.handleRequestError(RequestCommand.HEARTBEAT, error);
     }
   }
 
   async sendBootNotification(): Promise<BootNotificationResponse> {
     try {
-      return await this.sendMessage(Utils.generateUUID(), this._bootNotificationRequest, Constants.OCPP_JSON_CALL_MESSAGE, 'BootNotification') as BootNotificationResponse;
+      return await this.sendMessage(Utils.generateUUID(), this._bootNotificationRequest, MessageType.CALL_MESSAGE, RequestCommand.BOOT_NOTIFICATION) as BootNotificationResponse;
     } catch (error) {
-      logger.error(this._logPrefix() + ' Send BootNotification error: %j', error);
-      throw error;
+      this.handleRequestError(RequestCommand.BOOT_NOTIFICATION, error);
     }
   }
 
@@ -759,10 +774,9 @@ export default class ChargingStation {
         errorCode,
         status,
       };
-      await this.sendMessage(Utils.generateUUID(), payload, Constants.OCPP_JSON_CALL_MESSAGE, 'StatusNotification');
+      await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, RequestCommand.STATUS_NOTIFICATION);
     } catch (error) {
-      logger.error(this._logPrefix() + ' Send StatusNotification error: %j', error);
-      throw error;
+      this.handleRequestError(RequestCommand.STATUS_NOTIFICATION, error);
     }
   }
 
@@ -774,10 +788,9 @@ export default class ChargingStation {
         meterStart: 0,
         timestamp: new Date().toISOString(),
       };
-      return await this.sendMessage(Utils.generateUUID(), payload, Constants.OCPP_JSON_CALL_MESSAGE, 'StartTransaction') as StartTransactionResponse;
+      return await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, RequestCommand.START_TRANSACTION) as StartTransactionResponse;
     } catch (error) {
-      logger.error(this._logPrefix() + ' Send StartTransaction error: %j', error);
-      throw error;
+      this.handleRequestError(RequestCommand.START_TRANSACTION, error);
     }
   }
 
@@ -791,10 +804,9 @@ export default class ChargingStation {
         timestamp: new Date().toISOString(),
         ...reason && { reason },
       };
-      return await this.sendMessage(Utils.generateUUID(), payload, Constants.OCPP_JSON_CALL_MESSAGE, 'StopTransaction') as StartTransactionResponse;
+      return await this.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, RequestCommand.STOP_TRANSACTION) as StartTransactionResponse;
     } catch (error) {
-      logger.error(this._logPrefix() + ' Send StopTransaction error: %j', error);
-      throw error;
+      this.handleRequestError(RequestCommand.STOP_TRANSACTION, error);
     }
   }
 
@@ -1012,47 +1024,46 @@ export default class ChargingStation {
         transactionId: self.getConnector(connectorId).transactionId,
         meterValue: meterValue,
       };
-      await self.sendMessage(Utils.generateUUID(), payload, Constants.OCPP_JSON_CALL_MESSAGE, 'MeterValues');
+      await self.sendMessage(Utils.generateUUID(), payload, MessageType.CALL_MESSAGE, RequestCommand.METERVALUES);
     } catch (error) {
-      logger.error(self._logPrefix() + ' Send MeterValues error: %j', error);
-      throw error;
+      this.handleRequestError(RequestCommand.METERVALUES, error);
     }
   }
 
-  async sendError(messageId: string, err: Error | OCPPError, commandName: string): Promise<unknown> {
+  async sendError(messageId: string, err: Error | OCPPError, commandName: RequestCommand | IncomingRequestCommand): Promise<unknown> {
     // Check exception type: only OCPP error are accepted
-    const error = err instanceof OCPPError ? err : new OCPPError(Constants.OCPP_ERROR_INTERNAL_ERROR, err.message, err.stack && err.stack);
+    const error = err instanceof OCPPError ? err : new OCPPError(ErrorType.INTERNAL_ERROR, err.message, err.stack && err.stack);
     // Send error
-    return this.sendMessage(messageId, error, Constants.OCPP_JSON_CALL_ERROR_MESSAGE, commandName);
+    return this.sendMessage(messageId, error, MessageType.CALL_ERROR_MESSAGE, commandName);
   }
 
-  async sendMessage(messageId: string, commandParams, messageType = Constants.OCPP_JSON_CALL_RESULT_MESSAGE, commandName: string): Promise<any> {
+  async sendMessage(messageId: string, commandParams, messageType = MessageType.CALL_RESULT_MESSAGE, commandName: RequestCommand | IncomingRequestCommand): Promise<any> {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const self = this;
     // Send a message through wsConnection
     return new Promise((resolve: (value?: any | PromiseLike<any>) => void, reject: (reason?: any) => void) => {
-      let messageToSend;
+      let messageToSend: string;
       // Type of message
       switch (messageType) {
         // Request
-        case Constants.OCPP_JSON_CALL_MESSAGE:
+        case MessageType.CALL_MESSAGE:
           // Build request
-          this._requests[messageId] = [responseCallback, rejectCallback, commandParams];
+          this._requests[messageId] = [responseCallback, rejectCallback, commandParams] as Request;
           messageToSend = JSON.stringify([messageType, messageId, commandName, commandParams]);
           break;
         // Response
-        case Constants.OCPP_JSON_CALL_RESULT_MESSAGE:
+        case MessageType.CALL_RESULT_MESSAGE:
           // Build response
           messageToSend = JSON.stringify([messageType, messageId, commandParams]);
           break;
         // Error Message
-        case Constants.OCPP_JSON_CALL_ERROR_MESSAGE:
+        case MessageType.CALL_ERROR_MESSAGE:
           // Build Error Message
-          messageToSend = JSON.stringify([messageType, messageId, commandParams.code ? commandParams.code : Constants.OCPP_ERROR_GENERIC_ERROR, commandParams.message ? commandParams.message : '', commandParams.details ? commandParams.details : {}]);
+          messageToSend = JSON.stringify([messageType, messageId, commandParams.code ? commandParams.code : ErrorType.GENERIC_ERROR, commandParams.message ? commandParams.message : '', commandParams.details ? commandParams.details : {}]);
           break;
       }
-      // Check if wsConnection is ready
-      if (this._wsConnection?.readyState === WebSocket.OPEN) {
+      // Check if wsConnection opened and charging station registered
+      if (this._isWebSocketOpen() && (this._isRegistered() || commandName === RequestCommand.BOOT_NOTIFICATION)) {
         if (this.getEnableStatistics()) {
           this._statistics.addMessage(commandName, messageType);
         }
@@ -1063,7 +1074,7 @@ export default class ChargingStation {
         // Handle dups in buffer
         for (const message of this._messageQueue) {
           // Same message
-          if (JSON.stringify(messageToSend) === JSON.stringify(message)) {
+          if (messageToSend === message) {
             dups = true;
             break;
           }
@@ -1073,15 +1084,15 @@ export default class ChargingStation {
           this._messageQueue.push(messageToSend);
         }
         // Reject it
-        return rejectCallback(new OCPPError(commandParams.code ? commandParams.code : Constants.OCPP_ERROR_GENERIC_ERROR, commandParams.message ? commandParams.message : `WebSocket closed for message id '${messageId}' with content '${messageToSend}', message buffered`, commandParams.details ? commandParams.details : {}));
+        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 : {}));
       }
       // Response?
-      if (messageType === Constants.OCPP_JSON_CALL_RESULT_MESSAGE) {
+      if (messageType === MessageType.CALL_RESULT_MESSAGE) {
         // Yes: send Ok
         resolve();
-      } else if (messageType === Constants.OCPP_JSON_CALL_ERROR_MESSAGE) {
+      } else if (messageType === MessageType.CALL_ERROR_MESSAGE) {
         // Send timeout
-        setTimeout(() => rejectCallback(new OCPPError(commandParams.code ? commandParams.code : Constants.OCPP_ERROR_GENERIC_ERROR, commandParams.message ? commandParams.message : `Timeout for message id '${messageId}' with content '${messageToSend}'`, commandParams.details ? commandParams.details : {})), Constants.OCPP_SOCKET_TIMEOUT);
+        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);
       }
 
       // Function that will receive the request's response
@@ -1090,7 +1101,7 @@ export default class ChargingStation {
           self._statistics.addMessage(commandName, messageType);
         }
         // Send the response
-        await self.handleResponse(commandName, payload, requestPayload);
+        await self.handleResponse(commandName as RequestCommand, payload, requestPayload);
         resolve(payload);
       }
 
@@ -1109,7 +1120,7 @@ export default class ChargingStation {
     });
   }
 
-  async handleResponse(commandName: string, payload, requestPayload): Promise<void> {
+  async handleResponse(commandName: RequestCommand, payload, requestPayload): Promise<void> {
     const responseCallbackFn = 'handleResponse' + commandName;
     if (typeof this[responseCallbackFn] === 'function') {
       await this[responseCallbackFn](payload, requestPayload);
@@ -1120,10 +1131,10 @@ export default class ChargingStation {
 
   handleResponseBootNotification(payload: BootNotificationResponse, requestPayload: BootNotificationRequest): void {
     if (payload.status === RegistrationStatus.ACCEPTED) {
-      this._heartbeatInterval = Utils.convertToInt(payload.interval) * 1000;
+      this._heartbeatInterval = payload.interval * 1000;
       this._heartbeatSetInterval ? this._restartHeartbeat() : this._startHeartbeat();
-      this._addConfigurationKey('HeartBeatInterval', payload.interval);
-      this._addConfigurationKey('HeartbeatInterval', payload.interval, false, false);
+      this._addConfigurationKey('HeartBeatInterval', payload.interval.toString());
+      this._addConfigurationKey('HeartbeatInterval', payload.interval.toString(), false, false);
       this._hasStopped && (this._hasStopped = false);
     } else if (payload.status === RegistrationStatus.PENDING) {
       logger.info(this._logPrefix() + ' Charging station in pending state on the central server');
@@ -1147,7 +1158,7 @@ export default class ChargingStation {
   }
 
   async handleResponseStartTransaction(payload: StartTransactionResponse, requestPayload: StartTransactionRequest): Promise<void> {
-    const connectorId = Utils.convertToInt(requestPayload.connectorId);
+    const connectorId = requestPayload.connectorId;
     if (this.getConnector(connectorId).transactionStarted) {
       logger.debug(this._logPrefix() + ' Trying to start a transaction on an already used connector ' + connectorId.toString() + ': %j', this.getConnector(connectorId));
       return;
@@ -1187,7 +1198,7 @@ export default class ChargingStation {
   async handleResponseStopTransaction(payload: StopTransactionResponse, requestPayload: StopTransactionRequest): Promise<void> {
     let transactionConnectorId: number;
     for (const connector in this._connectors) {
-      if (Utils.convertToInt(connector) > 0 && this.getConnector(Utils.convertToInt(connector)).transactionId === Utils.convertToInt(requestPayload.transactionId)) {
+      if (Utils.convertToInt(connector) > 0 && this.getConnector(Utils.convertToInt(connector)).transactionId === requestPayload.transactionId) {
         transactionConnectorId = Utils.convertToInt(connector);
         break;
       }
@@ -1220,7 +1231,7 @@ export default class ChargingStation {
     logger.debug(this._logPrefix() + ' Heartbeat response received: %j to Heartbeat request: %j', payload, requestPayload);
   }
 
-  async handleRequest(messageId: string, commandName: string, commandPayload): Promise<void> {
+  async handleRequest(messageId: string, commandName: IncomingRequestCommand, commandPayload): Promise<void> {
     let response;
     // Call
     if (typeof this['handleRequest' + commandName] === 'function') {
@@ -1236,11 +1247,11 @@ export default class ChargingStation {
       }
     } else {
       // Throw exception
-      await this.sendError(messageId, new OCPPError(Constants.OCPP_ERROR_NOT_IMPLEMENTED, `${commandName} is not implemented`, {}), commandName);
+      await this.sendError(messageId, new OCPPError(ErrorType.NOT_IMPLEMENTED, `${commandName} is not implemented`, {}), commandName);
       throw new Error(`${commandName} is not implemented ${JSON.stringify(commandPayload, null, ' ')}`);
     }
     // Send response
-    await this.sendMessage(messageId, response, Constants.OCPP_JSON_CALL_RESULT_MESSAGE, commandName);
+    await this.sendMessage(messageId, response, MessageType.CALL_RESULT_MESSAGE, commandName);
   }
 
   // Simulate charging station restart
@@ -1259,7 +1270,7 @@ export default class ChargingStation {
   }
 
   async handleRequestUnlockConnector(commandPayload: UnlockConnectorRequest): Promise<UnlockConnectorResponse> {
-    const connectorId = Utils.convertToInt(commandPayload.connectorId);
+    const connectorId = commandPayload.connectorId;
     if (connectorId === 0) {
       logger.error(this._logPrefix() + ' Trying to unlock connector ' + connectorId.toString());
       return Constants.OCPP_RESPONSE_UNLOCK_NOT_SUPPORTED;
@@ -1275,8 +1286,13 @@ export default class ChargingStation {
     return Constants.OCPP_RESPONSE_UNLOCKED;
   }
 
-  _getConfigurationKey(key: string): ConfigurationKey {
-    return this._configuration.configurationKey.find((configElement) => configElement.key === key);
+  _getConfigurationKey(key: string, caseInsensitive = false): ConfigurationKey {
+    return this._configuration.configurationKey.find((configElement) => {
+      if (caseInsensitive) {
+        return configElement.key.toLowerCase() === key.toLowerCase();
+      }
+      return configElement.key === key;
+    });
   }
 
   _addConfigurationKey(key: string, value: string, readonly = false, visible = true, reboot = false): void {
@@ -1344,7 +1360,14 @@ export default class ChargingStation {
   }
 
   handleRequestChangeConfiguration(commandPayload: ChangeConfigurationRequest): ChangeConfigurationResponse {
-    const keyToChange = this._getConfigurationKey(commandPayload.key);
+    // JSON request fields type sanity check
+    if (!Utils.isString(commandPayload.key)) {
+      logger.error(`${this._logPrefix()} ChangeConfiguration request key field is not a string:`, commandPayload);
+    }
+    if (!Utils.isString(commandPayload.value)) {
+      logger.error(`${this._logPrefix()} ChangeConfiguration request value field is not a string:`, commandPayload);
+    }
+    const keyToChange = this._getConfigurationKey(commandPayload.key, true);
     if (!keyToChange) {
       return Constants.OCPP_CONFIGURATION_RESPONSE_NOT_SUPPORTED;
     } else if (keyToChange && keyToChange.readonly) {
@@ -1399,7 +1422,7 @@ export default class ChargingStation {
   }
 
   async handleRequestRemoteStartTransaction(commandPayload: RemoteStartTransactionRequest): Promise<DefaultResponse> {
-    const transactionConnectorID: number = commandPayload.connectorId ? Utils.convertToInt(commandPayload.connectorId) : 1;
+    const transactionConnectorID: number = commandPayload.connectorId ? commandPayload.connectorId : 1;
     if (this._getAuthorizeRemoteTxRequests() && this._getLocalAuthListEnabled() && this.hasAuthorizedTags()) {
       // Check if authorized
       if (this._authorizedTags.find((value) => value === commandPayload.idTag)) {
@@ -1418,7 +1441,7 @@ export default class ChargingStation {
   }
 
   async handleRequestRemoteStopTransaction(commandPayload: RemoteStopTransactionRequest): Promise<DefaultResponse> {
-    const transactionId = Utils.convertToInt(commandPayload.transactionId);
+    const transactionId = commandPayload.transactionId;
     for (const connector in this._connectors) {
       if (Utils.convertToInt(connector) > 0 && this.getConnector(Utils.convertToInt(connector)).transactionId === transactionId) {
         await this.sendStopTransaction(transactionId);
@@ -1428,5 +1451,10 @@ export default class ChargingStation {
     logger.info(this._logPrefix() + ' Trying to remote stop a non existing transaction ' + transactionId.toString());
     return Constants.OCPP_RESPONSE_REJECTED;
   }
+
+  private handleRequestError(commandName: RequestCommand, error: Error) {
+    logger.error(this._logPrefix() + ' Send ' + commandName + ' error: %j', error);
+    throw error;
+  }
 }