@enyo-energy/energy-app-sdk 0.0.34

package/dist/implementations/ocpp/ocpp-common.js

@@ -0,0 +1,328 @@
+export const MESSAGE_TYPE = {
+    CALL: 2,
+    CALLRESULT: 3,
+    CALLERROR: 4,
+};
+export var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode["NotImplemented"] = "NotImplemented";
+    ErrorCode["NotSupported"] = "NotSupported";
+    ErrorCode["InternalError"] = "InternalError";
+    ErrorCode["ProtocolError"] = "ProtocolError";
+    ErrorCode["SecurityError"] = "SecurityError";
+    ErrorCode["FormationViolation"] = "FormationViolation";
+    ErrorCode["PropertyConstraintViolation"] = "PropertyConstraintViolation";
+    ErrorCode["OccurenceConstraintViolation"] = "OccurenceConstraintViolation";
+    ErrorCode["TypeConstraintViolation"] = "TypeConstraintViolation";
+    ErrorCode["GenericError"] = "GenericError";
+})(ErrorCode || (ErrorCode = {}));
+export var GenericChargePointStatus;
+(function (GenericChargePointStatus) {
+    GenericChargePointStatus["Available"] = "Available";
+    GenericChargePointStatus["Occupied"] = "Occupied";
+    GenericChargePointStatus["Suspended"] = "Suspended";
+    GenericChargePointStatus["Finishing"] = "Finishing";
+    GenericChargePointStatus["Reserved"] = "Reserved";
+    GenericChargePointStatus["Unavailable"] = "Unavailable";
+    GenericChargePointStatus["Faulted"] = "Faulted";
+})(GenericChargePointStatus || (GenericChargePointStatus = {}));
+import { ChargePointStatus } from './ocpp16.js';
+import { ConnectorStatusEnumType } from './ocpp201.js';
+export function mapOCCP16StatusToGeneric(status) {
+    switch (status) {
+        case ChargePointStatus.Available:
+            return GenericChargePointStatus.Available;
+        case ChargePointStatus.Preparing:
+        case ChargePointStatus.Charging:
+            return GenericChargePointStatus.Occupied;
+        case ChargePointStatus.SuspendedEVSE:
+        case ChargePointStatus.SuspendedEV:
+            return GenericChargePointStatus.Suspended;
+        case ChargePointStatus.Finishing:
+            return GenericChargePointStatus.Finishing;
+        case ChargePointStatus.Reserved:
+            return GenericChargePointStatus.Reserved;
+        case ChargePointStatus.Unavailable:
+            return GenericChargePointStatus.Unavailable;
+        case ChargePointStatus.Faulted:
+            return GenericChargePointStatus.Faulted;
+        default:
+            return GenericChargePointStatus.Unavailable;
+    }
+}
+export function mapOCCP201StatusToGeneric(connectorStatus, chargingState) {
+    if (connectorStatus === ConnectorStatusEnumType.Available) {
+        return GenericChargePointStatus.Available;
+    }
+    if (connectorStatus === ConnectorStatusEnumType.Reserved) {
+        return GenericChargePointStatus.Reserved;
+    }
+    if (connectorStatus === ConnectorStatusEnumType.Unavailable) {
+        return GenericChargePointStatus.Unavailable;
+    }
+    if (connectorStatus === ConnectorStatusEnumType.Faulted) {
+        return GenericChargePointStatus.Faulted;
+    }
+    if (connectorStatus === ConnectorStatusEnumType.Occupied) {
+        if (chargingState === 'SuspendedEV' || chargingState === 'SuspendedEVSE') {
+            return GenericChargePointStatus.Suspended;
+        }
+        if (chargingState === 'Charging' || chargingState === 'EVConnected') {
+            return GenericChargePointStatus.Occupied;
+        }
+        if (chargingState === 'Idle') {
+            return GenericChargePointStatus.Finishing;
+        }
+        return GenericChargePointStatus.Occupied;
+    }
+    return GenericChargePointStatus.Unavailable;
+}
+export function mapGenericToOCCP16Status(status) {
+    switch (status) {
+        case GenericChargePointStatus.Available:
+            return ChargePointStatus.Available;
+        case GenericChargePointStatus.Occupied:
+            return ChargePointStatus.Charging;
+        case GenericChargePointStatus.Suspended:
+            return ChargePointStatus.SuspendedEVSE;
+        case GenericChargePointStatus.Finishing:
+            return ChargePointStatus.Finishing;
+        case GenericChargePointStatus.Reserved:
+            return ChargePointStatus.Reserved;
+        case GenericChargePointStatus.Unavailable:
+            return ChargePointStatus.Unavailable;
+        case GenericChargePointStatus.Faulted:
+            return ChargePointStatus.Faulted;
+        default:
+            return ChargePointStatus.Unavailable;
+    }
+}
+export function mapGenericToOCCP201Status(status) {
+    switch (status) {
+        case GenericChargePointStatus.Available:
+            return ConnectorStatusEnumType.Available;
+        case GenericChargePointStatus.Occupied:
+        case GenericChargePointStatus.Suspended:
+        case GenericChargePointStatus.Finishing:
+            return ConnectorStatusEnumType.Occupied;
+        case GenericChargePointStatus.Reserved:
+            return ConnectorStatusEnumType.Reserved;
+        case GenericChargePointStatus.Unavailable:
+            return ConnectorStatusEnumType.Unavailable;
+        case GenericChargePointStatus.Faulted:
+            return ConnectorStatusEnumType.Faulted;
+        default:
+            return ConnectorStatusEnumType.Unavailable;
+    }
+}
+export function mapOCPP16MeterValueToGeneric(sampledValues) {
+    const currentMeterValueInWattHours = getOCPP16MeterValueByMeasurand(sampledValues, 'Energy.Active.Import.Register');
+    const powerActiveImport = getOCPP16MeterValueByMeasurand(sampledValues, 'Power.Active.Import');
+    const evSoC = getOCPP16MeterValueByMeasurand(sampledValues, 'SoC');
+    const outletVoltage = getOCPP16OutletVoltage(sampledValues);
+    const outletCurrent = getOCPP16OutletCurrent(sampledValues);
+    return {
+        context: mapOCPP16MeterValueContext(sampledValues),
+        currentMeterValueInWattHours: convertToWattHours(currentMeterValueInWattHours),
+        powerImportByEvInWatt: convertToWatt(powerActiveImport),
+        evStateOfChargeInPercent: convertToPercent(evSoC),
+        outletVoltagePhase1: convertToVoltage(outletVoltage.phase1),
+        outletVoltagePhase2: convertToVoltage(outletVoltage.phase2),
+        outletVoltagePhase3: convertToVoltage(outletVoltage.phase3),
+        outletCurrentPhase1: convertToAmpere(outletCurrent.phase1),
+        outletCurrentPhase2: convertToAmpere(outletCurrent.phase2),
+        outletCurrentPhase3: convertToAmpere(outletCurrent.phase3),
+    };
+}
+function mapOCPP16MeterValueContext(sampledValues) {
+    const valuesWithContext = sampledValues.filter(s => s.context !== undefined);
+    if (valuesWithContext.length > 0) {
+        switch (valuesWithContext[0].context) {
+            case 'Transaction.Begin':
+                return 'Transaction.Begin';
+            case "Transaction.End":
+                return 'Transaction.End';
+            case "Sample.Clock":
+                return 'Sample.Clock';
+            case "Interruption.Begin":
+                return 'Interruption.Begin';
+            case "Interruption.End":
+                return 'Interruption.End';
+            case "Sample.Periodic":
+                return 'Sample.Periodic';
+            case "Trigger":
+                return 'Trigger';
+            default:
+                return undefined;
+        }
+    }
+    return undefined;
+}
+function getOCPP16MeterValueByMeasurand(sampledValues, measurand, phase) {
+    try {
+        const meterValue = sampledValues.find((sampledValue) => sampledValue.measurand === measurand &&
+            (!phase || sampledValue.phase === phase));
+        if (!meterValue) {
+            return undefined;
+        }
+        return {
+            unit: meterValue.unit,
+            value: Number.parseFloat(meterValue.value),
+            context: meterValue.context,
+        };
+    }
+    catch (_) {
+        return undefined;
+    }
+}
+function getOCPP16OutletCurrent(sampledValues) {
+    const phase1 = getOCPP16MeterValueByMeasurand(sampledValues, 'Current.Import', 'L1');
+    const phase2 = getOCPP16MeterValueByMeasurand(sampledValues, 'Current.Import', 'L2');
+    const phase3 = getOCPP16MeterValueByMeasurand(sampledValues, 'Current.Import', 'L3');
+    return {
+        phase1,
+        phase2,
+        phase3,
+    };
+}
+function getOCPP16OutletVoltage(sampledValues) {
+    const phase1 = getOCPP16MeterValueByMeasurand(sampledValues, 'Voltage', 'L1');
+    const phase2 = getOCPP16MeterValueByMeasurand(sampledValues, 'Voltage', 'L2');
+    const phase3 = getOCPP16MeterValueByMeasurand(sampledValues, 'Voltage', 'L3');
+    return {
+        phase1,
+        phase2,
+        phase3,
+    };
+}
+function convertToWattHours(instance) {
+    if (!instance) {
+        return 0;
+    }
+    if (instance.unit === 'Wh') {
+        return instance.value;
+    }
+    if (instance.unit === 'kWh') {
+        return instance.value * 1000;
+    }
+    throw new Error(`Cannot convert ${instance.value} ${instance.unit} into Wh`);
+}
+function convertToWatt(instance) {
+    if (!instance) {
+        return 0;
+    }
+    if (instance.unit === 'W') {
+        return instance.value;
+    }
+    if (instance.unit === 'kW') {
+        return instance.value * 1000;
+    }
+    throw new Error(`Cannot convert ${instance.value} ${instance.unit} into W`);
+}
+function convertToPercent(instance) {
+    if (!instance) {
+        return 0;
+    }
+    if (instance.unit === 'Percent') {
+        return instance.value;
+    }
+    throw new Error(`Cannot convert ${instance.value} ${instance.unit} into Percent`);
+}
+function convertToVoltage(instance) {
+    if (!instance) {
+        return 0;
+    }
+    if (instance.unit === 'V') {
+        return instance.value;
+    }
+    throw new Error(`Cannot convert ${instance.value} ${instance.unit} into V`);
+}
+function convertToAmpere(instance) {
+    if (!instance) {
+        return 0;
+    }
+    if (instance.unit === 'A') {
+        return instance.value;
+    }
+    throw new Error(`Cannot convert ${instance.value} ${instance.unit} into A`);
+}
+// OCPP 2.0.1 meter value mapping functions
+export function mapOCPP201MeterValueToGeneric(sampledValues) {
+    const currentMeterValueInWattHours = getOCPP201MeterValueByMeasurand(sampledValues, 'Energy.Active.Import');
+    const powerActiveImport = getOCPP201MeterValueByMeasurand(sampledValues, 'Power.Active.Import');
+    const evSoC = getOCPP201MeterValueByMeasurand(sampledValues, 'SoC');
+    const outletVoltage = getOCPP201OutletVoltage(sampledValues);
+    const outletCurrent = getOCPP201OutletCurrent(sampledValues);
+    return {
+        context: mapOCPP201MeterValueContext(sampledValues),
+        currentMeterValueInWattHours: convertToWattHours(currentMeterValueInWattHours),
+        powerImportByEvInWatt: convertToWatt(powerActiveImport),
+        evStateOfChargeInPercent: convertToPercent(evSoC),
+        outletVoltagePhase1: convertToVoltage(outletVoltage.phase1),
+        outletVoltagePhase2: convertToVoltage(outletVoltage.phase2),
+        outletVoltagePhase3: convertToVoltage(outletVoltage.phase3),
+        outletCurrentPhase1: convertToAmpere(outletCurrent.phase1),
+        outletCurrentPhase2: convertToAmpere(outletCurrent.phase2),
+        outletCurrentPhase3: convertToAmpere(outletCurrent.phase3),
+    };
+}
+function mapOCPP201MeterValueContext(sampledValues) {
+    const valuesWithContext = sampledValues.filter(s => s.context !== undefined);
+    if (valuesWithContext.length > 0) {
+        switch (valuesWithContext[0].context) {
+            case 'Transaction.Begin':
+                return 'Transaction.Begin';
+            case "Transaction.End":
+                return 'Transaction.End';
+            case "Sample.Clock":
+                return 'Sample.Clock';
+            case "Interruption.Begin":
+                return 'Interruption.Begin';
+            case "Interruption.End":
+                return 'Interruption.End';
+            case "Sample.Periodic":
+                return 'Sample.Periodic';
+            case "Trigger":
+                return 'Trigger';
+            default:
+                return undefined;
+        }
+    }
+    return undefined;
+}
+function getOCPP201MeterValueByMeasurand(sampledValues, measurand, phase) {
+    try {
+        const meterValue = sampledValues.find((sampledValue) => sampledValue.measurand === measurand &&
+            (!phase || sampledValue.phase === phase));
+        if (!meterValue) {
+            return undefined;
+        }
+        return {
+            unit: meterValue.unitOfMeasure?.unit,
+            value: meterValue.value,
+        };
+    }
+    catch (_) {
+        return undefined;
+    }
+}
+function getOCPP201OutletCurrent(sampledValues) {
+    const phase1 = getOCPP201MeterValueByMeasurand(sampledValues, 'Current.Import', 'L1');
+    const phase2 = getOCPP201MeterValueByMeasurand(sampledValues, 'Current.Import', 'L2');
+    const phase3 = getOCPP201MeterValueByMeasurand(sampledValues, 'Current.Import', 'L3');
+    return {
+        phase1,
+        phase2,
+        phase3,
+    };
+}
+function getOCPP201OutletVoltage(sampledValues) {
+    const phase1 = getOCPP201MeterValueByMeasurand(sampledValues, 'Voltage', 'L1');
+    const phase2 = getOCPP201MeterValueByMeasurand(sampledValues, 'Voltage', 'L2');
+    const phase3 = getOCPP201MeterValueByMeasurand(sampledValues, 'Voltage', 'L3');
+    return {
+        phase1,
+        phase2,
+        phase3,
+    };
+}

