X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2Focpp%2F1.6%2FOCPP16ServiceUtils.ts;h=b194e08e8d5a58db9641a337bd58b7d27aa5799f;hb=f1e3871b2a063e5ee0fddbf597df76d02f81e332;hp=f5c4df7321b7a8c60be62ead9b9df9bf0d5a125c;hpb=83e00df1c1ba02de8b637ca4cb0464eb909ebb18;p=e-mobility-charging-stations-simulator.git diff --git a/src/charging-station/ocpp/1.6/OCPP16ServiceUtils.ts b/src/charging-station/ocpp/1.6/OCPP16ServiceUtils.ts index f5c4df73..b194e08e 100644 --- a/src/charging-station/ocpp/1.6/OCPP16ServiceUtils.ts +++ b/src/charging-station/ocpp/1.6/OCPP16ServiceUtils.ts @@ -1,49 +1,81 @@ -// Partial Copyright Jerome Benoit. 2021. All Rights Reserved. +// Partial Copyright Jerome Benoit. 2021-2023. All Rights Reserved. -import OCPPError from '../../../exception/OCPPError'; -import { CurrentType, Voltage } from '../../../types/ChargingStationTemplate'; -import type { - MeasurandPerPhaseSampledValueTemplates, - SampledValueTemplate, -} from '../../../types/MeasurandPerPhaseSampledValueTemplates'; -import type { MeasurandValues } from '../../../types/MeasurandValues'; +import type { JSONSchemaType } from 'ajv'; import { - OCPP16StandardParametersKey, - OCPP16SupportedFeatureProfiles, -} from '../../../types/ocpp/1.6/Configuration'; + type Interval, + addSeconds, + areIntervalsOverlapping, + differenceInSeconds, + isAfter, + isBefore, + isWithinInterval, +} from 'date-fns'; + +import { OCPP16Constants } from './OCPP16Constants'; import { + type ChargingStation, + hasFeatureProfile, + hasReservationExpired, +} from '../../../charging-station'; +import { OCPPError } from '../../../exception'; +import { + type ClearChargingProfileRequest, + CurrentType, + ErrorType, + type GenericResponse, + type JsonType, + type MeasurandPerPhaseSampledValueTemplates, + type MeasurandValues, MeterValueContext, MeterValueLocation, MeterValueUnit, - OCPP16MeterValue, + OCPP16AuthorizationStatus, + OCPP16AvailabilityType, + type OCPP16ChangeAvailabilityResponse, + OCPP16ChargePointStatus, + type OCPP16ChargingProfile, + type OCPP16ChargingSchedule, + type OCPP16IncomingRequestCommand, + type OCPP16MeterValue, OCPP16MeterValueMeasurand, OCPP16MeterValuePhase, - OCPP16SampledValue, -} from '../../../types/ocpp/1.6/MeterValues'; -import { - OCPP16IncomingRequestCommand, OCPP16RequestCommand, -} from '../../../types/ocpp/1.6/Requests'; -import { ErrorType } from '../../../types/ocpp/ErrorType'; -import Constants from '../../../utils/Constants'; -import { ACElectricUtils, DCElectricUtils } from '../../../utils/ElectricUtils'; -import logger from '../../../utils/Logger'; -import Utils from '../../../utils/Utils'; -import type ChargingStation from '../../ChargingStation'; -import { ChargingStationUtils } from '../../ChargingStationUtils'; + type OCPP16SampledValue, + OCPP16StandardParametersKey, + OCPP16StopTransactionReason, + type OCPP16SupportedFeatureProfiles, + OCPPVersion, + type SampledValueTemplate, +} from '../../../types'; +import { + ACElectricUtils, + Constants, + DCElectricUtils, + convertToFloat, + convertToInt, + getRandomFloatFluctuatedRounded, + getRandomFloatRounded, + getRandomInteger, + isNotEmptyArray, + isNotEmptyString, + isNullOrUndefined, + isUndefined, + logger, + roundTo, +} from '../../../utils'; import { OCPPServiceUtils } from '../OCPPServiceUtils'; export class OCPP16ServiceUtils extends OCPPServiceUtils { public static checkFeatureProfile( chargingStation: ChargingStation, featureProfile: OCPP16SupportedFeatureProfiles, - command: OCPP16RequestCommand | OCPP16IncomingRequestCommand + command: OCPP16RequestCommand | OCPP16IncomingRequestCommand, ): boolean { - if (!chargingStation.hasFeatureProfile(featureProfile)) { + if (!hasFeatureProfile(chargingStation, featureProfile)) { logger.warn( `${chargingStation.logPrefix()} Trying to '${command}' without '${featureProfile}' feature enabled in ${ OCPP16StandardParametersKey.SupportedFeatureProfiles - } in configuration` + } in configuration`, ); return false; } @@ -55,63 +87,70 @@ export class OCPP16ServiceUtils extends OCPPServiceUtils { connectorId: number, transactionId: number, interval: number, - debug = false + debug = false, ): OCPP16MeterValue { const meterValue: OCPP16MeterValue = { - timestamp: new Date().toISOString(), + timestamp: new Date(), sampledValue: [], }; const connector = chargingStation.getConnectorStatus(connectorId); // SoC measurand - const socSampledValueTemplate = ChargingStationUtils.getSampledValueTemplate( + const socSampledValueTemplate = OCPP16ServiceUtils.getSampledValueTemplate( chargingStation, connectorId, - OCPP16MeterValueMeasurand.STATE_OF_CHARGE + OCPP16MeterValueMeasurand.STATE_OF_CHARGE, ); if (socSampledValueTemplate) { - const socSampledValueTemplateValue = socSampledValueTemplate.value - ? Utils.getRandomFloatFluctuatedRounded( + const socMaximumValue = 100; + const socMinimumValue = socSampledValueTemplate.minimumValue ?? 0; + const socSampledValueTemplateValue = isNotEmptyString(socSampledValueTemplate.value) + ? getRandomFloatFluctuatedRounded( parseInt(socSampledValueTemplate.value), - socSampledValueTemplate.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT + socSampledValueTemplate.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT, ) - : Utils.getRandomInteger(100); + : getRandomInteger(socMaximumValue, socMinimumValue); meterValue.sampledValue.push( - OCPP16ServiceUtils.buildSampledValue(socSampledValueTemplate, socSampledValueTemplateValue) + OCPP16ServiceUtils.buildSampledValue(socSampledValueTemplate, socSampledValueTemplateValue), ); const sampledValuesIndex = meterValue.sampledValue.length - 1; - if (Utils.convertToInt(meterValue.sampledValue[sampledValuesIndex].value) > 100 || debug) { + if ( + convertToInt(meterValue.sampledValue[sampledValuesIndex].value) > socMaximumValue || + convertToInt(meterValue.sampledValue[sampledValuesIndex].value) < socMinimumValue || + debug + ) { logger.error( `${chargingStation.logPrefix()} MeterValues measurand ${ meterValue.sampledValue[sampledValuesIndex].measurand ?? OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER - }: connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${ + }: connector id ${connectorId}, transaction id ${connector?.transactionId}, value: ${socMinimumValue}/${ meterValue.sampledValue[sampledValuesIndex].value - }/100` + }/${socMaximumValue}`, ); } } // Voltage measurand - const voltageSampledValueTemplate = ChargingStationUtils.getSampledValueTemplate( + const voltageSampledValueTemplate = OCPP16ServiceUtils.getSampledValueTemplate( chargingStation, connectorId, - OCPP16MeterValueMeasurand.VOLTAGE + OCPP16MeterValueMeasurand.VOLTAGE, ); if (voltageSampledValueTemplate) { - const voltageSampledValueTemplateValue = voltageSampledValueTemplate.value + const voltageSampledValueTemplateValue = isNotEmptyString(voltageSampledValueTemplate.value) ? parseInt(voltageSampledValueTemplate.value) - : chargingStation.getVoltageOut(); + : chargingStation.stationInfo.voltageOut!; const fluctuationPercent = voltageSampledValueTemplate.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT; - const voltageMeasurandValue = Utils.getRandomFloatFluctuatedRounded( + const voltageMeasurandValue = getRandomFloatFluctuatedRounded( voltageSampledValueTemplateValue, - fluctuationPercent + fluctuationPercent, ); if ( chargingStation.getNumberOfPhases() !== 3 || - (chargingStation.getNumberOfPhases() === 3 && chargingStation.getMainVoltageMeterValues()) + (chargingStation.getNumberOfPhases() === 3 && + chargingStation.stationInfo?.mainVoltageMeterValues) ) { meterValue.sampledValue.push( - OCPP16ServiceUtils.buildSampledValue(voltageSampledValueTemplate, voltageMeasurandValue) + OCPP16ServiceUtils.buildSampledValue(voltageSampledValueTemplate, voltageMeasurandValue), ); } for ( @@ -121,218 +160,280 @@ export class OCPP16ServiceUtils extends OCPPServiceUtils { ) { const phaseLineToNeutralValue = `L${phase}-N`; const voltagePhaseLineToNeutralSampledValueTemplate = - ChargingStationUtils.getSampledValueTemplate( + OCPP16ServiceUtils.getSampledValueTemplate( chargingStation, connectorId, OCPP16MeterValueMeasurand.VOLTAGE, - phaseLineToNeutralValue as OCPP16MeterValuePhase + phaseLineToNeutralValue as OCPP16MeterValuePhase, ); - let voltagePhaseLineToNeutralMeasurandValue: number; + let voltagePhaseLineToNeutralMeasurandValue: number | undefined; if (voltagePhaseLineToNeutralSampledValueTemplate) { - const voltagePhaseLineToNeutralSampledValueTemplateValue = - voltagePhaseLineToNeutralSampledValueTemplate.value - ? parseInt(voltagePhaseLineToNeutralSampledValueTemplate.value) - : chargingStation.getVoltageOut(); + const voltagePhaseLineToNeutralSampledValueTemplateValue = isNotEmptyString( + voltagePhaseLineToNeutralSampledValueTemplate.value, + ) + ? parseInt(voltagePhaseLineToNeutralSampledValueTemplate.value) + : chargingStation.stationInfo.voltageOut!; const fluctuationPhaseToNeutralPercent = voltagePhaseLineToNeutralSampledValueTemplate.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT; - voltagePhaseLineToNeutralMeasurandValue = Utils.getRandomFloatFluctuatedRounded( + voltagePhaseLineToNeutralMeasurandValue = getRandomFloatFluctuatedRounded( voltagePhaseLineToNeutralSampledValueTemplateValue, - fluctuationPhaseToNeutralPercent + fluctuationPhaseToNeutralPercent, ); } meterValue.sampledValue.push( OCPP16ServiceUtils.buildSampledValue( voltagePhaseLineToNeutralSampledValueTemplate ?? voltageSampledValueTemplate, voltagePhaseLineToNeutralMeasurandValue ?? voltageMeasurandValue, - null, - phaseLineToNeutralValue as OCPP16MeterValuePhase - ) + undefined, + phaseLineToNeutralValue as OCPP16MeterValuePhase, + ), ); - if (chargingStation.getPhaseLineToLineVoltageMeterValues()) { + if (chargingStation.stationInfo?.phaseLineToLineVoltageMeterValues) { const phaseLineToLineValue = `L${phase}-L${ (phase + 1) % chargingStation.getNumberOfPhases() !== 0 ? (phase + 1) % chargingStation.getNumberOfPhases() : chargingStation.getNumberOfPhases() }`; + const voltagePhaseLineToLineValueRounded = roundTo( + Math.sqrt(chargingStation.getNumberOfPhases()) * + chargingStation.stationInfo.voltageOut!, + 2, + ); const voltagePhaseLineToLineSampledValueTemplate = - ChargingStationUtils.getSampledValueTemplate( + OCPP16ServiceUtils.getSampledValueTemplate( chargingStation, connectorId, OCPP16MeterValueMeasurand.VOLTAGE, - phaseLineToLineValue as OCPP16MeterValuePhase + phaseLineToLineValue as OCPP16MeterValuePhase, ); - let voltagePhaseLineToLineMeasurandValue: number; + let voltagePhaseLineToLineMeasurandValue: number | undefined; if (voltagePhaseLineToLineSampledValueTemplate) { - const voltagePhaseLineToLineSampledValueTemplateValue = - voltagePhaseLineToLineSampledValueTemplate.value - ? parseInt(voltagePhaseLineToLineSampledValueTemplate.value) - : Voltage.VOLTAGE_400; + const voltagePhaseLineToLineSampledValueTemplateValue = isNotEmptyString( + voltagePhaseLineToLineSampledValueTemplate.value, + ) + ? parseInt(voltagePhaseLineToLineSampledValueTemplate.value) + : voltagePhaseLineToLineValueRounded; const fluctuationPhaseLineToLinePercent = voltagePhaseLineToLineSampledValueTemplate.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT; - voltagePhaseLineToLineMeasurandValue = Utils.getRandomFloatFluctuatedRounded( + voltagePhaseLineToLineMeasurandValue = getRandomFloatFluctuatedRounded( voltagePhaseLineToLineSampledValueTemplateValue, - fluctuationPhaseLineToLinePercent + fluctuationPhaseLineToLinePercent, ); } - const defaultVoltagePhaseLineToLineMeasurandValue = Utils.getRandomFloatFluctuatedRounded( - Voltage.VOLTAGE_400, - fluctuationPercent + const defaultVoltagePhaseLineToLineMeasurandValue = getRandomFloatFluctuatedRounded( + voltagePhaseLineToLineValueRounded, + fluctuationPercent, ); meterValue.sampledValue.push( OCPP16ServiceUtils.buildSampledValue( voltagePhaseLineToLineSampledValueTemplate ?? voltageSampledValueTemplate, voltagePhaseLineToLineMeasurandValue ?? defaultVoltagePhaseLineToLineMeasurandValue, - null, - phaseLineToLineValue as OCPP16MeterValuePhase - ) + undefined, + phaseLineToLineValue as OCPP16MeterValuePhase, + ), ); } } } // Power.Active.Import measurand - const powerSampledValueTemplate = ChargingStationUtils.getSampledValueTemplate( + const powerSampledValueTemplate = OCPP16ServiceUtils.getSampledValueTemplate( chargingStation, connectorId, - OCPP16MeterValueMeasurand.POWER_ACTIVE_IMPORT + OCPP16MeterValueMeasurand.POWER_ACTIVE_IMPORT, ); let powerPerPhaseSampledValueTemplates: MeasurandPerPhaseSampledValueTemplates = {}; if (chargingStation.getNumberOfPhases() === 3) { powerPerPhaseSampledValueTemplates = { - L1: ChargingStationUtils.getSampledValueTemplate( + L1: OCPP16ServiceUtils.getSampledValueTemplate( chargingStation, connectorId, OCPP16MeterValueMeasurand.POWER_ACTIVE_IMPORT, - OCPP16MeterValuePhase.L1_N + OCPP16MeterValuePhase.L1_N, ), - L2: ChargingStationUtils.getSampledValueTemplate( + L2: OCPP16ServiceUtils.getSampledValueTemplate( chargingStation, connectorId, OCPP16MeterValueMeasurand.POWER_ACTIVE_IMPORT, - OCPP16MeterValuePhase.L2_N + OCPP16MeterValuePhase.L2_N, ), - L3: ChargingStationUtils.getSampledValueTemplate( + L3: OCPP16ServiceUtils.getSampledValueTemplate( chargingStation, connectorId, OCPP16MeterValueMeasurand.POWER_ACTIVE_IMPORT, - OCPP16MeterValuePhase.L3_N + OCPP16MeterValuePhase.L3_N, ), }; } if (powerSampledValueTemplate) { OCPP16ServiceUtils.checkMeasurandPowerDivider( chargingStation, - powerSampledValueTemplate.measurand + powerSampledValueTemplate.measurand!, ); const errMsg = `MeterValues measurand ${ powerSampledValueTemplate.measurand ?? OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER - }: Unknown ${chargingStation.getCurrentOutType()} currentOutType in template file ${ + }: Unknown ${chargingStation.stationInfo?.currentOutType} currentOutType in template file ${ chargingStation.templateFile }, cannot calculate ${ powerSampledValueTemplate.measurand ?? OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER } measurand value`; - const powerMeasurandValues = {} as MeasurandValues; + const powerMeasurandValues: MeasurandValues = {} as MeasurandValues; const unitDivider = powerSampledValueTemplate?.unit === MeterValueUnit.KILO_WATT ? 1000 : 1; const connectorMaximumAvailablePower = chargingStation.getConnectorMaximumAvailablePower(connectorId); const connectorMaximumPower = Math.round(connectorMaximumAvailablePower); const connectorMaximumPowerPerPhase = Math.round( - connectorMaximumAvailablePower / chargingStation.getNumberOfPhases() + connectorMaximumAvailablePower / chargingStation.getNumberOfPhases(), ); - switch (chargingStation.getCurrentOutType()) { + const connectorMinimumPower = Math.round(powerSampledValueTemplate.minimumValue ?? 0); + const connectorMinimumPowerPerPhase = Math.round( + connectorMinimumPower / chargingStation.getNumberOfPhases(), + ); + switch (chargingStation.stationInfo?.currentOutType) { case CurrentType.AC: if (chargingStation.getNumberOfPhases() === 3) { - const defaultFluctuatedPowerPerPhase = - powerSampledValueTemplate.value && - Utils.getRandomFloatFluctuatedRounded( - OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( - powerSampledValueTemplate.value, - connectorMaximumPower / unitDivider, - { limitationEnabled: chargingStation.getCustomValueLimitationMeterValues() } - ) / chargingStation.getNumberOfPhases(), - powerSampledValueTemplate.fluctuationPercent ?? - Constants.DEFAULT_FLUCTUATION_PERCENT - ); - const phase1FluctuatedValue = - powerPerPhaseSampledValueTemplates?.L1?.value && - Utils.getRandomFloatFluctuatedRounded( - OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( - powerPerPhaseSampledValueTemplates.L1.value, - connectorMaximumPowerPerPhase / unitDivider, - { limitationEnabled: chargingStation.getCustomValueLimitationMeterValues() } - ), - powerPerPhaseSampledValueTemplates.L1.fluctuationPercent ?? - Constants.DEFAULT_FLUCTUATION_PERCENT - ); - const phase2FluctuatedValue = - powerPerPhaseSampledValueTemplates?.L2?.value && - Utils.getRandomFloatFluctuatedRounded( - OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( - powerPerPhaseSampledValueTemplates.L2.value, - connectorMaximumPowerPerPhase / unitDivider, - { limitationEnabled: chargingStation.getCustomValueLimitationMeterValues() } - ), - powerPerPhaseSampledValueTemplates.L2.fluctuationPercent ?? - Constants.DEFAULT_FLUCTUATION_PERCENT - ); - const phase3FluctuatedValue = - powerPerPhaseSampledValueTemplates?.L3?.value && - Utils.getRandomFloatFluctuatedRounded( - OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( - powerPerPhaseSampledValueTemplates.L3.value, - connectorMaximumPowerPerPhase / unitDivider, - { limitationEnabled: chargingStation.getCustomValueLimitationMeterValues() } - ), - powerPerPhaseSampledValueTemplates.L3.fluctuationPercent ?? - Constants.DEFAULT_FLUCTUATION_PERCENT - ); + const defaultFluctuatedPowerPerPhase = isNotEmptyString(powerSampledValueTemplate.value) + ? getRandomFloatFluctuatedRounded( + OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( + powerSampledValueTemplate.value, + connectorMaximumPower / unitDivider, + connectorMinimumPower / unitDivider, + { + limitationEnabled: + chargingStation.stationInfo?.customValueLimitationMeterValues, + fallbackValue: connectorMinimumPower / unitDivider, + }, + ) / chargingStation.getNumberOfPhases(), + powerSampledValueTemplate.fluctuationPercent ?? + Constants.DEFAULT_FLUCTUATION_PERCENT, + ) + : undefined; + const phase1FluctuatedValue = isNotEmptyString( + powerPerPhaseSampledValueTemplates.L1?.value, + ) + ? getRandomFloatFluctuatedRounded( + OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( + powerPerPhaseSampledValueTemplates.L1?.value, + connectorMaximumPowerPerPhase / unitDivider, + connectorMinimumPowerPerPhase / unitDivider, + { + limitationEnabled: + chargingStation.stationInfo?.customValueLimitationMeterValues, + fallbackValue: connectorMinimumPowerPerPhase / unitDivider, + }, + ), + powerPerPhaseSampledValueTemplates.L1?.fluctuationPercent ?? + Constants.DEFAULT_FLUCTUATION_PERCENT, + ) + : undefined; + const phase2FluctuatedValue = isNotEmptyString( + powerPerPhaseSampledValueTemplates.L2?.value, + ) + ? getRandomFloatFluctuatedRounded( + OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( + powerPerPhaseSampledValueTemplates.L2?.value, + connectorMaximumPowerPerPhase / unitDivider, + connectorMinimumPowerPerPhase / unitDivider, + { + limitationEnabled: + chargingStation.stationInfo?.customValueLimitationMeterValues, + fallbackValue: connectorMinimumPowerPerPhase / unitDivider, + }, + ), + powerPerPhaseSampledValueTemplates.L2?.fluctuationPercent ?? + Constants.DEFAULT_FLUCTUATION_PERCENT, + ) + : undefined; + const phase3FluctuatedValue = isNotEmptyString( + powerPerPhaseSampledValueTemplates.L3?.value, + ) + ? getRandomFloatFluctuatedRounded( + OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( + powerPerPhaseSampledValueTemplates.L3?.value, + connectorMaximumPowerPerPhase / unitDivider, + connectorMinimumPowerPerPhase / unitDivider, + { + limitationEnabled: + chargingStation.stationInfo?.customValueLimitationMeterValues, + fallbackValue: connectorMinimumPowerPerPhase / unitDivider, + }, + ), + powerPerPhaseSampledValueTemplates.L3?.fluctuationPercent ?? + Constants.DEFAULT_FLUCTUATION_PERCENT, + ) + : undefined; powerMeasurandValues.L1 = phase1FluctuatedValue ?? defaultFluctuatedPowerPerPhase ?? - Utils.getRandomFloatRounded(connectorMaximumPowerPerPhase / unitDivider); + getRandomFloatRounded( + connectorMaximumPowerPerPhase / unitDivider, + connectorMinimumPowerPerPhase / unitDivider, + ); powerMeasurandValues.L2 = phase2FluctuatedValue ?? defaultFluctuatedPowerPerPhase ?? - Utils.getRandomFloatRounded(connectorMaximumPowerPerPhase / unitDivider); + getRandomFloatRounded( + connectorMaximumPowerPerPhase / unitDivider, + connectorMinimumPowerPerPhase / unitDivider, + ); powerMeasurandValues.L3 = phase3FluctuatedValue ?? defaultFluctuatedPowerPerPhase ?? - Utils.getRandomFloatRounded(connectorMaximumPowerPerPhase / unitDivider); + getRandomFloatRounded( + connectorMaximumPowerPerPhase / unitDivider, + connectorMinimumPowerPerPhase / unitDivider, + ); } else { - powerMeasurandValues.L1 = powerSampledValueTemplate.value - ? Utils.getRandomFloatFluctuatedRounded( + powerMeasurandValues.L1 = isNotEmptyString(powerSampledValueTemplate.value) + ? getRandomFloatFluctuatedRounded( OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( powerSampledValueTemplate.value, connectorMaximumPower / unitDivider, - { limitationEnabled: chargingStation.getCustomValueLimitationMeterValues() } + connectorMinimumPower / unitDivider, + { + limitationEnabled: + chargingStation.stationInfo?.customValueLimitationMeterValues, + fallbackValue: connectorMinimumPower / unitDivider, + }, ), powerSampledValueTemplate.fluctuationPercent ?? - Constants.DEFAULT_FLUCTUATION_PERCENT + Constants.DEFAULT_FLUCTUATION_PERCENT, ) - : Utils.getRandomFloatRounded(connectorMaximumPower / unitDivider); + : getRandomFloatRounded( + connectorMaximumPower / unitDivider, + connectorMinimumPower / unitDivider, + ); powerMeasurandValues.L2 = 0; powerMeasurandValues.L3 = 0; } - powerMeasurandValues.allPhases = Utils.roundTo( + powerMeasurandValues.allPhases = roundTo( powerMeasurandValues.L1 + powerMeasurandValues.L2 + powerMeasurandValues.L3, - 2 + 2, ); break; case CurrentType.DC: - powerMeasurandValues.allPhases = powerSampledValueTemplate.value - ? Utils.getRandomFloatFluctuatedRounded( + powerMeasurandValues.allPhases = isNotEmptyString(powerSampledValueTemplate.value) + ? getRandomFloatFluctuatedRounded( OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( powerSampledValueTemplate.value, connectorMaximumPower / unitDivider, - { limitationEnabled: chargingStation.getCustomValueLimitationMeterValues() } + connectorMinimumPower / unitDivider, + { + limitationEnabled: + chargingStation.stationInfo?.customValueLimitationMeterValues, + fallbackValue: connectorMinimumPower / unitDivider, + }, ), powerSampledValueTemplate.fluctuationPercent ?? - Constants.DEFAULT_FLUCTUATION_PERCENT + Constants.DEFAULT_FLUCTUATION_PERCENT, ) - : Utils.getRandomFloatRounded(connectorMaximumPower / unitDivider); + : getRandomFloatRounded( + connectorMaximumPower / unitDivider, + connectorMinimumPower / unitDivider, + ); break; default: logger.error(`${chargingStation.logPrefix()} ${errMsg}`); @@ -341,23 +442,26 @@ export class OCPP16ServiceUtils extends OCPPServiceUtils { meterValue.sampledValue.push( OCPP16ServiceUtils.buildSampledValue( powerSampledValueTemplate, - powerMeasurandValues.allPhases - ) + powerMeasurandValues.allPhases, + ), ); const sampledValuesIndex = meterValue.sampledValue.length - 1; - const connectorMaximumPowerRounded = Utils.roundTo(connectorMaximumPower / unitDivider, 2); + const connectorMaximumPowerRounded = roundTo(connectorMaximumPower / unitDivider, 2); + const connectorMinimumPowerRounded = roundTo(connectorMinimumPower / unitDivider, 2); if ( - Utils.convertToFloat(meterValue.sampledValue[sampledValuesIndex].value) > + convertToFloat(meterValue.sampledValue[sampledValuesIndex].value) > connectorMaximumPowerRounded || + convertToFloat(meterValue.sampledValue[sampledValuesIndex].value) < + connectorMinimumPowerRounded || debug ) { logger.error( `${chargingStation.logPrefix()} MeterValues measurand ${ meterValue.sampledValue[sampledValuesIndex].measurand ?? OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER - }: connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${ + }: connector id ${connectorId}, transaction id ${connector?.transactionId}, value: ${connectorMinimumPowerRounded}/${ meterValue.sampledValue[sampledValuesIndex].value - }/${connectorMaximumPowerRounded}` + }/${connectorMaximumPowerRounded}`, ); } for ( @@ -368,21 +472,28 @@ export class OCPP16ServiceUtils extends OCPPServiceUtils { const phaseValue = `L${phase}-N`; meterValue.sampledValue.push( OCPP16ServiceUtils.buildSampledValue( - (powerPerPhaseSampledValueTemplates[`L${phase}`] as SampledValueTemplate) ?? - powerSampledValueTemplate, - powerMeasurandValues[`L${phase}`] as number, - null, - phaseValue as OCPP16MeterValuePhase - ) + powerPerPhaseSampledValueTemplates[ + `L${phase}` as keyof MeasurandPerPhaseSampledValueTemplates + ] ?? powerSampledValueTemplate, + powerMeasurandValues[`L${phase}` as keyof MeasurandPerPhaseSampledValueTemplates], + undefined, + phaseValue as OCPP16MeterValuePhase, + ), ); const sampledValuesPerPhaseIndex = meterValue.sampledValue.length - 1; - const connectorMaximumPowerPerPhaseRounded = Utils.roundTo( + const connectorMaximumPowerPerPhaseRounded = roundTo( connectorMaximumPowerPerPhase / unitDivider, - 2 + 2, + ); + const connectorMinimumPowerPerPhaseRounded = roundTo( + connectorMinimumPowerPerPhase / unitDivider, + 2, ); if ( - Utils.convertToFloat(meterValue.sampledValue[sampledValuesPerPhaseIndex].value) > + convertToFloat(meterValue.sampledValue[sampledValuesPerPhaseIndex].value) > connectorMaximumPowerPerPhaseRounded || + convertToFloat(meterValue.sampledValue[sampledValuesPerPhaseIndex].value) < + connectorMinimumPowerPerPhaseRounded || debug ) { logger.error( @@ -391,51 +502,51 @@ export class OCPP16ServiceUtils extends OCPPServiceUtils { OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER }: phase ${ meterValue.sampledValue[sampledValuesPerPhaseIndex].phase - }, connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${ + }, connector id ${connectorId}, transaction id ${connector?.transactionId}, value: ${connectorMinimumPowerPerPhaseRounded}/${ meterValue.sampledValue[sampledValuesPerPhaseIndex].value - }/${connectorMaximumPowerPerPhaseRounded}` + }/${connectorMaximumPowerPerPhaseRounded}`, ); } } } // Current.Import measurand - const currentSampledValueTemplate = ChargingStationUtils.getSampledValueTemplate( + const currentSampledValueTemplate = OCPP16ServiceUtils.getSampledValueTemplate( chargingStation, connectorId, - OCPP16MeterValueMeasurand.CURRENT_IMPORT + OCPP16MeterValueMeasurand.CURRENT_IMPORT, ); let currentPerPhaseSampledValueTemplates: MeasurandPerPhaseSampledValueTemplates = {}; if (chargingStation.getNumberOfPhases() === 3) { currentPerPhaseSampledValueTemplates = { - L1: ChargingStationUtils.getSampledValueTemplate( + L1: OCPP16ServiceUtils.getSampledValueTemplate( chargingStation, connectorId, OCPP16MeterValueMeasurand.CURRENT_IMPORT, - OCPP16MeterValuePhase.L1 + OCPP16MeterValuePhase.L1, ), - L2: ChargingStationUtils.getSampledValueTemplate( + L2: OCPP16ServiceUtils.getSampledValueTemplate( chargingStation, connectorId, OCPP16MeterValueMeasurand.CURRENT_IMPORT, - OCPP16MeterValuePhase.L2 + OCPP16MeterValuePhase.L2, ), - L3: ChargingStationUtils.getSampledValueTemplate( + L3: OCPP16ServiceUtils.getSampledValueTemplate( chargingStation, connectorId, OCPP16MeterValueMeasurand.CURRENT_IMPORT, - OCPP16MeterValuePhase.L3 + OCPP16MeterValuePhase.L3, ), }; } if (currentSampledValueTemplate) { OCPP16ServiceUtils.checkMeasurandPowerDivider( chargingStation, - currentSampledValueTemplate.measurand + currentSampledValueTemplate.measurand!, ); const errMsg = `MeterValues measurand ${ currentSampledValueTemplate.measurand ?? OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER - }: Unknown ${chargingStation.getCurrentOutType()} currentOutType in template file ${ + }: Unknown ${chargingStation.stationInfo?.currentOutType} currentOutType in template file ${ chargingStation.templateFile }, cannot calculate ${ currentSampledValueTemplate.measurand ?? @@ -444,108 +555,147 @@ export class OCPP16ServiceUtils extends OCPPServiceUtils { const currentMeasurandValues: MeasurandValues = {} as MeasurandValues; const connectorMaximumAvailablePower = chargingStation.getConnectorMaximumAvailablePower(connectorId); + const connectorMinimumAmperage = currentSampledValueTemplate.minimumValue ?? 0; let connectorMaximumAmperage: number; - switch (chargingStation.getCurrentOutType()) { + switch (chargingStation.stationInfo?.currentOutType) { case CurrentType.AC: connectorMaximumAmperage = ACElectricUtils.amperagePerPhaseFromPower( chargingStation.getNumberOfPhases(), connectorMaximumAvailablePower, - chargingStation.getVoltageOut() + chargingStation.stationInfo.voltageOut!, ); if (chargingStation.getNumberOfPhases() === 3) { - const defaultFluctuatedAmperagePerPhase = - currentSampledValueTemplate.value && - Utils.getRandomFloatFluctuatedRounded( - OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( - currentSampledValueTemplate.value, - connectorMaximumAmperage, - { limitationEnabled: chargingStation.getCustomValueLimitationMeterValues() } - ), - currentSampledValueTemplate.fluctuationPercent ?? - Constants.DEFAULT_FLUCTUATION_PERCENT - ); - const phase1FluctuatedValue = - currentPerPhaseSampledValueTemplates?.L1?.value && - Utils.getRandomFloatFluctuatedRounded( - OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( - currentPerPhaseSampledValueTemplates.L1.value, - connectorMaximumAmperage, - { limitationEnabled: chargingStation.getCustomValueLimitationMeterValues() } - ), - currentPerPhaseSampledValueTemplates.L1.fluctuationPercent ?? - Constants.DEFAULT_FLUCTUATION_PERCENT - ); - const phase2FluctuatedValue = - currentPerPhaseSampledValueTemplates?.L2?.value && - Utils.getRandomFloatFluctuatedRounded( - OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( - currentPerPhaseSampledValueTemplates.L2.value, - connectorMaximumAmperage, - { limitationEnabled: chargingStation.getCustomValueLimitationMeterValues() } - ), - currentPerPhaseSampledValueTemplates.L2.fluctuationPercent ?? - Constants.DEFAULT_FLUCTUATION_PERCENT - ); - const phase3FluctuatedValue = - currentPerPhaseSampledValueTemplates?.L3?.value && - Utils.getRandomFloatFluctuatedRounded( - OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( - currentPerPhaseSampledValueTemplates.L3.value, - connectorMaximumAmperage, - { limitationEnabled: chargingStation.getCustomValueLimitationMeterValues() } - ), - currentPerPhaseSampledValueTemplates.L3.fluctuationPercent ?? - Constants.DEFAULT_FLUCTUATION_PERCENT - ); + const defaultFluctuatedAmperagePerPhase = isNotEmptyString( + currentSampledValueTemplate.value, + ) + ? getRandomFloatFluctuatedRounded( + OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( + currentSampledValueTemplate.value, + connectorMaximumAmperage, + connectorMinimumAmperage, + { + limitationEnabled: + chargingStation.stationInfo?.customValueLimitationMeterValues, + fallbackValue: connectorMinimumAmperage, + }, + ), + currentSampledValueTemplate.fluctuationPercent ?? + Constants.DEFAULT_FLUCTUATION_PERCENT, + ) + : undefined; + const phase1FluctuatedValue = isNotEmptyString( + currentPerPhaseSampledValueTemplates.L1?.value, + ) + ? getRandomFloatFluctuatedRounded( + OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( + currentPerPhaseSampledValueTemplates.L1?.value, + connectorMaximumAmperage, + connectorMinimumAmperage, + { + limitationEnabled: + chargingStation.stationInfo?.customValueLimitationMeterValues, + fallbackValue: connectorMinimumAmperage, + }, + ), + currentPerPhaseSampledValueTemplates.L1?.fluctuationPercent ?? + Constants.DEFAULT_FLUCTUATION_PERCENT, + ) + : undefined; + const phase2FluctuatedValue = isNotEmptyString( + currentPerPhaseSampledValueTemplates.L2?.value, + ) + ? getRandomFloatFluctuatedRounded( + OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( + currentPerPhaseSampledValueTemplates.L2?.value, + connectorMaximumAmperage, + connectorMinimumAmperage, + { + limitationEnabled: + chargingStation.stationInfo?.customValueLimitationMeterValues, + fallbackValue: connectorMinimumAmperage, + }, + ), + currentPerPhaseSampledValueTemplates.L2?.fluctuationPercent ?? + Constants.DEFAULT_FLUCTUATION_PERCENT, + ) + : undefined; + const phase3FluctuatedValue = isNotEmptyString( + currentPerPhaseSampledValueTemplates.L3?.value, + ) + ? getRandomFloatFluctuatedRounded( + OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( + currentPerPhaseSampledValueTemplates.L3?.value, + connectorMaximumAmperage, + connectorMinimumAmperage, + { + limitationEnabled: + chargingStation.stationInfo?.customValueLimitationMeterValues, + fallbackValue: connectorMinimumAmperage, + }, + ), + currentPerPhaseSampledValueTemplates.L3?.fluctuationPercent ?? + Constants.DEFAULT_FLUCTUATION_PERCENT, + ) + : undefined; currentMeasurandValues.L1 = phase1FluctuatedValue ?? defaultFluctuatedAmperagePerPhase ?? - Utils.getRandomFloatRounded(connectorMaximumAmperage); + getRandomFloatRounded(connectorMaximumAmperage, connectorMinimumAmperage); currentMeasurandValues.L2 = phase2FluctuatedValue ?? defaultFluctuatedAmperagePerPhase ?? - Utils.getRandomFloatRounded(connectorMaximumAmperage); + getRandomFloatRounded(connectorMaximumAmperage, connectorMinimumAmperage); currentMeasurandValues.L3 = phase3FluctuatedValue ?? defaultFluctuatedAmperagePerPhase ?? - Utils.getRandomFloatRounded(connectorMaximumAmperage); + getRandomFloatRounded(connectorMaximumAmperage, connectorMinimumAmperage); } else { - currentMeasurandValues.L1 = currentSampledValueTemplate.value - ? Utils.getRandomFloatFluctuatedRounded( + currentMeasurandValues.L1 = isNotEmptyString(currentSampledValueTemplate.value) + ? getRandomFloatFluctuatedRounded( OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( currentSampledValueTemplate.value, connectorMaximumAmperage, - { limitationEnabled: chargingStation.getCustomValueLimitationMeterValues() } + connectorMinimumAmperage, + { + limitationEnabled: + chargingStation.stationInfo?.customValueLimitationMeterValues, + fallbackValue: connectorMinimumAmperage, + }, ), currentSampledValueTemplate.fluctuationPercent ?? - Constants.DEFAULT_FLUCTUATION_PERCENT + Constants.DEFAULT_FLUCTUATION_PERCENT, ) - : Utils.getRandomFloatRounded(connectorMaximumAmperage); + : getRandomFloatRounded(connectorMaximumAmperage, connectorMinimumAmperage); currentMeasurandValues.L2 = 0; currentMeasurandValues.L3 = 0; } - currentMeasurandValues.allPhases = Utils.roundTo( + currentMeasurandValues.allPhases = roundTo( (currentMeasurandValues.L1 + currentMeasurandValues.L2 + currentMeasurandValues.L3) / chargingStation.getNumberOfPhases(), - 2 + 2, ); break; case CurrentType.DC: connectorMaximumAmperage = DCElectricUtils.amperage( connectorMaximumAvailablePower, - chargingStation.getVoltageOut() + chargingStation.stationInfo.voltageOut!, ); - currentMeasurandValues.allPhases = currentSampledValueTemplate.value - ? Utils.getRandomFloatFluctuatedRounded( + currentMeasurandValues.allPhases = isNotEmptyString(currentSampledValueTemplate.value) + ? getRandomFloatFluctuatedRounded( OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( currentSampledValueTemplate.value, connectorMaximumAmperage, - { limitationEnabled: chargingStation.getCustomValueLimitationMeterValues() } + connectorMinimumAmperage, + { + limitationEnabled: + chargingStation.stationInfo?.customValueLimitationMeterValues, + fallbackValue: connectorMinimumAmperage, + }, ), currentSampledValueTemplate.fluctuationPercent ?? - Constants.DEFAULT_FLUCTUATION_PERCENT + Constants.DEFAULT_FLUCTUATION_PERCENT, ) - : Utils.getRandomFloatRounded(connectorMaximumAmperage); + : getRandomFloatRounded(connectorMaximumAmperage, connectorMinimumAmperage); break; default: logger.error(`${chargingStation.logPrefix()} ${errMsg}`); @@ -554,22 +704,24 @@ export class OCPP16ServiceUtils extends OCPPServiceUtils { meterValue.sampledValue.push( OCPP16ServiceUtils.buildSampledValue( currentSampledValueTemplate, - currentMeasurandValues.allPhases - ) + currentMeasurandValues.allPhases, + ), ); const sampledValuesIndex = meterValue.sampledValue.length - 1; if ( - Utils.convertToFloat(meterValue.sampledValue[sampledValuesIndex].value) > + convertToFloat(meterValue.sampledValue[sampledValuesIndex].value) > connectorMaximumAmperage || + convertToFloat(meterValue.sampledValue[sampledValuesIndex].value) < + connectorMinimumAmperage || debug ) { logger.error( `${chargingStation.logPrefix()} MeterValues measurand ${ meterValue.sampledValue[sampledValuesIndex].measurand ?? OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER - }: connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${ + }: connector id ${connectorId}, transaction id ${connector?.transactionId}, value: ${connectorMinimumAmperage}/${ meterValue.sampledValue[sampledValuesIndex].value - }/${connectorMaximumAmperage}` + }/${connectorMaximumAmperage}`, ); } for ( @@ -580,17 +732,20 @@ export class OCPP16ServiceUtils extends OCPPServiceUtils { const phaseValue = `L${phase}`; meterValue.sampledValue.push( OCPP16ServiceUtils.buildSampledValue( - (currentPerPhaseSampledValueTemplates[phaseValue] as SampledValueTemplate) ?? - currentSampledValueTemplate, - currentMeasurandValues[phaseValue] as number, - null, - phaseValue as OCPP16MeterValuePhase - ) + currentPerPhaseSampledValueTemplates[ + phaseValue as keyof MeasurandPerPhaseSampledValueTemplates + ] ?? currentSampledValueTemplate, + currentMeasurandValues[phaseValue as keyof MeasurandPerPhaseSampledValueTemplates], + undefined, + phaseValue as OCPP16MeterValuePhase, + ), ); const sampledValuesPerPhaseIndex = meterValue.sampledValue.length - 1; if ( - Utils.convertToFloat(meterValue.sampledValue[sampledValuesPerPhaseIndex].value) > + convertToFloat(meterValue.sampledValue[sampledValuesPerPhaseIndex].value) > connectorMaximumAmperage || + convertToFloat(meterValue.sampledValue[sampledValuesPerPhaseIndex].value) < + connectorMinimumAmperage || debug ) { logger.error( @@ -599,81 +754,86 @@ export class OCPP16ServiceUtils extends OCPPServiceUtils { OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER }: phase ${ meterValue.sampledValue[sampledValuesPerPhaseIndex].phase - }, connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${ + }, connector id ${connectorId}, transaction id ${connector?.transactionId}, value: ${connectorMinimumAmperage}/${ meterValue.sampledValue[sampledValuesPerPhaseIndex].value - }/${connectorMaximumAmperage}` + }/${connectorMaximumAmperage}`, ); } } } // Energy.Active.Import.Register measurand (default) - const energySampledValueTemplate = ChargingStationUtils.getSampledValueTemplate( + const energySampledValueTemplate = OCPP16ServiceUtils.getSampledValueTemplate( chargingStation, - connectorId + connectorId, ); if (energySampledValueTemplate) { OCPP16ServiceUtils.checkMeasurandPowerDivider( chargingStation, - energySampledValueTemplate.measurand + energySampledValueTemplate.measurand!, ); const unitDivider = energySampledValueTemplate?.unit === MeterValueUnit.KILO_WATT_HOUR ? 1000 : 1; const connectorMaximumAvailablePower = chargingStation.getConnectorMaximumAvailablePower(connectorId); - const connectorMaximumEnergyRounded = Utils.roundTo( + const connectorMaximumEnergyRounded = roundTo( (connectorMaximumAvailablePower * interval) / (3600 * 1000), - 2 + 2, + ); + const connectorMinimumEnergyRounded = roundTo( + energySampledValueTemplate.minimumValue ?? 0, + 2, ); - const energyValueRounded = energySampledValueTemplate.value - ? // Cumulate the fluctuated value around the static one - Utils.getRandomFloatFluctuatedRounded( + const energyValueRounded = isNotEmptyString(energySampledValueTemplate.value) + ? getRandomFloatFluctuatedRounded( OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( energySampledValueTemplate.value, connectorMaximumEnergyRounded, + connectorMinimumEnergyRounded, { - limitationEnabled: chargingStation.getCustomValueLimitationMeterValues(), + limitationEnabled: chargingStation.stationInfo?.customValueLimitationMeterValues, + fallbackValue: connectorMinimumEnergyRounded, unitMultiplier: unitDivider, - } + }, ), - energySampledValueTemplate.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT + energySampledValueTemplate.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT, ) - : Utils.getRandomFloatRounded(connectorMaximumEnergyRounded); + : getRandomFloatRounded(connectorMaximumEnergyRounded, connectorMinimumEnergyRounded); // Persist previous value on connector - if ( - connector && - !Utils.isNullOrUndefined(connector.energyActiveImportRegisterValue) && - connector.energyActiveImportRegisterValue >= 0 && - !Utils.isNullOrUndefined(connector.transactionEnergyActiveImportRegisterValue) && - connector.transactionEnergyActiveImportRegisterValue >= 0 - ) { - connector.energyActiveImportRegisterValue += energyValueRounded; - connector.transactionEnergyActiveImportRegisterValue += energyValueRounded; - } else { - connector.energyActiveImportRegisterValue = 0; - connector.transactionEnergyActiveImportRegisterValue = 0; + if (connector) { + if ( + isNullOrUndefined(connector.energyActiveImportRegisterValue) === false && + connector.energyActiveImportRegisterValue! >= 0 && + isNullOrUndefined(connector.transactionEnergyActiveImportRegisterValue) === false && + connector.transactionEnergyActiveImportRegisterValue! >= 0 + ) { + connector.energyActiveImportRegisterValue! += energyValueRounded; + connector.transactionEnergyActiveImportRegisterValue! += energyValueRounded; + } else { + connector.energyActiveImportRegisterValue = 0; + connector.transactionEnergyActiveImportRegisterValue = 0; + } } meterValue.sampledValue.push( OCPP16ServiceUtils.buildSampledValue( energySampledValueTemplate, - Utils.roundTo( + roundTo( chargingStation.getEnergyActiveImportRegisterByTransactionId(transactionId) / unitDivider, - 2 - ) - ) + 2, + ), + ), ); const sampledValuesIndex = meterValue.sampledValue.length - 1; - if (energyValueRounded > connectorMaximumEnergyRounded || debug) { + if ( + energyValueRounded > connectorMaximumEnergyRounded || + energyValueRounded < connectorMinimumEnergyRounded || + debug + ) { logger.error( `${chargingStation.logPrefix()} MeterValues measurand ${ meterValue.sampledValue[sampledValuesIndex].measurand ?? OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER - }: connectorId ${connectorId}, transaction ${ - connector.transactionId - }, value: ${energyValueRounded}/${connectorMaximumEnergyRounded}, duration: ${Utils.roundTo( - interval / (3600 * 1000), - 4 - )}h` + }: connector id ${connectorId}, transaction id ${connector?.transactionId}, value: ${connectorMinimumEnergyRounded}/${energyValueRounded}/${connectorMaximumEnergyRounded}, duration: ${interval}ms`, ); } } @@ -683,24 +843,24 @@ export class OCPP16ServiceUtils extends OCPPServiceUtils { public static buildTransactionBeginMeterValue( chargingStation: ChargingStation, connectorId: number, - meterStart: number + meterStart: number, ): OCPP16MeterValue { const meterValue: OCPP16MeterValue = { - timestamp: new Date().toISOString(), + timestamp: new Date(), sampledValue: [], }; // Energy.Active.Import.Register measurand (default) - const sampledValueTemplate = ChargingStationUtils.getSampledValueTemplate( + const sampledValueTemplate = OCPP16ServiceUtils.getSampledValueTemplate( chargingStation, - connectorId + connectorId, ); const unitDivider = sampledValueTemplate?.unit === MeterValueUnit.KILO_WATT_HOUR ? 1000 : 1; meterValue.sampledValue.push( OCPP16ServiceUtils.buildSampledValue( - sampledValueTemplate, - Utils.roundTo(meterStart / unitDivider, 4), - MeterValueContext.TRANSACTION_BEGIN - ) + sampledValueTemplate!, + roundTo((meterStart ?? 0) / unitDivider, 4), + MeterValueContext.TRANSACTION_BEGIN, + ), ); return meterValue; } @@ -708,31 +868,31 @@ export class OCPP16ServiceUtils extends OCPPServiceUtils { public static buildTransactionEndMeterValue( chargingStation: ChargingStation, connectorId: number, - meterStop: number + meterStop: number, ): OCPP16MeterValue { const meterValue: OCPP16MeterValue = { - timestamp: new Date().toISOString(), + timestamp: new Date(), sampledValue: [], }; // Energy.Active.Import.Register measurand (default) - const sampledValueTemplate = ChargingStationUtils.getSampledValueTemplate( + const sampledValueTemplate = OCPP16ServiceUtils.getSampledValueTemplate( chargingStation, - connectorId + connectorId, ); const unitDivider = sampledValueTemplate?.unit === MeterValueUnit.KILO_WATT_HOUR ? 1000 : 1; meterValue.sampledValue.push( OCPP16ServiceUtils.buildSampledValue( - sampledValueTemplate, - Utils.roundTo(meterStop / unitDivider, 4), - MeterValueContext.TRANSACTION_END - ) + sampledValueTemplate!, + roundTo((meterStop ?? 0) / unitDivider, 4), + MeterValueContext.TRANSACTION_END, + ), ); return meterValue; } public static buildTransactionDataMeterValues( transactionBeginMeterValue: OCPP16MeterValue, - transactionEndMeterValue: OCPP16MeterValue + transactionEndMeterValue: OCPP16MeterValue, ): OCPP16MeterValue[] { const meterValues: OCPP16MeterValue[] = []; meterValues.push(transactionBeginMeterValue); @@ -740,37 +900,466 @@ export class OCPP16ServiceUtils extends OCPPServiceUtils { return meterValues; } + public static remoteStopTransaction = async ( + chargingStation: ChargingStation, + connectorId: number, + ): Promise => { + await OCPP16ServiceUtils.sendAndSetConnectorStatus( + chargingStation, + connectorId, + OCPP16ChargePointStatus.Finishing, + ); + const stopResponse = await chargingStation.stopTransactionOnConnector( + connectorId, + OCPP16StopTransactionReason.REMOTE, + ); + if (stopResponse.idTagInfo?.status === OCPP16AuthorizationStatus.ACCEPTED) { + return OCPP16Constants.OCPP_RESPONSE_ACCEPTED; + } + return OCPP16Constants.OCPP_RESPONSE_REJECTED; + }; + + public static changeAvailability = async ( + chargingStation: ChargingStation, + connectorIds: number[], + chargePointStatus: OCPP16ChargePointStatus, + availabilityType: OCPP16AvailabilityType, + ): Promise => { + const responses: OCPP16ChangeAvailabilityResponse[] = []; + for (const connectorId of connectorIds) { + let response: OCPP16ChangeAvailabilityResponse = + OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_ACCEPTED; + const connectorStatus = chargingStation.getConnectorStatus(connectorId)!; + if (connectorStatus?.transactionStarted === true) { + response = OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_SCHEDULED; + } + connectorStatus.availability = availabilityType; + if (response === OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_ACCEPTED) { + await OCPP16ServiceUtils.sendAndSetConnectorStatus( + chargingStation, + connectorId, + chargePointStatus, + ); + } + responses.push(response); + } + if (responses.includes(OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_SCHEDULED)) { + return OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_SCHEDULED; + } + return OCPP16Constants.OCPP_AVAILABILITY_RESPONSE_ACCEPTED; + }; + + public static setChargingProfile( + chargingStation: ChargingStation, + connectorId: number, + cp: OCPP16ChargingProfile, + ): void { + if (isNullOrUndefined(chargingStation.getConnectorStatus(connectorId)?.chargingProfiles)) { + logger.error( + `${chargingStation.logPrefix()} Trying to set a charging profile on connector id ${connectorId} with an uninitialized charging profiles array attribute, applying deferred initialization`, + ); + chargingStation.getConnectorStatus(connectorId)!.chargingProfiles = []; + } + if ( + Array.isArray(chargingStation.getConnectorStatus(connectorId)?.chargingProfiles) === false + ) { + logger.error( + `${chargingStation.logPrefix()} Trying to set a charging profile on connector id ${connectorId} with an improper attribute type for the charging profiles array, applying proper type deferred initialization`, + ); + chargingStation.getConnectorStatus(connectorId)!.chargingProfiles = []; + } + let cpReplaced = false; + if (isNotEmptyArray(chargingStation.getConnectorStatus(connectorId)?.chargingProfiles)) { + chargingStation + .getConnectorStatus(connectorId) + ?.chargingProfiles?.forEach((chargingProfile: OCPP16ChargingProfile, index: number) => { + if ( + chargingProfile.chargingProfileId === cp.chargingProfileId || + (chargingProfile.stackLevel === cp.stackLevel && + chargingProfile.chargingProfilePurpose === cp.chargingProfilePurpose) + ) { + chargingStation.getConnectorStatus(connectorId)!.chargingProfiles![index] = cp; + cpReplaced = true; + } + }); + } + !cpReplaced && chargingStation.getConnectorStatus(connectorId)?.chargingProfiles?.push(cp); + } + + public static clearChargingProfiles = ( + chargingStation: ChargingStation, + commandPayload: ClearChargingProfileRequest, + chargingProfiles: OCPP16ChargingProfile[] | undefined, + ): boolean => { + const { id, chargingProfilePurpose, stackLevel } = commandPayload; + let clearedCP = false; + if (isNotEmptyArray(chargingProfiles)) { + chargingProfiles?.forEach((chargingProfile: OCPP16ChargingProfile, index: number) => { + let clearCurrentCP = false; + if (chargingProfile.chargingProfileId === id) { + clearCurrentCP = true; + } + if (!chargingProfilePurpose && chargingProfile.stackLevel === stackLevel) { + clearCurrentCP = true; + } + if (!stackLevel && chargingProfile.chargingProfilePurpose === chargingProfilePurpose) { + clearCurrentCP = true; + } + if ( + chargingProfile.stackLevel === stackLevel && + chargingProfile.chargingProfilePurpose === chargingProfilePurpose + ) { + clearCurrentCP = true; + } + if (clearCurrentCP) { + chargingProfiles.splice(index, 1); + logger.debug( + `${chargingStation.logPrefix()} Matching charging profile(s) cleared: %j`, + chargingProfile, + ); + clearedCP = true; + } + }); + } + return clearedCP; + }; + + public static composeChargingSchedules = ( + chargingScheduleHigher: OCPP16ChargingSchedule | undefined, + chargingScheduleLower: OCPP16ChargingSchedule | undefined, + compositeInterval: Interval, + ): OCPP16ChargingSchedule | undefined => { + if (!chargingScheduleHigher && !chargingScheduleLower) { + return undefined; + } + if (chargingScheduleHigher && !chargingScheduleLower) { + return OCPP16ServiceUtils.composeChargingSchedule(chargingScheduleHigher, compositeInterval); + } + if (!chargingScheduleHigher && chargingScheduleLower) { + return OCPP16ServiceUtils.composeChargingSchedule(chargingScheduleLower, compositeInterval); + } + const compositeChargingScheduleHigher: OCPP16ChargingSchedule | undefined = + OCPP16ServiceUtils.composeChargingSchedule(chargingScheduleHigher!, compositeInterval); + const compositeChargingScheduleLower: OCPP16ChargingSchedule | undefined = + OCPP16ServiceUtils.composeChargingSchedule(chargingScheduleLower!, compositeInterval); + const compositeChargingScheduleHigherInterval: Interval = { + start: compositeChargingScheduleHigher!.startSchedule!, + end: addSeconds( + compositeChargingScheduleHigher!.startSchedule!, + compositeChargingScheduleHigher!.duration!, + ), + }; + const compositeChargingScheduleLowerInterval: Interval = { + start: compositeChargingScheduleLower!.startSchedule!, + end: addSeconds( + compositeChargingScheduleLower!.startSchedule!, + compositeChargingScheduleLower!.duration!, + ), + }; + const higherFirst = isBefore( + compositeChargingScheduleHigherInterval.start, + compositeChargingScheduleLowerInterval.start, + ); + if ( + !areIntervalsOverlapping( + compositeChargingScheduleHigherInterval, + compositeChargingScheduleLowerInterval, + ) + ) { + return { + ...compositeChargingScheduleLower, + ...compositeChargingScheduleHigher!, + startSchedule: higherFirst + ? (compositeChargingScheduleHigherInterval.start as Date) + : (compositeChargingScheduleLowerInterval.start as Date), + duration: higherFirst + ? differenceInSeconds( + compositeChargingScheduleLowerInterval.end, + compositeChargingScheduleHigherInterval.start, + ) + : differenceInSeconds( + compositeChargingScheduleHigherInterval.end, + compositeChargingScheduleLowerInterval.start, + ), + chargingSchedulePeriod: [ + ...compositeChargingScheduleHigher!.chargingSchedulePeriod.map((schedulePeriod) => { + return { + ...schedulePeriod, + startPeriod: higherFirst + ? 0 + : schedulePeriod.startPeriod + + differenceInSeconds( + compositeChargingScheduleHigherInterval.start, + compositeChargingScheduleLowerInterval.start, + ), + }; + }), + ...compositeChargingScheduleLower!.chargingSchedulePeriod.map((schedulePeriod) => { + return { + ...schedulePeriod, + startPeriod: higherFirst + ? schedulePeriod.startPeriod + + differenceInSeconds( + compositeChargingScheduleLowerInterval.start, + compositeChargingScheduleHigherInterval.start, + ) + : 0, + }; + }), + ].sort((a, b) => a.startPeriod - b.startPeriod), + }; + } + return { + ...compositeChargingScheduleLower, + ...compositeChargingScheduleHigher!, + startSchedule: higherFirst + ? (compositeChargingScheduleHigherInterval.start as Date) + : (compositeChargingScheduleLowerInterval.start as Date), + duration: higherFirst + ? differenceInSeconds( + compositeChargingScheduleLowerInterval.end, + compositeChargingScheduleHigherInterval.start, + ) + : differenceInSeconds( + compositeChargingScheduleHigherInterval.end, + compositeChargingScheduleLowerInterval.start, + ), + chargingSchedulePeriod: [ + ...compositeChargingScheduleHigher!.chargingSchedulePeriod.map((schedulePeriod) => { + return { + ...schedulePeriod, + startPeriod: higherFirst + ? 0 + : schedulePeriod.startPeriod + + differenceInSeconds( + compositeChargingScheduleHigherInterval.start, + compositeChargingScheduleLowerInterval.start, + ), + }; + }), + ...compositeChargingScheduleLower!.chargingSchedulePeriod + .filter((schedulePeriod, index) => { + if ( + higherFirst && + isWithinInterval( + addSeconds( + compositeChargingScheduleLowerInterval.start, + schedulePeriod.startPeriod, + ), + { + start: compositeChargingScheduleLowerInterval.start, + end: compositeChargingScheduleHigherInterval.end, + }, + ) + ) { + return false; + } + if ( + higherFirst && + index < compositeChargingScheduleLower!.chargingSchedulePeriod.length - 1 && + !isWithinInterval( + addSeconds( + compositeChargingScheduleLowerInterval.start, + schedulePeriod.startPeriod, + ), + { + start: compositeChargingScheduleLowerInterval.start, + end: compositeChargingScheduleHigherInterval.end, + }, + ) && + isWithinInterval( + addSeconds( + compositeChargingScheduleLowerInterval.start, + compositeChargingScheduleLower!.chargingSchedulePeriod[index + 1].startPeriod, + ), + { + start: compositeChargingScheduleLowerInterval.start, + end: compositeChargingScheduleHigherInterval.end, + }, + ) + ) { + return false; + } + if ( + !higherFirst && + isWithinInterval( + addSeconds( + compositeChargingScheduleLowerInterval.start, + schedulePeriod.startPeriod, + ), + { + start: compositeChargingScheduleHigherInterval.start, + end: compositeChargingScheduleLowerInterval.end, + }, + ) + ) { + return false; + } + return true; + }) + .map((schedulePeriod, index) => { + if (index === 0 && schedulePeriod.startPeriod !== 0) { + schedulePeriod.startPeriod = 0; + } + return { + ...schedulePeriod, + startPeriod: higherFirst + ? schedulePeriod.startPeriod + + differenceInSeconds( + compositeChargingScheduleLowerInterval.start, + compositeChargingScheduleHigherInterval.start, + ) + : 0, + }; + }), + ].sort((a, b) => a.startPeriod - b.startPeriod), + }; + }; + + public static hasReservation = ( + chargingStation: ChargingStation, + connectorId: number, + idTag: string, + ): boolean => { + const connectorReservation = chargingStation.getReservationBy('connectorId', connectorId); + const chargingStationReservation = chargingStation.getReservationBy('connectorId', 0); + if ( + (chargingStation.getConnectorStatus(connectorId)?.status === + OCPP16ChargePointStatus.Reserved && + connectorReservation && + !hasReservationExpired(connectorReservation) && + // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing + connectorReservation?.idTag === idTag) || + (chargingStation.getConnectorStatus(0)?.status === OCPP16ChargePointStatus.Reserved && + chargingStationReservation && + !hasReservationExpired(chargingStationReservation) && + chargingStationReservation?.idTag === idTag) + ) { + logger.debug( + `${chargingStation.logPrefix()} Connector id ${connectorId} has a valid reservation for idTag ${idTag}: %j`, + connectorReservation ?? chargingStationReservation, + ); + return true; + } + return false; + }; + + public static parseJsonSchemaFile( + relativePath: string, + moduleName?: string, + methodName?: string, + ): JSONSchemaType { + return super.parseJsonSchemaFile( + relativePath, + OCPPVersion.VERSION_16, + moduleName, + methodName, + ); + } + + private static composeChargingSchedule = ( + chargingSchedule: OCPP16ChargingSchedule, + compositeInterval: Interval, + ): OCPP16ChargingSchedule | undefined => { + const chargingScheduleInterval: Interval = { + start: chargingSchedule.startSchedule!, + end: addSeconds(chargingSchedule.startSchedule!, chargingSchedule.duration!), + }; + if (areIntervalsOverlapping(chargingScheduleInterval, compositeInterval)) { + chargingSchedule.chargingSchedulePeriod.sort((a, b) => a.startPeriod - b.startPeriod); + if (isBefore(chargingScheduleInterval.start, compositeInterval.start)) { + return { + ...chargingSchedule, + startSchedule: compositeInterval.start as Date, + duration: differenceInSeconds( + chargingScheduleInterval.end, + compositeInterval.start as Date, + ), + chargingSchedulePeriod: chargingSchedule.chargingSchedulePeriod + .filter((schedulePeriod, index) => { + if ( + isWithinInterval( + addSeconds(chargingScheduleInterval.start, schedulePeriod.startPeriod)!, + compositeInterval, + ) + ) { + return true; + } + if ( + index < chargingSchedule.chargingSchedulePeriod.length - 1 && + !isWithinInterval( + addSeconds(chargingScheduleInterval.start, schedulePeriod.startPeriod), + compositeInterval, + ) && + isWithinInterval( + addSeconds( + chargingScheduleInterval.start, + chargingSchedule.chargingSchedulePeriod[index + 1].startPeriod, + ), + compositeInterval, + ) + ) { + return true; + } + return false; + }) + .map((schedulePeriod, index) => { + if (index === 0 && schedulePeriod.startPeriod !== 0) { + schedulePeriod.startPeriod = 0; + } + return schedulePeriod; + }), + }; + } + if (isAfter(chargingScheduleInterval.end, compositeInterval.end)) { + return { + ...chargingSchedule, + duration: differenceInSeconds( + compositeInterval.end as Date, + chargingScheduleInterval.start, + ), + chargingSchedulePeriod: chargingSchedule.chargingSchedulePeriod.filter((schedulePeriod) => + isWithinInterval( + addSeconds(chargingScheduleInterval.start, schedulePeriod.startPeriod)!, + compositeInterval, + ), + ), + }; + } + return chargingSchedule; + } + }; + private static buildSampledValue( sampledValueTemplate: SampledValueTemplate, value: number, context?: MeterValueContext, - phase?: OCPP16MeterValuePhase + phase?: OCPP16MeterValuePhase, ): OCPP16SampledValue { - const sampledValueValue = value ?? sampledValueTemplate?.value ?? null; - const sampledValueContext = context ?? sampledValueTemplate?.context ?? null; + const sampledValueContext = context ?? sampledValueTemplate?.context; const sampledValueLocation = sampledValueTemplate?.location ?? - OCPP16ServiceUtils.getMeasurandDefaultLocation(sampledValueTemplate?.measurand ?? null); - const sampledValuePhase = phase ?? sampledValueTemplate?.phase ?? null; + OCPP16ServiceUtils.getMeasurandDefaultLocation(sampledValueTemplate.measurand!); + const sampledValuePhase = phase ?? sampledValueTemplate?.phase; return { - ...(!Utils.isNullOrUndefined(sampledValueTemplate.unit) && { + ...(!isNullOrUndefined(sampledValueTemplate.unit) && { unit: sampledValueTemplate.unit, }), - ...(!Utils.isNullOrUndefined(sampledValueContext) && { context: sampledValueContext }), - ...(!Utils.isNullOrUndefined(sampledValueTemplate.measurand) && { + ...(!isNullOrUndefined(sampledValueContext) && { context: sampledValueContext }), + ...(!isNullOrUndefined(sampledValueTemplate.measurand) && { measurand: sampledValueTemplate.measurand, }), - ...(!Utils.isNullOrUndefined(sampledValueLocation) && { location: sampledValueLocation }), - ...(!Utils.isNullOrUndefined(sampledValueValue) && { value: sampledValueValue.toString() }), - ...(!Utils.isNullOrUndefined(sampledValuePhase) && { phase: sampledValuePhase }), - }; + ...(!isNullOrUndefined(sampledValueLocation) && { location: sampledValueLocation }), + ...(!isNullOrUndefined(value) && { value: value.toString() }), + ...(!isNullOrUndefined(sampledValuePhase) && { phase: sampledValuePhase }), + } as OCPP16SampledValue; } private static checkMeasurandPowerDivider( chargingStation: ChargingStation, - measurandType: OCPP16MeterValueMeasurand + measurandType: OCPP16MeterValueMeasurand, ): void { - if (Utils.isUndefined(chargingStation.powerDivider)) { + if (isUndefined(chargingStation.powerDivider)) { const errMsg = `MeterValues measurand ${ measurandType ?? OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER }: powerDivider is undefined`; @@ -786,7 +1375,7 @@ export class OCPP16ServiceUtils extends OCPPServiceUtils { } private static getMeasurandDefaultLocation( - measurandType: OCPP16MeterValueMeasurand + measurandType: OCPP16MeterValueMeasurand, ): MeterValueLocation | undefined { switch (measurandType) { case OCPP16MeterValueMeasurand.STATE_OF_CHARGE: @@ -794,25 +1383,25 @@ export class OCPP16ServiceUtils extends OCPPServiceUtils { } } - private static getMeasurandDefaultUnit( - measurandType: OCPP16MeterValueMeasurand - ): MeterValueUnit | undefined { - switch (measurandType) { - case OCPP16MeterValueMeasurand.CURRENT_EXPORT: - case OCPP16MeterValueMeasurand.CURRENT_IMPORT: - case OCPP16MeterValueMeasurand.CURRENT_OFFERED: - return MeterValueUnit.AMP; - case OCPP16MeterValueMeasurand.ENERGY_ACTIVE_EXPORT_REGISTER: - case OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER: - return MeterValueUnit.WATT_HOUR; - case OCPP16MeterValueMeasurand.POWER_ACTIVE_EXPORT: - case OCPP16MeterValueMeasurand.POWER_ACTIVE_IMPORT: - case OCPP16MeterValueMeasurand.POWER_OFFERED: - return MeterValueUnit.WATT; - case OCPP16MeterValueMeasurand.STATE_OF_CHARGE: - return MeterValueUnit.PERCENT; - case OCPP16MeterValueMeasurand.VOLTAGE: - return MeterValueUnit.VOLT; - } - } + // private static getMeasurandDefaultUnit( + // measurandType: OCPP16MeterValueMeasurand, + // ): MeterValueUnit | undefined { + // switch (measurandType) { + // case OCPP16MeterValueMeasurand.CURRENT_EXPORT: + // case OCPP16MeterValueMeasurand.CURRENT_IMPORT: + // case OCPP16MeterValueMeasurand.CURRENT_OFFERED: + // return MeterValueUnit.AMP; + // case OCPP16MeterValueMeasurand.ENERGY_ACTIVE_EXPORT_REGISTER: + // case OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER: + // return MeterValueUnit.WATT_HOUR; + // case OCPP16MeterValueMeasurand.POWER_ACTIVE_EXPORT: + // case OCPP16MeterValueMeasurand.POWER_ACTIVE_IMPORT: + // case OCPP16MeterValueMeasurand.POWER_OFFERED: + // return MeterValueUnit.WATT; + // case OCPP16MeterValueMeasurand.STATE_OF_CHARGE: + // return MeterValueUnit.PERCENT; + // case OCPP16MeterValueMeasurand.VOLTAGE: + // return MeterValueUnit.VOLT; + // } + // } }