// Partial Copyright Jerome Benoit. 2021-2023. All Rights Reserved.
-import crypto from 'crypto';
import fs from 'fs';
+import crypto from 'node:crypto';
import path from 'path';
import { URL } from 'url';
import { parentPort } from 'worker_threads';
import {
type ChargingStationTemplate,
CurrentType,
- type FirmwareUpgrade,
PowerUnits,
type WsOptions,
} from '../types/ChargingStationTemplate';
import type { ConnectorStatus } from '../types/ConnectorStatus';
import { FileType } from '../types/FileType';
import type { JsonType } from '../types/JsonType';
-import { ChargingProfile, ChargingRateUnitType } from '../types/ocpp/ChargingProfile';
import {
ConnectorPhaseRotation,
StandardParametersKey,
type IncomingRequest,
IncomingRequestCommand,
type MeterValuesRequest,
+ type OutgoingRequest,
RequestCommand,
type ResponseCallback,
type StatusNotificationRequest,
private get wsConnectionUrl(): URL {
return new URL(
- (this.getSupervisionUrlOcppConfiguration()
- ? ChargingStationConfigurationUtils.getConfigurationKey(
- this,
- this.getSupervisionUrlOcppKey()
- ).value
- : this.configuredSupervisionUrl.href) +
- '/' +
- this.stationInfo.chargingStationId
+ `${
+ this.getSupervisionUrlOcppConfiguration()
+ ? ChargingStationConfigurationUtils.getConfigurationKey(
+ this,
+ this.getSupervisionUrlOcppKey()
+ ).value
+ : this.configuredSupervisionUrl.href
+ }/${this.stationInfo.chargingStationId}`
);
}
: defaultVoltageOut;
}
+ public getMaximumPower(stationInfo?: ChargingStationInfo): number {
+ const localStationInfo = stationInfo ?? this.stationInfo;
+ return (localStationInfo['maxPower'] as number) ?? localStationInfo.maximumPower;
+ }
+
public getConnectorMaximumAvailablePower(connectorId: number): number {
let connectorAmperageLimitationPowerLimit: number;
if (
this.powerDivider;
}
const connectorMaximumPower = this.getMaximumPower() / this.powerDivider;
- const connectorChargingProfilePowerLimit = this.getChargingProfilePowerLimit(connectorId);
+ const connectorChargingProfilesPowerLimit =
+ ChargingStationUtils.getChargingStationConnectorChargingProfilesPowerLimit(this, connectorId);
return Math.min(
isNaN(connectorMaximumPower) ? Infinity : connectorMaximumPower,
isNaN(connectorAmperageLimitationPowerLimit)
? Infinity
: connectorAmperageLimitationPowerLimit,
- isNaN(connectorChargingProfilePowerLimit) ? Infinity : connectorChargingProfilePowerLimit
+ isNaN(connectorChargingProfilesPowerLimit) ? Infinity : connectorChargingProfilesPowerLimit
);
}
public getEnergyActiveImportRegisterByTransactionId(
transactionId: number,
- meterStop = false
+ rounded = false
): number {
return this.getEnergyActiveImportRegister(
this.getConnectorStatus(this.getConnectorIdByTransactionId(transactionId)),
- meterStop
+ rounded
);
}
- public getEnergyActiveImportRegisterByConnectorId(connectorId: number): number {
- return this.getEnergyActiveImportRegister(this.getConnectorStatus(connectorId));
+ public getEnergyActiveImportRegisterByConnectorId(connectorId: number, rounded = false): number {
+ return this.getEnergyActiveImportRegister(this.getConnectorStatus(connectorId), rounded);
}
public getAuthorizeRemoteTxRequests(): boolean {
this.getHeartbeatInterval() > 0 &&
!this.heartbeatSetInterval
) {
- // eslint-disable-next-line @typescript-eslint/no-misused-promises
- this.heartbeatSetInterval = setInterval(async (): Promise<void> => {
- await this.ocppRequestService.requestHandler<HeartbeatRequest, HeartbeatResponse>(
- this,
- RequestCommand.HEARTBEAT
- );
+ this.heartbeatSetInterval = setInterval(() => {
+ this.ocppRequestService
+ .requestHandler<HeartbeatRequest, HeartbeatResponse>(this, RequestCommand.HEARTBEAT)
+ .catch((error) => {
+ logger.error(
+ `${this.logPrefix()} Error while sending '${RequestCommand.HEARTBEAT}':`,
+ error
+ );
+ });
}, this.getHeartbeatInterval());
logger.info(
- this.logPrefix() +
- ' Heartbeat started every ' +
- Utils.formatDurationMilliSeconds(this.getHeartbeatInterval())
+ `${this.logPrefix()} Heartbeat started every ${Utils.formatDurationMilliSeconds(
+ this.getHeartbeatInterval()
+ )}`
);
} else if (this.heartbeatSetInterval) {
logger.info(
- this.logPrefix() +
- ' Heartbeat already started every ' +
- Utils.formatDurationMilliSeconds(this.getHeartbeatInterval())
+ `${this.logPrefix()} Heartbeat already started every ${Utils.formatDurationMilliSeconds(
+ this.getHeartbeatInterval()
+ )}`
);
} else {
logger.error(
return;
}
if (interval > 0) {
- // eslint-disable-next-line @typescript-eslint/no-misused-promises
- this.getConnectorStatus(connectorId).transactionSetInterval = setInterval(
- // eslint-disable-next-line @typescript-eslint/no-misused-promises
- async (): Promise<void> => {
- // FIXME: Implement OCPP version agnostic helpers
- const meterValue: MeterValue = OCPP16ServiceUtils.buildMeterValue(
- this,
- connectorId,
- this.getConnectorStatus(connectorId).transactionId,
- interval
- );
- await this.ocppRequestService.requestHandler<MeterValuesRequest, MeterValuesResponse>(
+ this.getConnectorStatus(connectorId).transactionSetInterval = setInterval(() => {
+ // FIXME: Implement OCPP version agnostic helpers
+ const meterValue: MeterValue = OCPP16ServiceUtils.buildMeterValue(
+ this,
+ connectorId,
+ this.getConnectorStatus(connectorId).transactionId,
+ interval
+ );
+ this.ocppRequestService
+ .requestHandler<MeterValuesRequest, MeterValuesResponse>(
this,
RequestCommand.METER_VALUES,
{
transactionId: this.getConnectorStatus(connectorId).transactionId,
meterValue: [meterValue],
}
- );
- },
- interval
- );
+ )
+ .catch((error) => {
+ logger.error(
+ `${this.logPrefix()} Error while sending '${RequestCommand.METER_VALUES}':`,
+ error
+ );
+ });
+ }, interval);
} else {
logger.error(
`${this.logPrefix()} Charging station ${
case OCPPVersion.VERSION_16:
case OCPPVersion.VERSION_20:
case OCPPVersion.VERSION_201:
- protocol = 'ocpp' + ocppVersion;
+ protocol = `ocpp${ocppVersion}`;
break;
default:
this.handleUnsupportedVersion(ocppVersion);
private flushMessageBuffer(): void {
if (this.messageBuffer.size > 0) {
this.messageBuffer.forEach((message) => {
- // TODO: evaluate the need to track performance
+ let beginId: string;
+ let commandName: RequestCommand;
+ const [messageType] = JSON.parse(message) as OutgoingRequest | Response | ErrorResponse;
+ const isRequest = messageType === MessageType.CALL_MESSAGE;
+ if (isRequest) {
+ [, , commandName] = JSON.parse(message) as OutgoingRequest;
+ beginId = PerformanceStatistics.beginMeasure(commandName);
+ }
this.wsConnection.send(message);
+ isRequest && PerformanceStatistics.endMeasure(commandName, beginId);
+ logger.debug(
+ `${this.logPrefix()} >> Buffered ${OCPPServiceUtils.getMessageTypeString(
+ messageType
+ )} payload sent: ${message}`
+ );
this.messageBuffer.delete(message);
});
}
private initialize(): void {
this.configurationFile = path.join(
path.dirname(this.templateFile.replace('station-templates', 'configurations')),
- ChargingStationUtils.getHashId(this.index, this.getTemplateFromFile()) + '.json'
+ `${ChargingStationUtils.getHashId(this.index, this.getTemplateFromFile())}.json`
);
this.stationInfo = this.getStationInfo();
this.saveStationInfo();
logger.debug(
`${this.logPrefix()} << Command '${
requestCommandName ?? Constants.UNKNOWN_COMMAND
- }' received error payload: ${JSON.stringify(request)}`
+ }' received error response payload: ${JSON.stringify(request)}`
);
errorCallback(new OCPPError(errorType, errorMessage, requestCommandName, errorDetails));
break;
}
private onPing(): void {
- logger.debug(this.logPrefix() + ' Received a WS ping (rfc6455) from the server');
+ logger.debug(`${this.logPrefix()} Received a WS ping (rfc6455) from the server`);
}
private onPong(): void {
- logger.debug(this.logPrefix() + ' Received a WS pong (rfc6455) from the server');
+ logger.debug(`${this.logPrefix()} Received a WS pong (rfc6455) from the server`);
}
private onError(error: WSError): void {
this.closeWSConnection();
- logger.error(this.logPrefix() + ' WebSocket error:', error);
+ logger.error(`${this.logPrefix()} WebSocket error:`, error);
}
- private getEnergyActiveImportRegister(
- connectorStatus: ConnectorStatus,
- meterStop = false
- ): number {
+ private getEnergyActiveImportRegister(connectorStatus: ConnectorStatus, rounded = false): number {
if (this.getMeteringPerTransaction() === true) {
return (
- (meterStop === true
+ (rounded === true
? Math.round(connectorStatus?.transactionEnergyActiveImportRegisterValue)
: connectorStatus?.transactionEnergyActiveImportRegisterValue) ?? 0
);
}
return (
- (meterStop === true
+ (rounded === true
? Math.round(connectorStatus?.energyActiveImportRegisterValue)
: connectorStatus?.energyActiveImportRegisterValue) ?? 0
);
return powerDivider;
}
- private getMaximumPower(stationInfo?: ChargingStationInfo): number {
- const localStationInfo = stationInfo ?? this.stationInfo;
- return (localStationInfo['maxPower'] as number) ?? localStationInfo.maximumPower;
- }
-
private getMaximumAmperage(stationInfo: ChargingStationInfo): number | undefined {
const maximumPower = this.getMaximumPower(stationInfo);
switch (this.getCurrentOutType(stationInfo)) {
}
}
- private getChargingProfilePowerLimit(connectorId: number): number | undefined {
- let limit: number, matchingChargingProfile: ChargingProfile;
- let chargingProfiles: ChargingProfile[] = [];
- // Get charging profiles for connector and sort by stack level
- chargingProfiles = this.getConnectorStatus(connectorId).chargingProfiles.sort(
- (a, b) => b.stackLevel - a.stackLevel
- );
- // Get profiles on connector 0
- if (this.getConnectorStatus(0).chargingProfiles) {
- chargingProfiles.push(
- ...this.getConnectorStatus(0).chargingProfiles.sort((a, b) => b.stackLevel - a.stackLevel)
- );
- }
- if (!Utils.isEmptyArray(chargingProfiles)) {
- const result = ChargingStationUtils.getLimitFromChargingProfiles(
- chargingProfiles,
- this.logPrefix()
- );
- if (!Utils.isNullOrUndefined(result)) {
- limit = result.limit;
- matchingChargingProfile = result.matchingChargingProfile;
- switch (this.getCurrentOutType()) {
- case CurrentType.AC:
- limit =
- matchingChargingProfile.chargingSchedule.chargingRateUnit ===
- ChargingRateUnitType.WATT
- ? limit
- : ACElectricUtils.powerTotal(this.getNumberOfPhases(), this.getVoltageOut(), limit);
- break;
- case CurrentType.DC:
- limit =
- matchingChargingProfile.chargingSchedule.chargingRateUnit ===
- ChargingRateUnitType.WATT
- ? limit
- : DCElectricUtils.power(this.getVoltageOut(), limit);
- }
- const connectorMaximumPower = this.getMaximumPower() / this.powerDivider;
- if (limit > connectorMaximumPower) {
- logger.error(
- `${this.logPrefix()} Charging profile id ${
- matchingChargingProfile.chargingProfileId
- } limit ${limit} is greater than connector id ${connectorId} maximum ${connectorMaximumPower}, dump charging profiles' stack: %j`,
- this.getConnectorStatus(connectorId).chargingProfiles
- );
- limit = connectorMaximumPower;
- }
- }
- }
- return limit;
- }
-
private async startMessageSequence(): Promise<void> {
if (this.stationInfo?.autoRegister === true) {
await this.ocppRequestService.requestHandler<
}
}, webSocketPingInterval * 1000);
logger.info(
- this.logPrefix() +
- ' WebSocket ping started every ' +
- Utils.formatDurationSeconds(webSocketPingInterval)
+ `${this.logPrefix()} WebSocket ping started every ${Utils.formatDurationSeconds(
+ webSocketPingInterval
+ )}`
);
} else if (this.webSocketPingSetInterval) {
logger.info(
- this.logPrefix() +
- ' WebSocket ping already started every ' +
- Utils.formatDurationSeconds(webSocketPingInterval)
+ `${this.logPrefix()} WebSocket ping already started every ${Utils.formatDurationSeconds(
+ webSocketPingInterval
+ )}`
);
} else {
logger.error(
);
await Utils.sleep(reconnectDelay);
logger.error(
- this.logPrefix() + ' WebSocket connection retry #' + this.autoReconnectRetryCount.toString()
+ `${this.logPrefix()} WebSocket connection retry #${this.autoReconnectRetryCount.toString()}`
);
this.openWSConnection(
{ ...(this.stationInfo?.wsOptions ?? {}), handshakeTimeout: reconnectTimeout },