X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2Fcharging-station%2Focpp%2F1.6%2FOCPP16ServiceUtils.ts;h=4062bc0af881d3445fdfc5207983d531dbf89b2a;hb=41f3983a4f934199769f9ef1c46bfae2adc22b56;hp=2dc498e82a28a5071a8cc0ce48449ce7509afefa;hpb=ed3d28080b6597ba2f728d625e34ce05aea49d06;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 2dc498e8..4062bc0a 100644 --- a/src/charging-station/ocpp/1.6/OCPP16ServiceUtils.ts +++ b/src/charging-station/ocpp/1.6/OCPP16ServiceUtils.ts @@ -1,742 +1,91 @@ -// Partial Copyright Jerome Benoit. 2021. All Rights Reserved. +// Partial Copyright Jerome Benoit. 2021-2023. All Rights Reserved. -import BaseError from '../../../exception/BaseError'; -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 { - MeterValueContext, - MeterValueLocation, - MeterValueUnit, - OCPP16MeterValue, - OCPP16MeterValueMeasurand, - OCPP16MeterValuePhase, - OCPP16SampledValue, -} from '../../../types/ocpp/1.6/MeterValues'; + type ChargingStation, + hasFeatureProfile, + hasReservationExpired, +} from '../../../charging-station'; import { - OCPP16IncomingRequestCommand, + type GenericResponse, + type JsonType, + OCPP16AuthorizationStatus, + OCPP16AvailabilityType, + type OCPP16ChangeAvailabilityResponse, + OCPP16ChargePointStatus, + type OCPP16ChargingProfile, + type OCPP16ChargingSchedule, + type OCPP16ClearChargingProfileRequest, + type OCPP16IncomingRequestCommand, + type OCPP16MeterValue, + OCPP16MeterValueContext, + OCPP16MeterValueUnit, OCPP16RequestCommand, -} from '../../../types/ocpp/1.6/Requests'; -import type { ChargingProfile } from '../../../types/ocpp/ChargingProfile'; -import { StandardParametersKey } from '../../../types/ocpp/Configuration'; -import { ErrorType } from '../../../types/ocpp/ErrorType'; -import { MeterValueMeasurand, type MeterValuePhase } from '../../../types/ocpp/MeterValues'; -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 { ChargingStationConfigurationUtils } from '../../ChargingStationConfigurationUtils'; + OCPP16StandardParametersKey, + OCPP16StopTransactionReason, + type OCPP16SupportedFeatureProfiles, + OCPPVersion, +} from '../../../types'; +import { isNotEmptyArray, isNullOrUndefined, 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; } return true; } - public static buildMeterValue( - chargingStation: ChargingStation, - connectorId: number, - transactionId: number, - interval: number, - debug = false - ): OCPP16MeterValue { - const meterValue: OCPP16MeterValue = { - timestamp: new Date().toISOString(), - sampledValue: [], - }; - const connector = chargingStation.getConnectorStatus(connectorId); - // SoC measurand - const socSampledValueTemplate = OCPP16ServiceUtils.getSampledValueTemplate( - chargingStation, - connectorId, - OCPP16MeterValueMeasurand.STATE_OF_CHARGE - ); - if (socSampledValueTemplate) { - const socSampledValueTemplateValue = socSampledValueTemplate.value - ? Utils.getRandomFloatFluctuatedRounded( - parseInt(socSampledValueTemplate.value), - socSampledValueTemplate.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT - ) - : Utils.getRandomInteger(100); - meterValue.sampledValue.push( - OCPP16ServiceUtils.buildSampledValue(socSampledValueTemplate, socSampledValueTemplateValue) - ); - const sampledValuesIndex = meterValue.sampledValue.length - 1; - if (Utils.convertToInt(meterValue.sampledValue[sampledValuesIndex].value) > 100 || debug) { - logger.error( - `${chargingStation.logPrefix()} MeterValues measurand ${ - meterValue.sampledValue[sampledValuesIndex].measurand ?? - OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER - }: connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${ - meterValue.sampledValue[sampledValuesIndex].value - }/100` - ); - } - } - // Voltage measurand - const voltageSampledValueTemplate = OCPP16ServiceUtils.getSampledValueTemplate( - chargingStation, - connectorId, - OCPP16MeterValueMeasurand.VOLTAGE - ); - if (voltageSampledValueTemplate) { - const voltageSampledValueTemplateValue = voltageSampledValueTemplate.value - ? parseInt(voltageSampledValueTemplate.value) - : chargingStation.getVoltageOut(); - const fluctuationPercent = - voltageSampledValueTemplate.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT; - const voltageMeasurandValue = Utils.getRandomFloatFluctuatedRounded( - voltageSampledValueTemplateValue, - fluctuationPercent - ); - if ( - chargingStation.getNumberOfPhases() !== 3 || - (chargingStation.getNumberOfPhases() === 3 && chargingStation.getMainVoltageMeterValues()) - ) { - meterValue.sampledValue.push( - OCPP16ServiceUtils.buildSampledValue(voltageSampledValueTemplate, voltageMeasurandValue) - ); - } - for ( - let phase = 1; - chargingStation.getNumberOfPhases() === 3 && phase <= chargingStation.getNumberOfPhases(); - phase++ - ) { - const phaseLineToNeutralValue = `L${phase}-N`; - const voltagePhaseLineToNeutralSampledValueTemplate = - OCPP16ServiceUtils.getSampledValueTemplate( - chargingStation, - connectorId, - OCPP16MeterValueMeasurand.VOLTAGE, - phaseLineToNeutralValue as OCPP16MeterValuePhase - ); - let voltagePhaseLineToNeutralMeasurandValue: number; - if (voltagePhaseLineToNeutralSampledValueTemplate) { - const voltagePhaseLineToNeutralSampledValueTemplateValue = - voltagePhaseLineToNeutralSampledValueTemplate.value - ? parseInt(voltagePhaseLineToNeutralSampledValueTemplate.value) - : chargingStation.getVoltageOut(); - const fluctuationPhaseToNeutralPercent = - voltagePhaseLineToNeutralSampledValueTemplate.fluctuationPercent ?? - Constants.DEFAULT_FLUCTUATION_PERCENT; - voltagePhaseLineToNeutralMeasurandValue = Utils.getRandomFloatFluctuatedRounded( - voltagePhaseLineToNeutralSampledValueTemplateValue, - fluctuationPhaseToNeutralPercent - ); - } - meterValue.sampledValue.push( - OCPP16ServiceUtils.buildSampledValue( - voltagePhaseLineToNeutralSampledValueTemplate ?? voltageSampledValueTemplate, - voltagePhaseLineToNeutralMeasurandValue ?? voltageMeasurandValue, - null, - phaseLineToNeutralValue as OCPP16MeterValuePhase - ) - ); - if (chargingStation.getPhaseLineToLineVoltageMeterValues()) { - const phaseLineToLineValue = `L${phase}-L${ - (phase + 1) % chargingStation.getNumberOfPhases() !== 0 - ? (phase + 1) % chargingStation.getNumberOfPhases() - : chargingStation.getNumberOfPhases() - }`; - const voltagePhaseLineToLineSampledValueTemplate = - OCPP16ServiceUtils.getSampledValueTemplate( - chargingStation, - connectorId, - OCPP16MeterValueMeasurand.VOLTAGE, - phaseLineToLineValue as OCPP16MeterValuePhase - ); - let voltagePhaseLineToLineMeasurandValue: number; - if (voltagePhaseLineToLineSampledValueTemplate) { - const voltagePhaseLineToLineSampledValueTemplateValue = - voltagePhaseLineToLineSampledValueTemplate.value - ? parseInt(voltagePhaseLineToLineSampledValueTemplate.value) - : Voltage.VOLTAGE_400; - const fluctuationPhaseLineToLinePercent = - voltagePhaseLineToLineSampledValueTemplate.fluctuationPercent ?? - Constants.DEFAULT_FLUCTUATION_PERCENT; - voltagePhaseLineToLineMeasurandValue = Utils.getRandomFloatFluctuatedRounded( - voltagePhaseLineToLineSampledValueTemplateValue, - fluctuationPhaseLineToLinePercent - ); - } - const defaultVoltagePhaseLineToLineMeasurandValue = Utils.getRandomFloatFluctuatedRounded( - Voltage.VOLTAGE_400, - fluctuationPercent - ); - meterValue.sampledValue.push( - OCPP16ServiceUtils.buildSampledValue( - voltagePhaseLineToLineSampledValueTemplate ?? voltageSampledValueTemplate, - voltagePhaseLineToLineMeasurandValue ?? defaultVoltagePhaseLineToLineMeasurandValue, - null, - phaseLineToLineValue as OCPP16MeterValuePhase - ) - ); - } - } - } - // Power.Active.Import measurand - const powerSampledValueTemplate = OCPP16ServiceUtils.getSampledValueTemplate( - chargingStation, - connectorId, - OCPP16MeterValueMeasurand.POWER_ACTIVE_IMPORT - ); - let powerPerPhaseSampledValueTemplates: MeasurandPerPhaseSampledValueTemplates = {}; - if (chargingStation.getNumberOfPhases() === 3) { - powerPerPhaseSampledValueTemplates = { - L1: OCPP16ServiceUtils.getSampledValueTemplate( - chargingStation, - connectorId, - OCPP16MeterValueMeasurand.POWER_ACTIVE_IMPORT, - OCPP16MeterValuePhase.L1_N - ), - L2: OCPP16ServiceUtils.getSampledValueTemplate( - chargingStation, - connectorId, - OCPP16MeterValueMeasurand.POWER_ACTIVE_IMPORT, - OCPP16MeterValuePhase.L2_N - ), - L3: OCPP16ServiceUtils.getSampledValueTemplate( - chargingStation, - connectorId, - OCPP16MeterValueMeasurand.POWER_ACTIVE_IMPORT, - OCPP16MeterValuePhase.L3_N - ), - }; - } - if (powerSampledValueTemplate) { - OCPP16ServiceUtils.checkMeasurandPowerDivider( - chargingStation, - powerSampledValueTemplate.measurand - ); - const errMsg = `MeterValues measurand ${ - powerSampledValueTemplate.measurand ?? - OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER - }: Unknown ${chargingStation.getCurrentOutType()} currentOutType in template file ${ - chargingStation.templateFile - }, cannot calculate ${ - powerSampledValueTemplate.measurand ?? - OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER - } measurand value`; - const powerMeasurandValues = {} 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() - ); - switch (chargingStation.getCurrentOutType()) { - 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 - ); - powerMeasurandValues.L1 = - phase1FluctuatedValue ?? - defaultFluctuatedPowerPerPhase ?? - Utils.getRandomFloatRounded(connectorMaximumPowerPerPhase / unitDivider); - powerMeasurandValues.L2 = - phase2FluctuatedValue ?? - defaultFluctuatedPowerPerPhase ?? - Utils.getRandomFloatRounded(connectorMaximumPowerPerPhase / unitDivider); - powerMeasurandValues.L3 = - phase3FluctuatedValue ?? - defaultFluctuatedPowerPerPhase ?? - Utils.getRandomFloatRounded(connectorMaximumPowerPerPhase / unitDivider); - } else { - powerMeasurandValues.L1 = powerSampledValueTemplate.value - ? Utils.getRandomFloatFluctuatedRounded( - OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( - powerSampledValueTemplate.value, - connectorMaximumPower / unitDivider, - { limitationEnabled: chargingStation.getCustomValueLimitationMeterValues() } - ), - powerSampledValueTemplate.fluctuationPercent ?? - Constants.DEFAULT_FLUCTUATION_PERCENT - ) - : Utils.getRandomFloatRounded(connectorMaximumPower / unitDivider); - powerMeasurandValues.L2 = 0; - powerMeasurandValues.L3 = 0; - } - powerMeasurandValues.allPhases = Utils.roundTo( - powerMeasurandValues.L1 + powerMeasurandValues.L2 + powerMeasurandValues.L3, - 2 - ); - break; - case CurrentType.DC: - powerMeasurandValues.allPhases = powerSampledValueTemplate.value - ? Utils.getRandomFloatFluctuatedRounded( - OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( - powerSampledValueTemplate.value, - connectorMaximumPower / unitDivider, - { limitationEnabled: chargingStation.getCustomValueLimitationMeterValues() } - ), - powerSampledValueTemplate.fluctuationPercent ?? - Constants.DEFAULT_FLUCTUATION_PERCENT - ) - : Utils.getRandomFloatRounded(connectorMaximumPower / unitDivider); - break; - default: - logger.error(`${chargingStation.logPrefix()} ${errMsg}`); - throw new OCPPError(ErrorType.INTERNAL_ERROR, errMsg, OCPP16RequestCommand.METER_VALUES); - } - meterValue.sampledValue.push( - OCPP16ServiceUtils.buildSampledValue( - powerSampledValueTemplate, - powerMeasurandValues.allPhases - ) - ); - const sampledValuesIndex = meterValue.sampledValue.length - 1; - const connectorMaximumPowerRounded = Utils.roundTo(connectorMaximumPower / unitDivider, 2); - if ( - Utils.convertToFloat(meterValue.sampledValue[sampledValuesIndex].value) > - connectorMaximumPowerRounded || - debug - ) { - logger.error( - `${chargingStation.logPrefix()} MeterValues measurand ${ - meterValue.sampledValue[sampledValuesIndex].measurand ?? - OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER - }: connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${ - meterValue.sampledValue[sampledValuesIndex].value - }/${connectorMaximumPowerRounded}` - ); - } - for ( - let phase = 1; - chargingStation.getNumberOfPhases() === 3 && phase <= chargingStation.getNumberOfPhases(); - phase++ - ) { - 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 - ) - ); - const sampledValuesPerPhaseIndex = meterValue.sampledValue.length - 1; - const connectorMaximumPowerPerPhaseRounded = Utils.roundTo( - connectorMaximumPowerPerPhase / unitDivider, - 2 - ); - if ( - Utils.convertToFloat(meterValue.sampledValue[sampledValuesPerPhaseIndex].value) > - connectorMaximumPowerPerPhaseRounded || - debug - ) { - logger.error( - `${chargingStation.logPrefix()} MeterValues measurand ${ - meterValue.sampledValue[sampledValuesPerPhaseIndex].measurand ?? - OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER - }: phase ${ - meterValue.sampledValue[sampledValuesPerPhaseIndex].phase - }, connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${ - meterValue.sampledValue[sampledValuesPerPhaseIndex].value - }/${connectorMaximumPowerPerPhaseRounded}` - ); - } - } - } - // Current.Import measurand - const currentSampledValueTemplate = OCPP16ServiceUtils.getSampledValueTemplate( - chargingStation, - connectorId, - OCPP16MeterValueMeasurand.CURRENT_IMPORT - ); - let currentPerPhaseSampledValueTemplates: MeasurandPerPhaseSampledValueTemplates = {}; - if (chargingStation.getNumberOfPhases() === 3) { - currentPerPhaseSampledValueTemplates = { - L1: OCPP16ServiceUtils.getSampledValueTemplate( - chargingStation, - connectorId, - OCPP16MeterValueMeasurand.CURRENT_IMPORT, - OCPP16MeterValuePhase.L1 - ), - L2: OCPP16ServiceUtils.getSampledValueTemplate( - chargingStation, - connectorId, - OCPP16MeterValueMeasurand.CURRENT_IMPORT, - OCPP16MeterValuePhase.L2 - ), - L3: OCPP16ServiceUtils.getSampledValueTemplate( - chargingStation, - connectorId, - OCPP16MeterValueMeasurand.CURRENT_IMPORT, - OCPP16MeterValuePhase.L3 - ), - }; - } - if (currentSampledValueTemplate) { - OCPP16ServiceUtils.checkMeasurandPowerDivider( - chargingStation, - currentSampledValueTemplate.measurand - ); - const errMsg = `MeterValues measurand ${ - currentSampledValueTemplate.measurand ?? - OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER - }: Unknown ${chargingStation.getCurrentOutType()} currentOutType in template file ${ - chargingStation.templateFile - }, cannot calculate ${ - currentSampledValueTemplate.measurand ?? - OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER - } measurand value`; - const currentMeasurandValues: MeasurandValues = {} as MeasurandValues; - const connectorMaximumAvailablePower = - chargingStation.getConnectorMaximumAvailablePower(connectorId); - let connectorMaximumAmperage: number; - switch (chargingStation.getCurrentOutType()) { - case CurrentType.AC: - connectorMaximumAmperage = ACElectricUtils.amperagePerPhaseFromPower( - chargingStation.getNumberOfPhases(), - connectorMaximumAvailablePower, - chargingStation.getVoltageOut() - ); - 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 - ); - currentMeasurandValues.L1 = - phase1FluctuatedValue ?? - defaultFluctuatedAmperagePerPhase ?? - Utils.getRandomFloatRounded(connectorMaximumAmperage); - currentMeasurandValues.L2 = - phase2FluctuatedValue ?? - defaultFluctuatedAmperagePerPhase ?? - Utils.getRandomFloatRounded(connectorMaximumAmperage); - currentMeasurandValues.L3 = - phase3FluctuatedValue ?? - defaultFluctuatedAmperagePerPhase ?? - Utils.getRandomFloatRounded(connectorMaximumAmperage); - } else { - currentMeasurandValues.L1 = currentSampledValueTemplate.value - ? Utils.getRandomFloatFluctuatedRounded( - OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( - currentSampledValueTemplate.value, - connectorMaximumAmperage, - { limitationEnabled: chargingStation.getCustomValueLimitationMeterValues() } - ), - currentSampledValueTemplate.fluctuationPercent ?? - Constants.DEFAULT_FLUCTUATION_PERCENT - ) - : Utils.getRandomFloatRounded(connectorMaximumAmperage); - currentMeasurandValues.L2 = 0; - currentMeasurandValues.L3 = 0; - } - currentMeasurandValues.allPhases = Utils.roundTo( - (currentMeasurandValues.L1 + currentMeasurandValues.L2 + currentMeasurandValues.L3) / - chargingStation.getNumberOfPhases(), - 2 - ); - break; - case CurrentType.DC: - connectorMaximumAmperage = DCElectricUtils.amperage( - connectorMaximumAvailablePower, - chargingStation.getVoltageOut() - ); - currentMeasurandValues.allPhases = currentSampledValueTemplate.value - ? Utils.getRandomFloatFluctuatedRounded( - OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( - currentSampledValueTemplate.value, - connectorMaximumAmperage, - { limitationEnabled: chargingStation.getCustomValueLimitationMeterValues() } - ), - currentSampledValueTemplate.fluctuationPercent ?? - Constants.DEFAULT_FLUCTUATION_PERCENT - ) - : Utils.getRandomFloatRounded(connectorMaximumAmperage); - break; - default: - logger.error(`${chargingStation.logPrefix()} ${errMsg}`); - throw new OCPPError(ErrorType.INTERNAL_ERROR, errMsg, OCPP16RequestCommand.METER_VALUES); - } - meterValue.sampledValue.push( - OCPP16ServiceUtils.buildSampledValue( - currentSampledValueTemplate, - currentMeasurandValues.allPhases - ) - ); - const sampledValuesIndex = meterValue.sampledValue.length - 1; - if ( - Utils.convertToFloat(meterValue.sampledValue[sampledValuesIndex].value) > - connectorMaximumAmperage || - debug - ) { - logger.error( - `${chargingStation.logPrefix()} MeterValues measurand ${ - meterValue.sampledValue[sampledValuesIndex].measurand ?? - OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER - }: connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${ - meterValue.sampledValue[sampledValuesIndex].value - }/${connectorMaximumAmperage}` - ); - } - for ( - let phase = 1; - chargingStation.getNumberOfPhases() === 3 && phase <= chargingStation.getNumberOfPhases(); - phase++ - ) { - const phaseValue = `L${phase}`; - meterValue.sampledValue.push( - OCPP16ServiceUtils.buildSampledValue( - (currentPerPhaseSampledValueTemplates[phaseValue] as SampledValueTemplate) ?? - currentSampledValueTemplate, - currentMeasurandValues[phaseValue] as number, - null, - phaseValue as OCPP16MeterValuePhase - ) - ); - const sampledValuesPerPhaseIndex = meterValue.sampledValue.length - 1; - if ( - Utils.convertToFloat(meterValue.sampledValue[sampledValuesPerPhaseIndex].value) > - connectorMaximumAmperage || - debug - ) { - logger.error( - `${chargingStation.logPrefix()} MeterValues measurand ${ - meterValue.sampledValue[sampledValuesPerPhaseIndex].measurand ?? - OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER - }: phase ${ - meterValue.sampledValue[sampledValuesPerPhaseIndex].phase - }, connectorId ${connectorId}, transaction ${connector.transactionId}, value: ${ - meterValue.sampledValue[sampledValuesPerPhaseIndex].value - }/${connectorMaximumAmperage}` - ); - } - } - } - // Energy.Active.Import.Register measurand (default) - const energySampledValueTemplate = OCPP16ServiceUtils.getSampledValueTemplate( - chargingStation, - connectorId - ); - if (energySampledValueTemplate) { - OCPP16ServiceUtils.checkMeasurandPowerDivider( - chargingStation, - energySampledValueTemplate.measurand - ); - const unitDivider = - energySampledValueTemplate?.unit === MeterValueUnit.KILO_WATT_HOUR ? 1000 : 1; - const connectorMaximumAvailablePower = - chargingStation.getConnectorMaximumAvailablePower(connectorId); - const connectorMaximumEnergyRounded = Utils.roundTo( - (connectorMaximumAvailablePower * interval) / (3600 * 1000), - 2 - ); - const energyValueRounded = energySampledValueTemplate.value - ? // Cumulate the fluctuated value around the static one - Utils.getRandomFloatFluctuatedRounded( - OCPP16ServiceUtils.getLimitFromSampledValueTemplateCustomValue( - energySampledValueTemplate.value, - connectorMaximumEnergyRounded, - { - limitationEnabled: chargingStation.getCustomValueLimitationMeterValues(), - unitMultiplier: unitDivider, - } - ), - energySampledValueTemplate.fluctuationPercent ?? Constants.DEFAULT_FLUCTUATION_PERCENT - ) - : Utils.getRandomFloatRounded(connectorMaximumEnergyRounded); - // 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; - } - meterValue.sampledValue.push( - OCPP16ServiceUtils.buildSampledValue( - energySampledValueTemplate, - Utils.roundTo( - chargingStation.getEnergyActiveImportRegisterByTransactionId(transactionId) / - unitDivider, - 2 - ) - ) - ); - const sampledValuesIndex = meterValue.sampledValue.length - 1; - if (energyValueRounded > connectorMaximumEnergyRounded || 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` - ); - } - } - return meterValue; - } - public static buildTransactionBeginMeterValue( chargingStation: ChargingStation, connectorId: number, - meterStart: number - ): OCPP16MeterValue { - const meterValue: OCPP16MeterValue = { - timestamp: new Date().toISOString(), - sampledValue: [], - }; - // Energy.Active.Import.Register measurand (default) - const sampledValueTemplate = OCPP16ServiceUtils.getSampledValueTemplate( - chargingStation, - 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 - ) - ); - return meterValue; - } - - public static buildTransactionEndMeterValue( - chargingStation: ChargingStation, - connectorId: number, - meterStop: number + meterStart: number, ): OCPP16MeterValue { const meterValue: OCPP16MeterValue = { - timestamp: new Date().toISOString(), + timestamp: new Date(), sampledValue: [], }; // Energy.Active.Import.Register measurand (default) const sampledValueTemplate = OCPP16ServiceUtils.getSampledValueTemplate( chargingStation, - connectorId + connectorId, ); - const unitDivider = sampledValueTemplate?.unit === MeterValueUnit.KILO_WATT_HOUR ? 1000 : 1; + const unitDivider = + sampledValueTemplate?.unit === OCPP16MeterValueUnit.KILO_WATT_HOUR ? 1000 : 1; meterValue.sampledValue.push( OCPP16ServiceUtils.buildSampledValue( - sampledValueTemplate, - Utils.roundTo(meterStop / unitDivider, 4), - MeterValueContext.TRANSACTION_END - ) + sampledValueTemplate!, + roundTo((meterStart ?? 0) / unitDivider, 4), + OCPP16MeterValueContext.TRANSACTION_BEGIN, + ), ); return meterValue; } public static buildTransactionDataMeterValues( transactionBeginMeterValue: OCPP16MeterValue, - transactionEndMeterValue: OCPP16MeterValue + transactionEndMeterValue: OCPP16MeterValue, ): OCPP16MeterValue[] { const meterValues: OCPP16MeterValue[] = []; meterValues.push(transactionBeginMeterValue); @@ -744,195 +93,433 @@ 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: ChargingProfile + cp: OCPP16ChargingProfile, ): void { - if (Utils.isNullOrUndefined(chargingStation.getConnectorStatus(connectorId).chargingProfiles)) { + if (isNullOrUndefined(chargingStation.getConnectorStatus(connectorId)?.chargingProfiles)) { logger.error( - `${chargingStation.logPrefix()} Trying to set a charging profile on connectorId ${connectorId} with an uninitialized charging profiles array attribute, applying deferred initialization` + `${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 = []; + chargingStation.getConnectorStatus(connectorId)!.chargingProfiles = []; } - if (Array.isArray(chargingStation.getConnectorStatus(connectorId).chargingProfiles) === false) { + if ( + Array.isArray(chargingStation.getConnectorStatus(connectorId)?.chargingProfiles) === false + ) { logger.error( - `${chargingStation.logPrefix()} Trying to set a charging profile on connectorId ${connectorId} with an improper attribute type for the charging profiles array, applying proper type initialization` + `${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 = []; + chargingStation.getConnectorStatus(connectorId)!.chargingProfiles = []; } let cpReplaced = false; - if (!Utils.isEmptyArray(chargingStation.getConnectorStatus(connectorId).chargingProfiles)) { + if (isNotEmptyArray(chargingStation.getConnectorStatus(connectorId)?.chargingProfiles)) { chargingStation .getConnectorStatus(connectorId) - .chargingProfiles?.forEach((chargingProfile: ChargingProfile, index: number) => { + ?.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; + chargingStation.getConnectorStatus(connectorId)!.chargingProfiles![index] = cp; cpReplaced = true; } }); } - !cpReplaced && chargingStation.getConnectorStatus(connectorId).chargingProfiles?.push(cp); + !cpReplaced && chargingStation.getConnectorStatus(connectorId)?.chargingProfiles?.push(cp); } - private static getSampledValueTemplate( + public static clearChargingProfiles = ( chargingStation: ChargingStation, - connectorId: number, - measurand: MeterValueMeasurand = MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER, - phase?: MeterValuePhase - ): SampledValueTemplate | undefined { - const onPhaseStr = phase ? `on phase ${phase} ` : ''; - if (Constants.SUPPORTED_MEASURANDS.includes(measurand) === false) { - logger.warn( - `${chargingStation.logPrefix()} Trying to get unsupported MeterValues measurand '${measurand}' ${onPhaseStr}in template on connectorId ${connectorId}` - ); - return; + commandPayload: OCPP16ClearChargingProfileRequest, + 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; + } + }); } - if ( - measurand !== MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER && - !ChargingStationConfigurationUtils.getConfigurationKey( - chargingStation, - StandardParametersKey.MeterValuesSampledData - )?.value.includes(measurand) - ) { - logger.debug( - `${chargingStation.logPrefix()} Trying to get MeterValues measurand '${measurand}' ${onPhaseStr}in template on connectorId ${connectorId} not found in '${ - StandardParametersKey.MeterValuesSampledData - }' OCPP parameter` - ); - return; + return clearedCP; + }; + + public static composeChargingSchedules = ( + chargingScheduleHigher: OCPP16ChargingSchedule | undefined, + chargingScheduleLower: OCPP16ChargingSchedule | undefined, + compositeInterval: Interval, + ): OCPP16ChargingSchedule | undefined => { + if (!chargingScheduleHigher && !chargingScheduleLower) { + return undefined; } - const sampledValueTemplates: SampledValueTemplate[] = - chargingStation.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 - ) === false - ) { - logger.warn( - `${chargingStation.logPrefix()} Unsupported MeterValues measurand '${measurand}' ${onPhaseStr}in template on connectorId ${connectorId}` - ); - } else if ( - phase && - sampledValueTemplates[index]?.phase === phase && - sampledValueTemplates[index]?.measurand === measurand && - ChargingStationConfigurationUtils.getConfigurationKey( - chargingStation, - StandardParametersKey.MeterValuesSampledData - )?.value.includes(measurand) === true - ) { - return sampledValueTemplates[index]; - } else if ( - !phase && - !sampledValueTemplates[index].phase && - sampledValueTemplates[index]?.measurand === measurand && - ChargingStationConfigurationUtils.getConfigurationKey( - chargingStation, - StandardParametersKey.MeterValuesSampledData - )?.value.includes(measurand) === true - ) { - return sampledValueTemplates[index]; - } else if ( - measurand === MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER && - (!sampledValueTemplates[index].measurand || - sampledValueTemplates[index].measurand === measurand) - ) { - return sampledValueTemplates[index]; - } + if (chargingScheduleHigher && !chargingScheduleLower) { + return OCPP16ServiceUtils.composeChargingSchedule(chargingScheduleHigher, compositeInterval); } - if (measurand === MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER) { - const errorMsg = `Missing MeterValues for default measurand '${measurand}' in template on connectorId ${connectorId}`; - logger.error(`${chargingStation.logPrefix()} ${errorMsg}`); - throw new BaseError(errorMsg); + if (!chargingScheduleHigher && chargingScheduleLower) { + return OCPP16ServiceUtils.composeChargingSchedule(chargingScheduleLower, compositeInterval); } - logger.debug( - `${chargingStation.logPrefix()} No MeterValues for measurand '${measurand}' ${onPhaseStr}in template on connectorId ${connectorId}` + 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, ); - } - - private static buildSampledValue( - sampledValueTemplate: SampledValueTemplate, - value: number, - context?: MeterValueContext, - phase?: OCPP16MeterValuePhase - ): OCPP16SampledValue { - const sampledValueValue = value ?? sampledValueTemplate?.value ?? null; - const sampledValueContext = context ?? sampledValueTemplate?.context ?? null; - const sampledValueLocation = - sampledValueTemplate?.location ?? - OCPP16ServiceUtils.getMeasurandDefaultLocation(sampledValueTemplate?.measurand ?? null); - const sampledValuePhase = phase ?? sampledValueTemplate?.phase ?? null; + 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 { - ...(!Utils.isNullOrUndefined(sampledValueTemplate.unit) && { - unit: sampledValueTemplate.unit, - }), - ...(!Utils.isNullOrUndefined(sampledValueContext) && { context: sampledValueContext }), - ...(!Utils.isNullOrUndefined(sampledValueTemplate.measurand) && { - measurand: sampledValueTemplate.measurand, - }), - ...(!Utils.isNullOrUndefined(sampledValueLocation) && { location: sampledValueLocation }), - ...(!Utils.isNullOrUndefined(sampledValueValue) && { value: sampledValueValue.toString() }), - ...(!Utils.isNullOrUndefined(sampledValuePhase) && { phase: sampledValuePhase }), + ...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), }; - } + }; - private static checkMeasurandPowerDivider( + public static hasReservation = ( chargingStation: ChargingStation, - measurandType: OCPP16MeterValueMeasurand - ): void { - if (Utils.isUndefined(chargingStation.powerDivider)) { - const errMsg = `MeterValues measurand ${ - measurandType ?? OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER - }: powerDivider is undefined`; - logger.error(`${chargingStation.logPrefix()} ${errMsg}`); - throw new OCPPError(ErrorType.INTERNAL_ERROR, errMsg, OCPP16RequestCommand.METER_VALUES); - } else if (chargingStation?.powerDivider <= 0) { - const errMsg = `MeterValues measurand ${ - measurandType ?? OCPP16MeterValueMeasurand.ENERGY_ACTIVE_IMPORT_REGISTER - }: powerDivider have zero or below value ${chargingStation.powerDivider}`; - logger.error(`${chargingStation.logPrefix()} ${errMsg}`); - throw new OCPPError(ErrorType.INTERNAL_ERROR, errMsg, OCPP16RequestCommand.METER_VALUES); + 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; + }; - private static getMeasurandDefaultLocation( - measurandType: OCPP16MeterValueMeasurand - ): MeterValueLocation | undefined { - switch (measurandType) { - case OCPP16MeterValueMeasurand.STATE_OF_CHARGE: - return MeterValueLocation.EV; - } + public static parseJsonSchemaFile( + relativePath: string, + moduleName?: string, + methodName?: string, + ): JSONSchemaType { + return super.parseJsonSchemaFile( + relativePath, + OCPPVersion.VERSION_16, + moduleName, + methodName, + ); } - 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 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; } - } + }; }