package/dist/implementations/ocpp/ocpp16.d.ts

@@ -0,0 +1,137 @@
+export declare enum OCPP16Action {
+    Authorize = "Authorize",
+    BootNotification = "BootNotification",
+    CancelReservation = "CancelReservation",
+    ChangeAvailability = "ChangeAvailability",
+    ChangeConfiguration = "ChangeConfiguration",
+    ClearCache = "ClearCache",
+    ClearChargingProfile = "ClearChargingProfile",
+    DataTransfer = "DataTransfer",
+    DiagnosticsStatusNotification = "DiagnosticsStatusNotification",
+    FirmwareStatusNotification = "FirmwareStatusNotification",
+    GetConfiguration = "GetConfiguration",
+    GetDiagnostics = "GetDiagnostics",
+    GetLocalListVersion = "GetLocalListVersion",
+    Heartbeat = "Heartbeat",
+    MeterValues = "MeterValues",
+    RemoteStartTransaction = "RemoteStartTransaction",
+    RemoteStopTransaction = "RemoteStopTransaction",
+    ReserveNow = "ReserveNow",
+    Reset = "Reset",
+    SendLocalList = "SendLocalList",
+    SetChargingProfile = "SetChargingProfile",
+    StartTransaction = "StartTransaction",
+    StatusNotification = "StatusNotification",
+    StopTransaction = "StopTransaction",
+    TriggerMessage = "TriggerMessage",
+    UnlockConnector = "UnlockConnector",
+    UpdateFirmware = "UpdateFirmware"
+}
+export declare enum RegistrationStatus {
+    Accepted = "Accepted",
+    Pending = "Pending",
+    Rejected = "Rejected"
+}
+export declare enum ChargePointStatus {
+    Available = "Available",
+    Preparing = "Preparing",
+    Charging = "Charging",
+    SuspendedEVSE = "SuspendedEVSE",
+    SuspendedEV = "SuspendedEV",
+    Finishing = "Finishing",
+    Reserved = "Reserved",
+    Unavailable = "Unavailable",
+    Faulted = "Faulted"
+}
+export interface OCPP16BootNotificationRequest {
+    chargePointVendor: string;
+    chargePointModel: string;
+    chargePointSerialNumber?: string;
+    chargeBoxSerialNumber?: string;
+    firmwareVersion?: string;
+    iccid?: string;
+    imsi?: string;
+    meterSerialNumber?: string;
+    meterType?: string;
+}
+export interface OCPP16BootNotificationResponse {
+    status: RegistrationStatus;
+    currentTime: string;
+    interval: number;
+}
+export interface OCPP16HeartbeatRequest {
+}
+export interface OCPP16HeartbeatResponse {
+    currentTime: string;
+}
+export interface OCPP16StatusNotificationRequest {
+    connectorId: number;
+    status: ChargePointStatus;
+    errorCode: string;
+    info?: string;
+    timestamp?: string;
+    vendorId?: string;
+    vendorErrorCode?: string;
+}
+export interface OCPP16StatusNotificationResponse {
+}
+export interface OCPP16AuthorizeRequest {
+    idTag: string;
+}
+export interface OCPP16AuthorizeResponse {
+    idTagInfo: {
+        status: 'Accepted' | 'Blocked' | 'Expired' | 'Invalid' | 'ConcurrentTx';
+        expiryDate?: string;
+        parentIdTag?: string;
+    };
+}
+export interface OCPP16StartTransactionRequest {
+    connectorId: number;
+    idTag: string;
+    meterStart: number;
+    timestamp: string;
+    reservationId?: number;
+}
+export interface OCPP16StartTransactionResponse {
+    transactionId: number;
+    idTagInfo: {
+        status: 'Accepted' | 'Blocked' | 'Expired' | 'Invalid' | 'ConcurrentTx';
+        expiryDate?: string;
+        parentIdTag?: string;
+    };
+}
+export interface OCPP16StopTransactionRequest {
+    transactionId: number;
+    timestamp: string;
+    meterStop: number;
+    idTag?: string;
+    reason?: string;
+    transactionData?: any[];
+}
+export interface OCPP16StopTransactionResponse {
+    idTagInfo?: {
+        status: 'Accepted' | 'Blocked' | 'Expired' | 'Invalid' | 'ConcurrentTx';
+        expiryDate?: string;
+        parentIdTag?: string;
+    };
+}
+export type OCPP16MeterValueContext = 'Interruption.Begin' | 'Interruption.End' | 'Sample.Clock' | 'Sample.Periodic' | 'Transaction.Begin' | 'Transaction.End' | 'Trigger';
+export type OCPP16MeterValueMeasurand = 'Voltage' | 'Current.Import' | 'Power.Active.Import' | 'SoC' | 'Power.Offered' | 'Energy.Active.Import.Register';
+export interface OCPP16MeterValueSampledValue {
+    value: string;
+    format?: 'SignedData' | 'Raw';
+    measurand: OCPP16MeterValueMeasurand;
+    context?: OCPP16MeterValueContext;
+    location?: 'Outlet' | 'EV';
+    unit: 'V' | 'A' | 'W' | 'Percent' | 'Wh';
+    phase?: 'L1' | 'L2' | 'L3';
+}
+export interface OCPP16MeterValue {
+    timestamp: string;
+    sampledValue: OCPP16MeterValueSampledValue[];
+}
+export interface OCPP16MeterValuesMessage {
+    connectorId: number;
+    transactionId: number;
+    meterValue: OCPP16MeterValue[];
+}

