// Partial Copyright Jerome Benoit. 2021. All Rights Reserved.
-import { AvailabilityType, BootNotificationRequest, IncomingRequest, IncomingRequestCommand, Request } from '../types/ocpp/Requests';
+import { AvailabilityType, BootNotificationRequest, CachedRequest, IncomingRequest, IncomingRequestCommand, RequestCommand } from '../types/ocpp/Requests';
import { BootNotificationResponse, RegistrationStatus } from '../types/ocpp/Responses';
import ChargingStationConfiguration, { ConfigurationKey } from '../types/ChargingStationConfiguration';
import ChargingStationTemplate, { CurrentType, PowerUnits, Voltage } from '../types/ChargingStationTemplate';
-import { Connector, Connectors, SampledValueTemplate } from '../types/Connectors';
-import { ConnectorPhaseRotation, StandardParametersKey, SupportedFeatureProfiles } from '../types/ocpp/Configuration';
+import { ConnectorPhaseRotation, StandardParametersKey, SupportedFeatureProfiles, VendorDefaultParametersKey } from '../types/ocpp/Configuration';
import { MeterValueMeasurand, MeterValuePhase } from '../types/ocpp/MeterValues';
import { WSError, WebSocketCloseEventStatusCode } from '../types/WebSocket';
import WebSocket, { ClientOptions, Data, OPEN } from 'ws';
import { ChargePointStatus } from '../types/ocpp/ChargePointStatus';
import { ChargingProfile } from '../types/ocpp/ChargingProfile';
import ChargingStationInfo from '../types/ChargingStationInfo';
+import { ChargingStationWorkerMessageEvents } from '../types/ChargingStationWorker';
import { ClientRequestArgs } from 'http';
import Configuration from '../utils/Configuration';
+import { ConnectorStatus } from '../types/ConnectorStatus';
import Constants from '../utils/Constants';
import { ErrorType } from '../types/ocpp/ErrorType';
import FileUtils from '../utils/FileUtils';
import OCPP16IncomingRequestService from './ocpp/1.6/OCPP16IncomingRequestService';
import OCPP16RequestService from './ocpp/1.6/OCPP16RequestService';
import OCPP16ResponseService from './ocpp/1.6/OCPP16ResponseService';
-import OCPPError from './ocpp/OCPPError';
+import OCPPError from '../exception/OCPPError';
import OCPPIncomingRequestService from './ocpp/OCPPIncomingRequestService';
import OCPPRequestService from './ocpp/OCPPRequestService';
import { OCPPVersion } from '../types/ocpp/OCPPVersion';
import PerformanceStatistics from '../performance/PerformanceStatistics';
+import { SampledValueTemplate } from '../types/MeasurandPerPhaseSampledValueTemplates';
import { StopTransactionReason } from '../types/ocpp/Transaction';
+import { SupervisionUrlDistribution } from '../types/ConfigurationData';
import { URL } from 'url';
import Utils from '../utils/Utils';
import crypto from 'crypto';
import fs from 'fs';
import logger from '../utils/Logger';
+import { parentPort } from 'worker_threads';
import path from 'path';
export default class ChargingStation {
- public stationTemplateFile: string;
+ public readonly stationTemplateFile: string;
public authorizedTags: string[];
public stationInfo!: ChargingStationInfo;
- public connectors: Connectors;
+ public readonly connectors: Map<number, ConnectorStatus>;
public configuration!: ChargingStationConfiguration;
public wsConnection!: WebSocket;
- public requests: Map<string, Request>;
+ public readonly requests: Map<string, CachedRequest>;
public performanceStatistics!: PerformanceStatistics;
public heartbeatSetInterval!: NodeJS.Timeout;
public ocppRequestService!: OCPPRequestService;
- private index: number;
+ private readonly index: number;
private bootNotificationRequest!: BootNotificationRequest;
private bootNotificationResponse!: BootNotificationResponse | null;
private connectorsConfigurationHash!: string;
private ocppIncomingRequestService!: OCPPIncomingRequestService;
- private messageQueue: string[];
- private wsConnectionUrl!: URL;
+ private readonly messageBuffer: Set<string>;
+ private wsConfiguredConnectionUrl!: URL;
private wsConnectionRestarted: boolean;
private stopped: boolean;
private autoReconnectRetryCount: number;
constructor(index: number, stationTemplateFile: string) {
this.index = index;
this.stationTemplateFile = stationTemplateFile;
- this.connectors = {} as Connectors;
+ this.connectors = new Map<number, ConnectorStatus>();
this.initialize();
this.stopped = false;
this.wsConnectionRestarted = false;
this.autoReconnectRetryCount = 0;
- this.requests = new Map<string, Request>();
- this.messageQueue = new Array<string>();
+ this.requests = new Map<string, CachedRequest>();
+ this.messageBuffer = new Set<string>();
this.authorizedTags = this.getAuthorizedTags();
}
+ get wsConnectionUrl(): URL {
+ return this.getSupervisionUrlOcppConfiguration() ? new URL(this.getConfigurationKey(this.stationInfo.supervisionUrlOcppKey ?? VendorDefaultParametersKey.ConnectionUrl).value + '/' + this.stationInfo.chargingStationId) : this.wsConfiguredConnectionUrl;
+ }
+
public logPrefix(): string {
return Utils.logPrefix(` ${this.stationInfo.chargingStationId} |`);
}
}
public isWebSocketConnectionOpened(): boolean {
- return this.wsConnection?.readyState === OPEN;
+ return this?.wsConnection?.readyState === OPEN;
+ }
+
+ public isInPendingState(): boolean {
+ return this?.bootNotificationResponse?.status === RegistrationStatus.PENDING;
+ }
+
+ public isInAcceptedState(): boolean {
+ return this?.bootNotificationResponse?.status === RegistrationStatus.ACCEPTED;
+ }
+
+ public isInRejectedState(): boolean {
+ return this?.bootNotificationResponse?.status === RegistrationStatus.REJECTED;
}
public isRegistered(): boolean {
- return this.bootNotificationResponse?.status === RegistrationStatus.ACCEPTED;
+ return this.isInAcceptedState() || this.isInPendingState();
}
public isChargingStationAvailable(): boolean {
- return this.getConnector(0).availability === AvailabilityType.OPERATIVE;
+ return this.getConnectorStatus(0).availability === AvailabilityType.OPERATIVE;
}
public isConnectorAvailable(id: number): boolean {
- return this.getConnector(id).availability === AvailabilityType.OPERATIVE;
+ return this.getConnectorStatus(id).availability === AvailabilityType.OPERATIVE;
+ }
+
+ public getNumberOfConnectors(): number {
+ return this.connectors.get(0) ? this.connectors.size - 1 : this.connectors.size;
}
- public getConnector(id: number): Connector {
- return this.connectors[id];
+ public getConnectorStatus(id: number): ConnectorStatus {
+ return this.connectors.get(id);
}
public getCurrentOutType(): CurrentType | undefined {
}
public getTransactionIdTag(transactionId: number): string | undefined {
- for (const connector in this.connectors) {
- if (Utils.convertToInt(connector) > 0 && this.getConnector(Utils.convertToInt(connector)).transactionId === transactionId) {
- return this.getConnector(Utils.convertToInt(connector)).transactionIdTag;
+ for (const connectorId of this.connectors.keys()) {
+ if (connectorId > 0 && this.getConnectorStatus(connectorId).transactionId === transactionId) {
+ return this.getConnectorStatus(connectorId).transactionIdTag;
}
}
}
public getEnergyActiveImportRegisterByTransactionId(transactionId: number): number | undefined {
if (this.getMeteringPerTransaction()) {
- for (const connector in this.connectors) {
- if (Utils.convertToInt(connector) > 0 && this.getConnector(Utils.convertToInt(connector)).transactionId === transactionId) {
- return this.getConnector(Utils.convertToInt(connector)).transactionEnergyActiveImportRegisterValue;
+ for (const connectorId of this.connectors.keys()) {
+ if (connectorId > 0 && this.getConnectorStatus(connectorId).transactionId === transactionId) {
+ return this.getConnectorStatus(connectorId).transactionEnergyActiveImportRegisterValue;
}
}
}
- for (const connector in this.connectors) {
- if (Utils.convertToInt(connector) > 0 && this.getConnector(Utils.convertToInt(connector)).transactionId === transactionId) {
- return this.getConnector(Utils.convertToInt(connector)).energyActiveImportRegisterValue;
+ for (const connectorId of this.connectors.keys()) {
+ if (connectorId > 0 && this.getConnectorStatus(connectorId).transactionId === transactionId) {
+ return this.getConnectorStatus(connectorId).energyActiveImportRegisterValue;
}
}
}
public getEnergyActiveImportRegisterByConnectorId(connectorId: number): number | undefined {
if (this.getMeteringPerTransaction()) {
- return this.getConnector(connectorId).transactionEnergyActiveImportRegisterValue;
+ return this.getConnectorStatus(connectorId).transactionEnergyActiveImportRegisterValue;
}
- return this.getConnector(connectorId).energyActiveImportRegisterValue;
+ return this.getConnectorStatus(connectorId).energyActiveImportRegisterValue;
}
public getAuthorizeRemoteTxRequests(): boolean {
logger.debug(`${this.logPrefix()} Trying to get MeterValues measurand '${measurand}' ${phase ? `on phase ${phase} ` : ''}in template on connectorId ${connectorId} not found in '${StandardParametersKey.MeterValuesSampledData}' OCPP parameter`);
return;
}
- const sampledValueTemplates: SampledValueTemplate[] = this.getConnector(connectorId).MeterValues;
+ const sampledValueTemplates: SampledValueTemplate[] = this.getConnectorStatus(connectorId).MeterValues;
for (let index = 0; !Utils.isEmptyArray(sampledValueTemplates) && index < sampledValueTemplates.length; index++) {
if (!Constants.SUPPORTED_MEASURANDS.includes(sampledValueTemplates[index]?.measurand ?? MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER)) {
logger.warn(`${this.logPrefix()} Unsupported MeterValues measurand '${measurand}' ${phase ? `on phase ${phase} ` : ''}in template on connectorId ${connectorId}`);
} else if (phase && sampledValueTemplates[index]?.phase === phase && sampledValueTemplates[index]?.measurand === measurand
- && this.getConfigurationKey(StandardParametersKey.MeterValuesSampledData).value.includes(measurand)) {
+ && this.getConfigurationKey(StandardParametersKey.MeterValuesSampledData).value.includes(measurand)) {
return sampledValueTemplates[index];
} else if (!phase && !sampledValueTemplates[index].phase && sampledValueTemplates[index]?.measurand === measurand
- && this.getConfigurationKey(StandardParametersKey.MeterValuesSampledData).value.includes(measurand)) {
+ && this.getConfigurationKey(StandardParametersKey.MeterValuesSampledData).value.includes(measurand)) {
return sampledValueTemplates[index];
} else if (measurand === MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER
- && (!sampledValueTemplates[index].measurand || sampledValueTemplates[index].measurand === measurand)) {
+ && (!sampledValueTemplates[index].measurand || sampledValueTemplates[index].measurand === measurand)) {
return sampledValueTemplates[index];
}
}
logger.error(`${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId.toString()}`);
return;
}
- if (!this.getConnector(connectorId)) {
+ if (!this.getConnectorStatus(connectorId)) {
logger.error(`${this.logPrefix()} Trying to start MeterValues on non existing connector Id ${connectorId.toString()}`);
return;
}
- if (!this.getConnector(connectorId)?.transactionStarted) {
+ if (!this.getConnectorStatus(connectorId)?.transactionStarted) {
logger.error(`${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId} with no transaction started`);
return;
- } else if (this.getConnector(connectorId)?.transactionStarted && !this.getConnector(connectorId)?.transactionId) {
+ } else if (this.getConnectorStatus(connectorId)?.transactionStarted && !this.getConnectorStatus(connectorId)?.transactionId) {
logger.error(`${this.logPrefix()} Trying to start MeterValues on connector Id ${connectorId} with no transaction id`);
return;
}
if (interval > 0) {
// eslint-disable-next-line @typescript-eslint/no-misused-promises
- this.getConnector(connectorId).transactionSetInterval = setInterval(async (): Promise<void> => {
- await this.ocppRequestService.sendMeterValues(connectorId, this.getConnector(connectorId).transactionId, interval);
+ this.getConnectorStatus(connectorId).transactionSetInterval = setInterval(async (): Promise<void> => {
+ await this.ocppRequestService.sendMeterValues(connectorId, this.getConnectorStatus(connectorId).transactionId, interval);
}, interval);
} else {
logger.error(`${this.logPrefix()} Charging station ${StandardParametersKey.MeterValueSampleInterval} configuration set to ${interval ? Utils.formatDurationMilliSeconds(interval) : interval}, not sending MeterValues`);
this.startAuthorizationFileMonitoring();
// Monitor station template file
this.startStationTemplateFileMonitoring();
- // Handle Socket incoming messages
+ // Handle WebSocket message
this.wsConnection.on('message', this.onMessage.bind(this));
- // Handle Socket error
+ // Handle WebSocket error
this.wsConnection.on('error', this.onError.bind(this));
- // Handle Socket close
+ // Handle WebSocket close
this.wsConnection.on('close', this.onClose.bind(this));
- // Handle Socket opening connection
+ // Handle WebSocket open
this.wsConnection.on('open', this.onOpen.bind(this));
- // Handle Socket ping
+ // Handle WebSocket ping
this.wsConnection.on('ping', this.onPing.bind(this));
- // Handle Socket pong
+ // Handle WebSocket pong
this.wsConnection.on('pong', this.onPong.bind(this));
+ parentPort.postMessage({ id: ChargingStationWorkerMessageEvents.STARTED, data: { id: this.stationInfo.chargingStationId } });
}
public async stop(reason: StopTransactionReason = StopTransactionReason.NONE): Promise<void> {
// Stop message sequence
await this.stopMessageSequence(reason);
- for (const connector in this.connectors) {
- if (Utils.convertToInt(connector) > 0) {
- await this.ocppRequestService.sendStatusNotification(Utils.convertToInt(connector), ChargePointStatus.UNAVAILABLE);
- this.getConnector(Utils.convertToInt(connector)).status = ChargePointStatus.UNAVAILABLE;
+ for (const connectorId of this.connectors.keys()) {
+ if (connectorId > 0) {
+ await this.ocppRequestService.sendStatusNotification(connectorId, ChargePointStatus.UNAVAILABLE);
+ this.getConnectorStatus(connectorId).status = ChargePointStatus.UNAVAILABLE;
}
}
if (this.isWebSocketConnectionOpened()) {
this.performanceStatistics.stop();
}
this.bootNotificationResponse = null;
+ parentPort.postMessage({ id: ChargingStationWorkerMessageEvents.STOPPED, data: { id: this.stationInfo.chargingStationId } });
this.stopped = true;
}
});
}
- public addConfigurationKey(key: string | StandardParametersKey, value: string, readonly = false, visible = true, reboot = false): void {
+ public addConfigurationKey(key: string | StandardParametersKey, value: string, options: { readonly?: boolean, visible?: boolean, reboot?: boolean } = { readonly: false, visible: true, reboot: false }): void {
const keyFound = this.getConfigurationKey(key);
+ const readonly = options.readonly;
+ const visible = options.visible;
+ const reboot = options.reboot;
if (!keyFound) {
this.configuration.configurationKey.push({
key,
public setChargingProfile(connectorId: number, cp: ChargingProfile): void {
let cpReplaced = false;
- if (!Utils.isEmptyArray(this.getConnector(connectorId).chargingProfiles)) {
- this.getConnector(connectorId).chargingProfiles?.forEach((chargingProfile: ChargingProfile, index: number) => {
+ if (!Utils.isEmptyArray(this.getConnectorStatus(connectorId).chargingProfiles)) {
+ this.getConnectorStatus(connectorId).chargingProfiles?.forEach((chargingProfile: ChargingProfile, index: number) => {
if (chargingProfile.chargingProfileId === cp.chargingProfileId
- || (chargingProfile.stackLevel === cp.stackLevel && chargingProfile.chargingProfilePurpose === cp.chargingProfilePurpose)) {
- this.getConnector(connectorId).chargingProfiles[index] = cp;
+ || (chargingProfile.stackLevel === cp.stackLevel && chargingProfile.chargingProfilePurpose === cp.chargingProfilePurpose)) {
+ this.getConnectorStatus(connectorId).chargingProfiles[index] = cp;
cpReplaced = true;
}
});
}
- !cpReplaced && this.getConnector(connectorId).chargingProfiles?.push(cp);
+ !cpReplaced && this.getConnectorStatus(connectorId).chargingProfiles?.push(cp);
}
- public resetTransactionOnConnector(connectorId: number): void {
- this.getConnector(connectorId).authorized = false;
- this.getConnector(connectorId).transactionStarted = false;
- delete this.getConnector(connectorId).authorizeIdTag;
- delete this.getConnector(connectorId).transactionId;
- delete this.getConnector(connectorId).transactionIdTag;
- this.getConnector(connectorId).transactionEnergyActiveImportRegisterValue = 0;
- delete this.getConnector(connectorId).transactionBeginMeterValue;
+ public resetConnectorStatus(connectorId: number): void {
+ this.getConnectorStatus(connectorId).idTagLocalAuthorized = false;
+ this.getConnectorStatus(connectorId).idTagAuthorized = false;
+ this.getConnectorStatus(connectorId).transactionRemoteStarted = false;
+ this.getConnectorStatus(connectorId).transactionStarted = false;
+ delete this.getConnectorStatus(connectorId).localAuthorizeIdTag;
+ delete this.getConnectorStatus(connectorId).authorizeIdTag;
+ delete this.getConnectorStatus(connectorId).transactionId;
+ delete this.getConnectorStatus(connectorId).transactionIdTag;
+ this.getConnectorStatus(connectorId).transactionEnergyActiveImportRegisterValue = 0;
+ delete this.getConnectorStatus(connectorId).transactionBeginMeterValue;
this.stopMeterValues(connectorId);
}
- public addToMessageQueue(message: string): void {
- let dups = false;
- // Handle dups in message queue
- for (const bufferedMessage of this.messageQueue) {
- // Message already in the queue
- if (message === bufferedMessage) {
- dups = true;
- break;
- }
- }
- if (!dups) {
- // Queue message
- this.messageQueue.push(message);
- }
+ public bufferMessage(message: string): void {
+ this.messageBuffer.add(message);
}
- private flushMessageQueue() {
- if (!Utils.isEmptyArray(this.messageQueue)) {
- this.messageQueue.forEach((message, index) => {
- this.messageQueue.splice(index, 1);
+ private flushMessageBuffer() {
+ if (this.messageBuffer.size > 0) {
+ this.messageBuffer.forEach((message) => {
// TODO: evaluate the need to track performance
this.wsConnection.send(message);
+ this.messageBuffer.delete(message);
});
}
}
+ private getSupervisionUrlOcppConfiguration(): boolean {
+ return this.stationInfo.supervisionUrlOcppConfiguration ?? false;
+ }
+
private getChargingStationId(stationTemplate: ChargingStationTemplate): string {
// In case of multiple instances: add instance index to charging station id
const instanceIndex = process.env.CF_INSTANCE_INDEX ?? 0;
stationTemplateFromFile = JSON.parse(fs.readFileSync(fileDescriptor, 'utf8')) as ChargingStationTemplate;
fs.closeSync(fileDescriptor);
} catch (error) {
- FileUtils.handleFileException(this.logPrefix(), 'Template', this.stationTemplateFile, error);
+ FileUtils.handleFileException(this.logPrefix(), 'Template', this.stationTemplateFile, error as NodeJS.ErrnoException);
}
+ const chargingStationId = this.getChargingStationId(stationTemplateFromFile);
+ // Deprecation template keys section
+ this.warnDeprecatedTemplateKey(stationTemplateFromFile, 'supervisionUrl', chargingStationId, 'Use \'supervisionUrls\' instead');
+ this.convertDeprecatedTemplateKey(stationTemplateFromFile, 'supervisionUrl', 'supervisionUrls');
const stationInfo: ChargingStationInfo = stationTemplateFromFile ?? {} as ChargingStationInfo;
+ stationInfo.wsOptions = stationTemplateFromFile?.wsOptions ?? {};
if (!Utils.isEmptyArray(stationTemplateFromFile.power)) {
stationTemplateFromFile.power = stationTemplateFromFile.power as number[];
const powerArrayRandomIndex = Math.floor(Utils.secureRandom() * stationTemplateFromFile.power.length);
}
delete stationInfo.power;
delete stationInfo.powerUnit;
- stationInfo.chargingStationId = this.getChargingStationId(stationTemplateFromFile);
+ stationInfo.chargingStationId = chargingStationId;
stationInfo.resetTime = stationTemplateFromFile.resetTime ? stationTemplateFromFile.resetTime * 1000 : Constants.CHARGING_STATION_DEFAULT_RESET_TIME;
return stationInfo;
}
- private getOCPPVersion(): OCPPVersion {
+ private getOcppVersion(): OCPPVersion {
return this.stationInfo.ocppVersion ? this.stationInfo.ocppVersion : OCPPVersion.VERSION_16;
}
private initialize(): void {
this.stationInfo = this.buildStationInfo();
+ this.configuration = this.getTemplateChargingStationConfiguration();
+ delete this.stationInfo.Configuration;
this.bootNotificationRequest = {
chargePointModel: this.stationInfo.chargePointModel,
chargePointVendor: this.stationInfo.chargePointVendor,
...!Utils.isUndefined(this.stationInfo.chargeBoxSerialNumberPrefix) && { chargeBoxSerialNumber: this.stationInfo.chargeBoxSerialNumberPrefix },
...!Utils.isUndefined(this.stationInfo.firmwareVersion) && { firmwareVersion: this.stationInfo.firmwareVersion },
};
- this.configuration = this.getTemplateChargingStationConfiguration();
- this.wsConnectionUrl = new URL(this.getSupervisionURL().href + '/' + this.stationInfo.chargingStationId);
// Build connectors if needed
const maxConnectors = this.getMaxNumberOfConnectors();
if (maxConnectors <= 0) {
this.stationInfo.randomConnectors = true;
}
const connectorsConfigHash = crypto.createHash('sha256').update(JSON.stringify(this.stationInfo.Connectors) + maxConnectors.toString()).digest('hex');
- // FIXME: Handle shrinking the number of connectors
- if (!this.connectors || (this.connectors && this.connectorsConfigurationHash !== connectorsConfigHash)) {
+ const connectorsConfigChanged = this.connectors?.size !== 0 && this.connectorsConfigurationHash !== connectorsConfigHash;
+ if (this.connectors?.size === 0 || connectorsConfigChanged) {
+ connectorsConfigChanged && (this.connectors.clear());
this.connectorsConfigurationHash = connectorsConfigHash;
// Add connector Id 0
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<Connector>(this.stationInfo.Connectors[lastConnector]);
- this.connectors[lastConnector].availability = AvailabilityType.OPERATIVE;
- if (Utils.isUndefined(this.connectors[lastConnector]?.chargingProfiles)) {
- this.connectors[lastConnector].chargingProfiles = [];
+ const lastConnectorId = Utils.convertToInt(lastConnector);
+ if (lastConnectorId === 0 && this.getUseConnectorId0() && this.stationInfo.Connectors[lastConnector]) {
+ this.connectors.set(lastConnectorId, Utils.cloneObject<ConnectorStatus>(this.stationInfo.Connectors[lastConnector]));
+ this.getConnectorStatus(lastConnectorId).availability = AvailabilityType.OPERATIVE;
+ if (Utils.isUndefined(this.getConnectorStatus(lastConnectorId)?.chargingProfiles)) {
+ this.getConnectorStatus(lastConnectorId).chargingProfiles = [];
}
}
}
if ((this.stationInfo.Connectors[0] ? templateMaxConnectors - 1 : templateMaxConnectors) > 0) {
for (let index = 1; index <= maxConnectors; index++) {
const randConnectorId = this.stationInfo.randomConnectors ? Utils.getRandomInteger(Utils.convertToInt(lastConnector), 1) : index;
- this.connectors[index] = Utils.cloneObject<Connector>(this.stationInfo.Connectors[randConnectorId]);
- this.connectors[index].availability = AvailabilityType.OPERATIVE;
- if (Utils.isUndefined(this.connectors[lastConnector]?.chargingProfiles)) {
- this.connectors[index].chargingProfiles = [];
+ this.connectors.set(index, Utils.cloneObject<ConnectorStatus>(this.stationInfo.Connectors[randConnectorId]));
+ this.getConnectorStatus(index).availability = AvailabilityType.OPERATIVE;
+ if (Utils.isUndefined(this.getConnectorStatus(index)?.chargingProfiles)) {
+ this.getConnectorStatus(index).chargingProfiles = [];
}
}
}
// Avoid duplication of connectors related information
delete this.stationInfo.Connectors;
// Initialize transaction attributes on connectors
- for (const connector in this.connectors) {
- if (Utils.convertToInt(connector) > 0 && !this.getConnector(Utils.convertToInt(connector))?.transactionStarted) {
- this.initTransactionAttributesOnConnector(Utils.convertToInt(connector));
+ for (const connectorId of this.connectors.keys()) {
+ if (connectorId > 0 && !this.getConnectorStatus(connectorId)?.transactionStarted) {
+ this.initializeConnectorStatus(connectorId);
}
}
- switch (this.getOCPPVersion()) {
+ this.wsConfiguredConnectionUrl = new URL(this.getConfiguredSupervisionUrl().href + '/' + this.stationInfo.chargingStationId);
+ switch (this.getOcppVersion()) {
case OCPPVersion.VERSION_16:
this.ocppIncomingRequestService = new OCPP16IncomingRequestService(this);
this.ocppRequestService = new OCPP16RequestService(this, new OCPP16ResponseService(this));
break;
default:
- this.handleUnsupportedVersion(this.getOCPPVersion());
+ this.handleUnsupportedVersion(this.getOcppVersion());
break;
}
// OCPP parameters
- this.initOCPPParameters();
+ this.initOcppParameters();
if (this.stationInfo.autoRegister) {
this.bootNotificationResponse = {
currentTime: new Date().toISOString(),
}
}
- private initOCPPParameters(): void {
+ private initOcppParameters(): void {
+ if (this.getSupervisionUrlOcppConfiguration() && !this.getConfigurationKey(this.stationInfo.supervisionUrlOcppKey ?? VendorDefaultParametersKey.ConnectionUrl)) {
+ this.addConfigurationKey(VendorDefaultParametersKey.ConnectionUrl, this.getConfiguredSupervisionUrl().href, { reboot: true });
+ }
if (!this.getConfigurationKey(StandardParametersKey.SupportedFeatureProfiles)) {
this.addConfigurationKey(StandardParametersKey.SupportedFeatureProfiles, `${SupportedFeatureProfiles.Core},${SupportedFeatureProfiles.Local_Auth_List_Management},${SupportedFeatureProfiles.Smart_Charging}`);
}
- this.addConfigurationKey(StandardParametersKey.NumberOfConnectors, this.getNumberOfConnectors().toString(), true);
+ this.addConfigurationKey(StandardParametersKey.NumberOfConnectors, this.getNumberOfConnectors().toString(), { readonly: true });
if (!this.getConfigurationKey(StandardParametersKey.MeterValuesSampledData)) {
this.addConfigurationKey(StandardParametersKey.MeterValuesSampledData, MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER);
}
if (!this.getConfigurationKey(StandardParametersKey.ConnectorPhaseRotation)) {
const connectorPhaseRotation = [];
- for (const connector in this.connectors) {
+ for (const connectorId of this.connectors.keys()) {
// AC/DC
- if (Utils.convertToInt(connector) === 0 && this.getNumberOfPhases() === 0) {
- connectorPhaseRotation.push(`${connector}.${ConnectorPhaseRotation.RST}`);
- } else if (Utils.convertToInt(connector) > 0 && this.getNumberOfPhases() === 0) {
- connectorPhaseRotation.push(`${connector}.${ConnectorPhaseRotation.NotApplicable}`);
+ if (connectorId === 0 && this.getNumberOfPhases() === 0) {
+ connectorPhaseRotation.push(`${connectorId}.${ConnectorPhaseRotation.RST}`);
+ } else if (connectorId > 0 && this.getNumberOfPhases() === 0) {
+ connectorPhaseRotation.push(`${connectorId}.${ConnectorPhaseRotation.NotApplicable}`);
// AC
- } else if (Utils.convertToInt(connector) > 0 && this.getNumberOfPhases() === 1) {
- connectorPhaseRotation.push(`${connector}.${ConnectorPhaseRotation.NotApplicable}`);
- } else if (Utils.convertToInt(connector) > 0 && this.getNumberOfPhases() === 3) {
- connectorPhaseRotation.push(`${connector}.${ConnectorPhaseRotation.RST}`);
+ } else if (connectorId > 0 && this.getNumberOfPhases() === 1) {
+ connectorPhaseRotation.push(`${connectorId}.${ConnectorPhaseRotation.NotApplicable}`);
+ } else if (connectorId > 0 && this.getNumberOfPhases() === 3) {
+ connectorPhaseRotation.push(`${connectorId}.${ConnectorPhaseRotation.RST}`);
}
}
this.addConfigurationKey(StandardParametersKey.ConnectorPhaseRotation, connectorPhaseRotation.toString());
this.addConfigurationKey(StandardParametersKey.AuthorizeRemoteTxRequests, 'true');
}
if (!this.getConfigurationKey(StandardParametersKey.LocalAuthListEnabled)
- && this.getConfigurationKey(StandardParametersKey.SupportedFeatureProfiles).value.includes(SupportedFeatureProfiles.Local_Auth_List_Management)) {
+ && this.getConfigurationKey(StandardParametersKey.SupportedFeatureProfiles).value.includes(SupportedFeatureProfiles.Local_Auth_List_Management)) {
this.addConfigurationKey(StandardParametersKey.LocalAuthListEnabled, 'false');
}
if (!this.getConfigurationKey(StandardParametersKey.ConnectionTimeOut)) {
}
} while (!this.isRegistered() && (registrationRetryCount <= this.getRegistrationMaxRetries() || this.getRegistrationMaxRetries() === -1));
}
- if (this.isRegistered()) {
+ if (this.isRegistered() && this.stationInfo.autoRegister) {
+ await this.ocppRequestService.sendBootNotification(this.bootNotificationRequest.chargePointModel,
+ this.bootNotificationRequest.chargePointVendor, this.bootNotificationRequest.chargeBoxSerialNumber, this.bootNotificationRequest.firmwareVersion);
+ }
+ if (this.isInAcceptedState()) {
await this.startMessageSequence();
this.stopped && (this.stopped = false);
if (this.wsConnectionRestarted && this.isWebSocketConnectionOpened()) {
- this.flushMessageQueue();
+ this.flushMessageBuffer();
+ }
+ } else if (this.isInPendingState()) {
+ // The central server shall issue a TriggerMessage to the charging station for the boot notification at the end of its configuration process
+ while (!this.isInAcceptedState()) {
+ await Utils.sleep(Constants.CHARGING_STATION_DEFAULT_START_SEQUENCE_DELAY);
+ }
+ await this.startMessageSequence();
+ this.stopped && (this.stopped = false);
+ if (this.wsConnectionRestarted && this.isWebSocketConnectionOpened()) {
+ this.flushMessageBuffer();
}
} else {
logger.error(`${this.logPrefix()} Registration failure: max retries reached (${this.getRegistrationMaxRetries()}) or retry disabled (${this.getRegistrationMaxRetries()})`);
// Normal close
case WebSocketCloseEventStatusCode.CLOSE_NORMAL:
case WebSocketCloseEventStatusCode.CLOSE_NO_STATUS:
- logger.info(`${this.logPrefix()} Socket normally closed with status '${Utils.getWebSocketCloseEventStatusString(code)}' and reason '${reason}'`);
+ logger.info(`${this.logPrefix()} WebSocket normally closed with status '${Utils.getWebSocketCloseEventStatusString(code)}' and reason '${reason}'`);
this.autoReconnectRetryCount = 0;
break;
// Abnormal close
default:
- logger.error(`${this.logPrefix()} Socket abnormally closed with status '${Utils.getWebSocketCloseEventStatusString(code)}' and reason '${reason}'`);
+ logger.error(`${this.logPrefix()} WebSocket abnormally closed with status '${Utils.getWebSocketCloseEventStatusString(code)}' and reason '${reason}'`);
await this.reconnect(code);
break;
}
private async onMessage(data: Data): Promise<void> {
let [messageType, messageId, commandName, commandPayload, errorDetails]: IncomingRequest = [0, '', '' as IncomingRequestCommand, {}, {}];
let responseCallback: (payload: Record<string, unknown> | string, requestPayload: Record<string, unknown>) => void;
- let rejectCallback: (error: OCPPError) => void;
+ let rejectCallback: (error: OCPPError, requestStatistic?: boolean) => void;
+ let requestCommandName: RequestCommand | IncomingRequestCommand;
let requestPayload: Record<string, unknown>;
- let cachedRequest: Request;
+ let cachedRequest: CachedRequest;
let errMsg: string;
try {
const request = JSON.parse(data.toString()) as IncomingRequest;
// Respond
cachedRequest = this.requests.get(messageId);
if (Utils.isIterable(cachedRequest)) {
- [responseCallback, , requestPayload] = cachedRequest;
+ [responseCallback, , , requestPayload] = cachedRequest;
} else {
- throw new OCPPError(ErrorType.PROTOCOL_ERROR, `Response request for message id ${messageId} is not iterable`, commandName);
+ throw new OCPPError(ErrorType.PROTOCOL_ERROR, `Cached request for message id ${messageId} response is not iterable`, commandName);
}
if (!responseCallback) {
// Error
- throw new OCPPError(ErrorType.INTERNAL_ERROR, `Response request for unknown message id ${messageId}`, commandName);
+ throw new OCPPError(ErrorType.INTERNAL_ERROR, `Response for unknown message id ${messageId}`, commandName);
}
- this.requests.delete(messageId);
responseCallback(commandName, requestPayload);
break;
// Error Message
case MessageType.CALL_ERROR_MESSAGE:
cachedRequest = this.requests.get(messageId);
- if (!cachedRequest) {
- // Error
- throw new OCPPError(ErrorType.INTERNAL_ERROR, `Error request for unknown message id ${messageId}`);
- }
if (Utils.isIterable(cachedRequest)) {
- [, rejectCallback] = cachedRequest;
+ [, rejectCallback, requestCommandName] = cachedRequest;
} else {
- throw new OCPPError(ErrorType.PROTOCOL_ERROR, `Error request for message id ${messageId} is not iterable`);
+ throw new OCPPError(ErrorType.PROTOCOL_ERROR, `Cached request for message id ${messageId} error response is not iterable`);
+ }
+ if (!rejectCallback) {
+ // Error
+ throw new OCPPError(ErrorType.INTERNAL_ERROR, `Error response for unknown message id ${messageId}`, requestCommandName);
}
- this.requests.delete(messageId);
- rejectCallback(new OCPPError(commandName, commandPayload.toString(), null, errorDetails));
+ rejectCallback(new OCPPError(commandName, commandPayload.toString(), requestCommandName, errorDetails));
break;
// Error
default:
}
} catch (error) {
// Log
- logger.error('%s Incoming request message %j processing error %j on content type %j', this.logPrefix(), data, error, this.requests.get(messageId));
+ logger.error('%s Incoming OCPP message %j matching cached request %j processing error %j', this.logPrefix(), data.toString(), this.requests.get(messageId), error);
// Send error
- messageType !== MessageType.CALL_ERROR_MESSAGE && await this.ocppRequestService.sendError(messageId, error, commandName);
+ messageType === MessageType.CALL_MESSAGE && await this.ocppRequestService.sendError(messageId, error as OCPPError, commandName);
}
}
}
private async onError(error: WSError): Promise<void> {
- logger.error(this.logPrefix() + ' Socket error: %j', error);
+ logger.error(this.logPrefix() + ' WebSocket error: %j', error);
// switch (error.code) {
// case 'ECONNREFUSED':
// await this.reconnect(error);
authorizedTags = JSON.parse(fs.readFileSync(fileDescriptor, 'utf8')) as string[];
fs.closeSync(fileDescriptor);
} catch (error) {
- FileUtils.handleFileException(this.logPrefix(), 'Authorization', authorizationFile, error);
+ FileUtils.handleFileException(this.logPrefix(), 'Authorization', authorizationFile, error as NodeJS.ErrnoException);
}
} else {
logger.info(this.logPrefix() + ' No authorization file given in template file ' + this.stationTemplateFile);
private getNumberOfRunningTransactions(): number {
let trxCount = 0;
- for (const connector in this.connectors) {
- if (Utils.convertToInt(connector) > 0 && this.getConnector(Utils.convertToInt(connector))?.transactionStarted) {
+ for (const connectorId of this.connectors.keys()) {
+ if (connectorId > 0 && this.getConnectorStatus(connectorId)?.transactionStarted) {
trxCount++;
}
}
}
private getMaxNumberOfConnectors(): number {
- let maxConnectors = 0;
+ let maxConnectors: number;
if (!Utils.isEmptyArray(this.stationInfo.numberOfConnectors)) {
const numberOfConnectors = this.stationInfo.numberOfConnectors as number[];
// Distribute evenly the number of connectors
return maxConnectors;
}
- private getNumberOfConnectors(): number {
- return this.connectors[0] ? Object.keys(this.connectors).length - 1 : Object.keys(this.connectors).length;
- }
-
private async startMessageSequence(): Promise<void> {
// Start WebSocket ping
this.startWebSocketPing();
// Start heartbeat
this.startHeartbeat();
// Initialize connectors status
- for (const connector in this.connectors) {
- if (Utils.convertToInt(connector) === 0) {
+ for (const connectorId of this.connectors.keys()) {
+ if (connectorId === 0) {
continue;
- } else if (!this.stopped && !this.getConnector(Utils.convertToInt(connector))?.status && this.getConnector(Utils.convertToInt(connector))?.bootStatus) {
+ } else if (!this.stopped && !this.getConnectorStatus(connectorId)?.status && this.getConnectorStatus(connectorId)?.bootStatus) {
// Send status in template at startup
- await this.ocppRequestService.sendStatusNotification(Utils.convertToInt(connector), this.getConnector(Utils.convertToInt(connector)).bootStatus);
- this.getConnector(Utils.convertToInt(connector)).status = this.getConnector(Utils.convertToInt(connector)).bootStatus;
- } else if (this.stopped && this.getConnector(Utils.convertToInt(connector))?.bootStatus) {
+ await this.ocppRequestService.sendStatusNotification(connectorId, this.getConnectorStatus(connectorId).bootStatus);
+ this.getConnectorStatus(connectorId).status = this.getConnectorStatus(connectorId).bootStatus;
+ } else if (this.stopped && this.getConnectorStatus(connectorId)?.status && this.getConnectorStatus(connectorId)?.bootStatus) {
// Send status in template after reset
- await this.ocppRequestService.sendStatusNotification(Utils.convertToInt(connector), this.getConnector(Utils.convertToInt(connector)).bootStatus);
- this.getConnector(Utils.convertToInt(connector)).status = this.getConnector(Utils.convertToInt(connector)).bootStatus;
- } else if (!this.stopped && this.getConnector(Utils.convertToInt(connector))?.status) {
+ await this.ocppRequestService.sendStatusNotification(connectorId, this.getConnectorStatus(connectorId).bootStatus);
+ this.getConnectorStatus(connectorId).status = this.getConnectorStatus(connectorId).bootStatus;
+ } else if (!this.stopped && this.getConnectorStatus(connectorId)?.status) {
// Send previous status at template reload
- await this.ocppRequestService.sendStatusNotification(Utils.convertToInt(connector), this.getConnector(Utils.convertToInt(connector)).status);
+ await this.ocppRequestService.sendStatusNotification(connectorId, this.getConnectorStatus(connectorId).status);
} else {
// Send default status
- await this.ocppRequestService.sendStatusNotification(Utils.convertToInt(connector), ChargePointStatus.AVAILABLE);
- this.getConnector(Utils.convertToInt(connector)).status = ChargePointStatus.AVAILABLE;
+ await this.ocppRequestService.sendStatusNotification(connectorId, ChargePointStatus.AVAILABLE);
+ this.getConnectorStatus(connectorId).status = ChargePointStatus.AVAILABLE;
}
}
// Start the ATG
this.automaticTransactionGenerator.started) {
this.automaticTransactionGenerator.stop();
} else {
- for (const connector in this.connectors) {
- if (Utils.convertToInt(connector) > 0 && this.getConnector(Utils.convertToInt(connector))?.transactionStarted) {
- const transactionId = this.getConnector(Utils.convertToInt(connector)).transactionId;
+ for (const connectorId of this.connectors.keys()) {
+ if (connectorId > 0 && this.getConnectorStatus(connectorId)?.transactionStarted) {
+ const transactionId = this.getConnectorStatus(connectorId).transactionId;
await this.ocppRequestService.sendStopTransaction(transactionId, this.getEnergyActiveImportRegisterByTransactionId(transactionId),
this.getTransactionIdTag(transactionId), reason);
}
}
}
- private getSupervisionURL(): URL {
- const supervisionUrls = Utils.cloneObject<string | string[]>(this.stationInfo.supervisionURL ? this.stationInfo.supervisionURL : Configuration.getSupervisionURLs());
- let indexUrl = 0;
+ private warnDeprecatedTemplateKey(template: ChargingStationTemplate, key: string, chargingStationId: string, logMsgToAppend = ''): void {
+ if (!Utils.isUndefined(template[key])) {
+ logger.warn(`${Utils.logPrefix(` ${chargingStationId} |`)} Deprecated template key '${key}' usage in file '${this.stationTemplateFile}'${logMsgToAppend && '. ' + logMsgToAppend}`);
+ }
+ }
+
+ private convertDeprecatedTemplateKey(template: ChargingStationTemplate, deprecatedKey: string, key: string): void {
+ if (!Utils.isUndefined(template[deprecatedKey])) {
+ // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+ template[key] = template[deprecatedKey];
+ delete template[deprecatedKey];
+ }
+ }
+
+ private getConfiguredSupervisionUrl(): URL {
+ const supervisionUrls = Utils.cloneObject<string | string[]>(this.stationInfo.supervisionUrls ?? Configuration.getSupervisionUrls());
if (!Utils.isEmptyArray(supervisionUrls)) {
- if (Configuration.getDistributeStationsToTenantsEqually()) {
- indexUrl = this.index % supervisionUrls.length;
- } else {
- // Get a random url
- indexUrl = Math.floor(Utils.secureRandom() * supervisionUrls.length);
+ let urlIndex = 0;
+ switch (Configuration.getSupervisionUrlDistribution()) {
+ case SupervisionUrlDistribution.ROUND_ROBIN:
+ urlIndex = (this.index - 1) % supervisionUrls.length;
+ break;
+ case SupervisionUrlDistribution.RANDOM:
+ // Get a random url
+ urlIndex = Math.floor(Utils.secureRandom() * supervisionUrls.length);
+ break;
+ case SupervisionUrlDistribution.SEQUENTIAL:
+ if (this.index <= supervisionUrls.length) {
+ urlIndex = this.index - 1;
+ } else {
+ logger.warn(`${this.logPrefix()} No more configured supervision urls available, using the first one`);
+ }
+ break;
+ default:
+ logger.error(`${this.logPrefix()} Unknown supervision url distribution '${Configuration.getSupervisionUrlDistribution()}' from values '${SupervisionUrlDistribution.toString()}', defaulting to ${SupervisionUrlDistribution.ROUND_ROBIN}`);
+ urlIndex = (this.index - 1) % supervisionUrls.length;
+ break;
}
- return new URL(supervisionUrls[indexUrl]);
+ return new URL(supervisionUrls[urlIndex]);
}
return new URL(supervisionUrls as string);
}
}
}
- private openWSConnection(options?: ClientOptions & ClientRequestArgs, forceCloseOpened = false): void {
- options = options ?? {};
+ private openWSConnection(options: ClientOptions & ClientRequestArgs = this.stationInfo.wsOptions, forceCloseOpened = false): void {
options.handshakeTimeout = options?.handshakeTimeout ?? this.getConnectionTimeout() * 1000;
if (!Utils.isNullOrUndefined(this.stationInfo.supervisionUser) && !Utils.isNullOrUndefined(this.stationInfo.supervisionPassword)) {
options.auth = `${this.stationInfo.supervisionUser}:${this.stationInfo.supervisionPassword}`;
if (this.isWebSocketConnectionOpened() && forceCloseOpened) {
this.wsConnection.close();
}
- let protocol;
- switch (this.getOCPPVersion()) {
+ let protocol: string;
+ switch (this.getOcppVersion()) {
case OCPPVersion.VERSION_16:
protocol = 'ocpp' + OCPPVersion.VERSION_16;
break;
default:
- this.handleUnsupportedVersion(this.getOCPPVersion());
+ this.handleUnsupportedVersion(this.getOcppVersion());
break;
}
this.wsConnection = new WebSocket(this.wsConnectionUrl, protocol, options);
}
private stopMeterValues(connectorId: number) {
- if (this.getConnector(connectorId)?.transactionSetInterval) {
- clearInterval(this.getConnector(connectorId).transactionSetInterval);
+ if (this.getConnectorStatus(connectorId)?.transactionSetInterval) {
+ clearInterval(this.getConnectorStatus(connectorId).transactionSetInterval);
}
}
}
});
} catch (error) {
- FileUtils.handleFileException(this.logPrefix(), 'Authorization', authorizationFile, error);
+ FileUtils.handleFileException(this.logPrefix(), 'Authorization', authorizationFile, error as NodeJS.ErrnoException);
}
} else {
logger.info(this.logPrefix() + ' No authorization file given in template file ' + this.stationTemplateFile + '. Not monitoring changes');
this.initialize();
// Restart the ATG
if (!this.stationInfo.AutomaticTransactionGenerator.enable &&
- this.automaticTransactionGenerator) {
+ this.automaticTransactionGenerator) {
this.automaticTransactionGenerator.stop();
}
this.startAutomaticTransactionGenerator();
}
});
} catch (error) {
- FileUtils.handleFileException(this.logPrefix(), 'Template', this.stationTemplateFile, error);
+ FileUtils.handleFileException(this.logPrefix(), 'Template', this.stationTemplateFile, error as NodeJS.ErrnoException);
}
}
if (this.autoReconnectRetryCount < this.getAutoReconnectMaxRetries() || this.getAutoReconnectMaxRetries() === -1) {
this.autoReconnectRetryCount++;
const reconnectDelay = (this.getReconnectExponentialDelay() ? Utils.exponentialDelay(this.autoReconnectRetryCount) : this.getConnectionTimeout() * 1000);
- const reconnectTimeout = reconnectDelay - 100;
- logger.error(`${this.logPrefix()} Socket: connection retry in ${Utils.roundTo(reconnectDelay, 2)}ms, timeout ${reconnectTimeout}ms`);
+ const reconnectTimeout = (reconnectDelay - 100) > 0 && reconnectDelay;
+ logger.error(`${this.logPrefix()} WebSocket: connection retry in ${Utils.roundTo(reconnectDelay, 2)}ms, timeout ${reconnectTimeout}ms`);
await Utils.sleep(reconnectDelay);
- logger.error(this.logPrefix() + ' Socket: reconnecting try #' + this.autoReconnectRetryCount.toString());
- this.openWSConnection({ handshakeTimeout: reconnectTimeout }, true);
+ logger.error(this.logPrefix() + ' WebSocket: reconnecting try #' + this.autoReconnectRetryCount.toString());
+ this.openWSConnection({ ...this.stationInfo.wsOptions, handshakeTimeout: reconnectTimeout }, true);
this.wsConnectionRestarted = true;
} else if (this.getAutoReconnectMaxRetries() !== -1) {
- logger.error(`${this.logPrefix()} Socket reconnect failure: max retries reached (${this.autoReconnectRetryCount}) or retry disabled (${this.getAutoReconnectMaxRetries()})`);
+ logger.error(`${this.logPrefix()} WebSocket reconnect failure: max retries reached (${this.autoReconnectRetryCount}) or retry disabled (${this.getAutoReconnectMaxRetries()})`);
}
}
- private initTransactionAttributesOnConnector(connectorId: number): void {
- this.getConnector(connectorId).authorized = false;
- this.getConnector(connectorId).transactionStarted = false;
- this.getConnector(connectorId).energyActiveImportRegisterValue = 0;
- this.getConnector(connectorId).transactionEnergyActiveImportRegisterValue = 0;
+ private initializeConnectorStatus(connectorId: number): void {
+ this.getConnectorStatus(connectorId).idTagLocalAuthorized = false;
+ this.getConnectorStatus(connectorId).idTagAuthorized = false;
+ this.getConnectorStatus(connectorId).transactionRemoteStarted = false;
+ this.getConnectorStatus(connectorId).transactionStarted = false;
+ this.getConnectorStatus(connectorId).energyActiveImportRegisterValue = 0;
+ this.getConnectorStatus(connectorId).transactionEnergyActiveImportRegisterValue = 0;
}
}
repositories / e-mobility-charging-stations-simulator.git / blobdiff