package/dist/implementations/ocpp/ocpp16.js

@@ -0,0 +1,48 @@
+export var OCPP16Action;
+(function (OCPP16Action) {
+    OCPP16Action["Authorize"] = "Authorize";
+    OCPP16Action["BootNotification"] = "BootNotification";
+    OCPP16Action["CancelReservation"] = "CancelReservation";
+    OCPP16Action["ChangeAvailability"] = "ChangeAvailability";
+    OCPP16Action["ChangeConfiguration"] = "ChangeConfiguration";
+    OCPP16Action["ClearCache"] = "ClearCache";
+    OCPP16Action["ClearChargingProfile"] = "ClearChargingProfile";
+    OCPP16Action["DataTransfer"] = "DataTransfer";
+    OCPP16Action["DiagnosticsStatusNotification"] = "DiagnosticsStatusNotification";
+    OCPP16Action["FirmwareStatusNotification"] = "FirmwareStatusNotification";
+    OCPP16Action["GetConfiguration"] = "GetConfiguration";
+    OCPP16Action["GetDiagnostics"] = "GetDiagnostics";
+    OCPP16Action["GetLocalListVersion"] = "GetLocalListVersion";
+    OCPP16Action["Heartbeat"] = "Heartbeat";
+    OCPP16Action["MeterValues"] = "MeterValues";
+    OCPP16Action["RemoteStartTransaction"] = "RemoteStartTransaction";
+    OCPP16Action["RemoteStopTransaction"] = "RemoteStopTransaction";
+    OCPP16Action["ReserveNow"] = "ReserveNow";
+    OCPP16Action["Reset"] = "Reset";
+    OCPP16Action["SendLocalList"] = "SendLocalList";
+    OCPP16Action["SetChargingProfile"] = "SetChargingProfile";
+    OCPP16Action["StartTransaction"] = "StartTransaction";
+    OCPP16Action["StatusNotification"] = "StatusNotification";
+    OCPP16Action["StopTransaction"] = "StopTransaction";
+    OCPP16Action["TriggerMessage"] = "TriggerMessage";
+    OCPP16Action["UnlockConnector"] = "UnlockConnector";
+    OCPP16Action["UpdateFirmware"] = "UpdateFirmware";
+})(OCPP16Action || (OCPP16Action = {}));
+export var RegistrationStatus;
+(function (RegistrationStatus) {
+    RegistrationStatus["Accepted"] = "Accepted";
+    RegistrationStatus["Pending"] = "Pending";
+    RegistrationStatus["Rejected"] = "Rejected";
+})(RegistrationStatus || (RegistrationStatus = {}));
+export var ChargePointStatus;
+(function (ChargePointStatus) {
+    ChargePointStatus["Available"] = "Available";
+    ChargePointStatus["Preparing"] = "Preparing";
+    ChargePointStatus["Charging"] = "Charging";
+    ChargePointStatus["SuspendedEVSE"] = "SuspendedEVSE";
+    ChargePointStatus["SuspendedEV"] = "SuspendedEV";
+    ChargePointStatus["Finishing"] = "Finishing";
+    ChargePointStatus["Reserved"] = "Reserved";
+    ChargePointStatus["Unavailable"] = "Unavailable";
+    ChargePointStatus["Faulted"] = "Faulted";
+})(ChargePointStatus || (ChargePointStatus = {}));