1040 lines
27 KiB
TypeScript
1040 lines
27 KiB
TypeScript
/* eslint-disable */
|
|
import Long from "long";
|
|
import _m0 from "protobufjs/minimal";
|
|
|
|
export const protobufPackage = "";
|
|
|
|
export enum Warnings {
|
|
NoWarning = 0,
|
|
TaM1_Bit1 = 1,
|
|
TbM1_Bit4 = 4,
|
|
VBm1_Bit6 = 6,
|
|
VBM1_Bit8 = 8,
|
|
IDM1_Bit10 = 10,
|
|
vsM1_Bit24 = 24,
|
|
iCM1_Bit26 = 26,
|
|
iDM1_Bit28 = 28,
|
|
MID1_Bit30 = 30,
|
|
BLPW_Bit32 = 32,
|
|
Ah_W_Bit35 = 35,
|
|
MPMM_Bit38 = 38,
|
|
TCMM_Bit39 = 39,
|
|
TCdi_Bit40 = 40,
|
|
WMTO_Bit41 = 41,
|
|
CELL1_Bit46 = 46,
|
|
UNRECOGNIZED = -1,
|
|
}
|
|
|
|
export function warningsFromJSON(object: any): Warnings {
|
|
switch (object) {
|
|
case 0:
|
|
case "NoWarning":
|
|
return Warnings.NoWarning;
|
|
case 1:
|
|
case "TaM1_Bit1":
|
|
return Warnings.TaM1_Bit1;
|
|
case 4:
|
|
case "TbM1_Bit4":
|
|
return Warnings.TbM1_Bit4;
|
|
case 6:
|
|
case "VBm1_Bit6":
|
|
return Warnings.VBm1_Bit6;
|
|
case 8:
|
|
case "VBM1_Bit8":
|
|
return Warnings.VBM1_Bit8;
|
|
case 10:
|
|
case "IDM1_Bit10":
|
|
return Warnings.IDM1_Bit10;
|
|
case 24:
|
|
case "vsM1_Bit24":
|
|
return Warnings.vsM1_Bit24;
|
|
case 26:
|
|
case "iCM1_Bit26":
|
|
return Warnings.iCM1_Bit26;
|
|
case 28:
|
|
case "iDM1_Bit28":
|
|
return Warnings.iDM1_Bit28;
|
|
case 30:
|
|
case "MID1_Bit30":
|
|
return Warnings.MID1_Bit30;
|
|
case 32:
|
|
case "BLPW_Bit32":
|
|
return Warnings.BLPW_Bit32;
|
|
case 35:
|
|
case "Ah_W_Bit35":
|
|
return Warnings.Ah_W_Bit35;
|
|
case 38:
|
|
case "MPMM_Bit38":
|
|
return Warnings.MPMM_Bit38;
|
|
case 39:
|
|
case "TCMM_Bit39":
|
|
return Warnings.TCMM_Bit39;
|
|
case 40:
|
|
case "TCdi_Bit40":
|
|
return Warnings.TCdi_Bit40;
|
|
case 41:
|
|
case "WMTO_Bit41":
|
|
return Warnings.WMTO_Bit41;
|
|
case 46:
|
|
case "CELL1_Bit46":
|
|
return Warnings.CELL1_Bit46;
|
|
case -1:
|
|
case "UNRECOGNIZED":
|
|
default:
|
|
return Warnings.UNRECOGNIZED;
|
|
}
|
|
}
|
|
|
|
export function warningsToJSON(object: Warnings): string {
|
|
switch (object) {
|
|
case Warnings.NoWarning:
|
|
return "NoWarning";
|
|
case Warnings.TaM1_Bit1:
|
|
return "TaM1_Bit1";
|
|
case Warnings.TbM1_Bit4:
|
|
return "TbM1_Bit4";
|
|
case Warnings.VBm1_Bit6:
|
|
return "VBm1_Bit6";
|
|
case Warnings.VBM1_Bit8:
|
|
return "VBM1_Bit8";
|
|
case Warnings.IDM1_Bit10:
|
|
return "IDM1_Bit10";
|
|
case Warnings.vsM1_Bit24:
|
|
return "vsM1_Bit24";
|
|
case Warnings.iCM1_Bit26:
|
|
return "iCM1_Bit26";
|
|
case Warnings.iDM1_Bit28:
|
|
return "iDM1_Bit28";
|
|
case Warnings.MID1_Bit30:
|
|
return "MID1_Bit30";
|
|
case Warnings.BLPW_Bit32:
|
|
return "BLPW_Bit32";
|
|
case Warnings.Ah_W_Bit35:
|
|
return "Ah_W_Bit35";
|
|
case Warnings.MPMM_Bit38:
|
|
return "MPMM_Bit38";
|
|
case Warnings.TCMM_Bit39:
|
|
return "TCMM_Bit39";
|
|
case Warnings.TCdi_Bit40:
|
|
return "TCdi_Bit40";
|
|
case Warnings.WMTO_Bit41:
|
|
return "WMTO_Bit41";
|
|
case Warnings.CELL1_Bit46:
|
|
return "CELL1_Bit46";
|
|
default:
|
|
return "UNKNOWN";
|
|
}
|
|
}
|
|
|
|
export enum Alarms {
|
|
Tam_Bit0 = 0,
|
|
TaM2_Bit2 = 2,
|
|
Tbm_Bit3 = 3,
|
|
TbM2_Bit5 = 5,
|
|
VBm2_Bit7 = 7,
|
|
VBM2_Bit8 = 8,
|
|
IDM2_Bit11 = 11,
|
|
ISOB_Bit12 = 12,
|
|
MSWE_Bit13 = 13,
|
|
FUSE_Bit14 = 14,
|
|
HTRE_Bit15 = 15,
|
|
TCPE_Bit16 = 16,
|
|
STRE_Bit17 = 17,
|
|
CME_Bit18 = 18,
|
|
HWFL_Bit19 = 19,
|
|
HWEM_Bit20 = 20,
|
|
ThM_Bit21 = 21,
|
|
vsm1_Bit22 = 22,
|
|
vsm2_Bit23 = 23,
|
|
vsM2_Bit25 = 25,
|
|
iCM2_Bit27 = 27,
|
|
iDM2_Bit29 = 29,
|
|
MID2_Bit31 = 31,
|
|
CCBF_Bit33 = 33,
|
|
AhFL_Bit34 = 34,
|
|
TbCM_Bit36 = 36,
|
|
BRNF_Bit37 = 37,
|
|
HTFS_Bit42 = 42,
|
|
DATA_Bit43 = 43,
|
|
CELL2_Bit45 = 45,
|
|
Undocumented_Bit44 = 44,
|
|
Undocumented_Bit47 = 47,
|
|
Undocumented_Bit48 = 48,
|
|
Undocumented_Bit49 = 49,
|
|
Undocumented_Bit50 = 50,
|
|
Undocumented_Bit51 = 51,
|
|
Undocumented_Bit52 = 52,
|
|
Undocumented_Bit53 = 53,
|
|
Undocumented_Bit54 = 54,
|
|
Undocumented_Bit55 = 55,
|
|
Undocumented_Bit56 = 56,
|
|
Undocumented_Bit57 = 57,
|
|
Undocumented_Bit58 = 58,
|
|
Undocumented_Bit59 = 59,
|
|
Undocumented_Bit60 = 60,
|
|
Undocumented_Bit61 = 61,
|
|
Undocumented_Bit62 = 62,
|
|
Undocumented_Bit63 = 63,
|
|
UNRECOGNIZED = -1,
|
|
}
|
|
|
|
export function alarmsFromJSON(object: any): Alarms {
|
|
switch (object) {
|
|
case 0:
|
|
case "Tam_Bit0":
|
|
return Alarms.Tam_Bit0;
|
|
case 2:
|
|
case "TaM2_Bit2":
|
|
return Alarms.TaM2_Bit2;
|
|
case 3:
|
|
case "Tbm_Bit3":
|
|
return Alarms.Tbm_Bit3;
|
|
case 5:
|
|
case "TbM2_Bit5":
|
|
return Alarms.TbM2_Bit5;
|
|
case 7:
|
|
case "VBm2_Bit7":
|
|
return Alarms.VBm2_Bit7;
|
|
case 8:
|
|
case "VBM2_Bit8":
|
|
return Alarms.VBM2_Bit8;
|
|
case 11:
|
|
case "IDM2_Bit11":
|
|
return Alarms.IDM2_Bit11;
|
|
case 12:
|
|
case "ISOB_Bit12":
|
|
return Alarms.ISOB_Bit12;
|
|
case 13:
|
|
case "MSWE_Bit13":
|
|
return Alarms.MSWE_Bit13;
|
|
case 14:
|
|
case "FUSE_Bit14":
|
|
return Alarms.FUSE_Bit14;
|
|
case 15:
|
|
case "HTRE_Bit15":
|
|
return Alarms.HTRE_Bit15;
|
|
case 16:
|
|
case "TCPE_Bit16":
|
|
return Alarms.TCPE_Bit16;
|
|
case 17:
|
|
case "STRE_Bit17":
|
|
return Alarms.STRE_Bit17;
|
|
case 18:
|
|
case "CME_Bit18":
|
|
return Alarms.CME_Bit18;
|
|
case 19:
|
|
case "HWFL_Bit19":
|
|
return Alarms.HWFL_Bit19;
|
|
case 20:
|
|
case "HWEM_Bit20":
|
|
return Alarms.HWEM_Bit20;
|
|
case 21:
|
|
case "ThM_Bit21":
|
|
return Alarms.ThM_Bit21;
|
|
case 22:
|
|
case "vsm1_Bit22":
|
|
return Alarms.vsm1_Bit22;
|
|
case 23:
|
|
case "vsm2_Bit23":
|
|
return Alarms.vsm2_Bit23;
|
|
case 25:
|
|
case "vsM2_Bit25":
|
|
return Alarms.vsM2_Bit25;
|
|
case 27:
|
|
case "iCM2_Bit27":
|
|
return Alarms.iCM2_Bit27;
|
|
case 29:
|
|
case "iDM2_Bit29":
|
|
return Alarms.iDM2_Bit29;
|
|
case 31:
|
|
case "MID2_Bit31":
|
|
return Alarms.MID2_Bit31;
|
|
case 33:
|
|
case "CCBF_Bit33":
|
|
return Alarms.CCBF_Bit33;
|
|
case 34:
|
|
case "AhFL_Bit34":
|
|
return Alarms.AhFL_Bit34;
|
|
case 36:
|
|
case "TbCM_Bit36":
|
|
return Alarms.TbCM_Bit36;
|
|
case 37:
|
|
case "BRNF_Bit37":
|
|
return Alarms.BRNF_Bit37;
|
|
case 42:
|
|
case "HTFS_Bit42":
|
|
return Alarms.HTFS_Bit42;
|
|
case 43:
|
|
case "DATA_Bit43":
|
|
return Alarms.DATA_Bit43;
|
|
case 45:
|
|
case "CELL2_Bit45":
|
|
return Alarms.CELL2_Bit45;
|
|
case 44:
|
|
case "Undocumented_Bit44":
|
|
return Alarms.Undocumented_Bit44;
|
|
case 47:
|
|
case "Undocumented_Bit47":
|
|
return Alarms.Undocumented_Bit47;
|
|
case 48:
|
|
case "Undocumented_Bit48":
|
|
return Alarms.Undocumented_Bit48;
|
|
case 49:
|
|
case "Undocumented_Bit49":
|
|
return Alarms.Undocumented_Bit49;
|
|
case 50:
|
|
case "Undocumented_Bit50":
|
|
return Alarms.Undocumented_Bit50;
|
|
case 51:
|
|
case "Undocumented_Bit51":
|
|
return Alarms.Undocumented_Bit51;
|
|
case 52:
|
|
case "Undocumented_Bit52":
|
|
return Alarms.Undocumented_Bit52;
|
|
case 53:
|
|
case "Undocumented_Bit53":
|
|
return Alarms.Undocumented_Bit53;
|
|
case 54:
|
|
case "Undocumented_Bit54":
|
|
return Alarms.Undocumented_Bit54;
|
|
case 55:
|
|
case "Undocumented_Bit55":
|
|
return Alarms.Undocumented_Bit55;
|
|
case 56:
|
|
case "Undocumented_Bit56":
|
|
return Alarms.Undocumented_Bit56;
|
|
case 57:
|
|
case "Undocumented_Bit57":
|
|
return Alarms.Undocumented_Bit57;
|
|
case 58:
|
|
case "Undocumented_Bit58":
|
|
return Alarms.Undocumented_Bit58;
|
|
case 59:
|
|
case "Undocumented_Bit59":
|
|
return Alarms.Undocumented_Bit59;
|
|
case 60:
|
|
case "Undocumented_Bit60":
|
|
return Alarms.Undocumented_Bit60;
|
|
case 61:
|
|
case "Undocumented_Bit61":
|
|
return Alarms.Undocumented_Bit61;
|
|
case 62:
|
|
case "Undocumented_Bit62":
|
|
return Alarms.Undocumented_Bit62;
|
|
case 63:
|
|
case "Undocumented_Bit63":
|
|
return Alarms.Undocumented_Bit63;
|
|
case -1:
|
|
case "UNRECOGNIZED":
|
|
default:
|
|
return Alarms.UNRECOGNIZED;
|
|
}
|
|
}
|
|
|
|
export function alarmsToJSON(object: Alarms): string {
|
|
switch (object) {
|
|
case Alarms.Tam_Bit0:
|
|
return "Tam_Bit0";
|
|
case Alarms.TaM2_Bit2:
|
|
return "TaM2_Bit2";
|
|
case Alarms.Tbm_Bit3:
|
|
return "Tbm_Bit3";
|
|
case Alarms.TbM2_Bit5:
|
|
return "TbM2_Bit5";
|
|
case Alarms.VBm2_Bit7:
|
|
return "VBm2_Bit7";
|
|
case Alarms.VBM2_Bit8:
|
|
return "VBM2_Bit8";
|
|
case Alarms.IDM2_Bit11:
|
|
return "IDM2_Bit11";
|
|
case Alarms.ISOB_Bit12:
|
|
return "ISOB_Bit12";
|
|
case Alarms.MSWE_Bit13:
|
|
return "MSWE_Bit13";
|
|
case Alarms.FUSE_Bit14:
|
|
return "FUSE_Bit14";
|
|
case Alarms.HTRE_Bit15:
|
|
return "HTRE_Bit15";
|
|
case Alarms.TCPE_Bit16:
|
|
return "TCPE_Bit16";
|
|
case Alarms.STRE_Bit17:
|
|
return "STRE_Bit17";
|
|
case Alarms.CME_Bit18:
|
|
return "CME_Bit18";
|
|
case Alarms.HWFL_Bit19:
|
|
return "HWFL_Bit19";
|
|
case Alarms.HWEM_Bit20:
|
|
return "HWEM_Bit20";
|
|
case Alarms.ThM_Bit21:
|
|
return "ThM_Bit21";
|
|
case Alarms.vsm1_Bit22:
|
|
return "vsm1_Bit22";
|
|
case Alarms.vsm2_Bit23:
|
|
return "vsm2_Bit23";
|
|
case Alarms.vsM2_Bit25:
|
|
return "vsM2_Bit25";
|
|
case Alarms.iCM2_Bit27:
|
|
return "iCM2_Bit27";
|
|
case Alarms.iDM2_Bit29:
|
|
return "iDM2_Bit29";
|
|
case Alarms.MID2_Bit31:
|
|
return "MID2_Bit31";
|
|
case Alarms.CCBF_Bit33:
|
|
return "CCBF_Bit33";
|
|
case Alarms.AhFL_Bit34:
|
|
return "AhFL_Bit34";
|
|
case Alarms.TbCM_Bit36:
|
|
return "TbCM_Bit36";
|
|
case Alarms.BRNF_Bit37:
|
|
return "BRNF_Bit37";
|
|
case Alarms.HTFS_Bit42:
|
|
return "HTFS_Bit42";
|
|
case Alarms.DATA_Bit43:
|
|
return "DATA_Bit43";
|
|
case Alarms.CELL2_Bit45:
|
|
return "CELL2_Bit45";
|
|
case Alarms.Undocumented_Bit44:
|
|
return "Undocumented_Bit44";
|
|
case Alarms.Undocumented_Bit47:
|
|
return "Undocumented_Bit47";
|
|
case Alarms.Undocumented_Bit48:
|
|
return "Undocumented_Bit48";
|
|
case Alarms.Undocumented_Bit49:
|
|
return "Undocumented_Bit49";
|
|
case Alarms.Undocumented_Bit50:
|
|
return "Undocumented_Bit50";
|
|
case Alarms.Undocumented_Bit51:
|
|
return "Undocumented_Bit51";
|
|
case Alarms.Undocumented_Bit52:
|
|
return "Undocumented_Bit52";
|
|
case Alarms.Undocumented_Bit53:
|
|
return "Undocumented_Bit53";
|
|
case Alarms.Undocumented_Bit54:
|
|
return "Undocumented_Bit54";
|
|
case Alarms.Undocumented_Bit55:
|
|
return "Undocumented_Bit55";
|
|
case Alarms.Undocumented_Bit56:
|
|
return "Undocumented_Bit56";
|
|
case Alarms.Undocumented_Bit57:
|
|
return "Undocumented_Bit57";
|
|
case Alarms.Undocumented_Bit58:
|
|
return "Undocumented_Bit58";
|
|
case Alarms.Undocumented_Bit59:
|
|
return "Undocumented_Bit59";
|
|
case Alarms.Undocumented_Bit60:
|
|
return "Undocumented_Bit60";
|
|
case Alarms.Undocumented_Bit61:
|
|
return "Undocumented_Bit61";
|
|
case Alarms.Undocumented_Bit62:
|
|
return "Undocumented_Bit62";
|
|
case Alarms.Undocumented_Bit63:
|
|
return "Undocumented_Bit63";
|
|
default:
|
|
return "UNKNOWN";
|
|
}
|
|
}
|
|
|
|
export enum IoStatus {
|
|
NoStatus = 0,
|
|
DisconnectedFromDc = 1,
|
|
AlarmActive = 2,
|
|
VoltMeasurementAllowed = 4,
|
|
AuxRelay = 5,
|
|
RemoteState = 6,
|
|
HeaterActive = 7,
|
|
/** BatteryCold - fake */
|
|
BatteryCold = 8,
|
|
/** EocReached - fake */
|
|
EocReached = 9,
|
|
UNRECOGNIZED = -1,
|
|
}
|
|
|
|
export function ioStatusFromJSON(object: any): IoStatus {
|
|
switch (object) {
|
|
case 0:
|
|
case "NoStatus":
|
|
return IoStatus.NoStatus;
|
|
case 1:
|
|
case "DisconnectedFromDc":
|
|
return IoStatus.DisconnectedFromDc;
|
|
case 2:
|
|
case "AlarmActive":
|
|
return IoStatus.AlarmActive;
|
|
case 4:
|
|
case "VoltMeasurementAllowed":
|
|
return IoStatus.VoltMeasurementAllowed;
|
|
case 5:
|
|
case "AuxRelay":
|
|
return IoStatus.AuxRelay;
|
|
case 6:
|
|
case "RemoteState":
|
|
return IoStatus.RemoteState;
|
|
case 7:
|
|
case "HeaterActive":
|
|
return IoStatus.HeaterActive;
|
|
case 8:
|
|
case "BatteryCold":
|
|
return IoStatus.BatteryCold;
|
|
case 9:
|
|
case "EocReached":
|
|
return IoStatus.EocReached;
|
|
case -1:
|
|
case "UNRECOGNIZED":
|
|
default:
|
|
return IoStatus.UNRECOGNIZED;
|
|
}
|
|
}
|
|
|
|
export function ioStatusToJSON(object: IoStatus): string {
|
|
switch (object) {
|
|
case IoStatus.NoStatus:
|
|
return "NoStatus";
|
|
case IoStatus.DisconnectedFromDc:
|
|
return "DisconnectedFromDc";
|
|
case IoStatus.AlarmActive:
|
|
return "AlarmActive";
|
|
case IoStatus.VoltMeasurementAllowed:
|
|
return "VoltMeasurementAllowed";
|
|
case IoStatus.AuxRelay:
|
|
return "AuxRelay";
|
|
case IoStatus.RemoteState:
|
|
return "RemoteState";
|
|
case IoStatus.HeaterActive:
|
|
return "HeaterActive";
|
|
case IoStatus.BatteryCold:
|
|
return "BatteryCold";
|
|
case IoStatus.EocReached:
|
|
return "EocReached";
|
|
default:
|
|
return "UNKNOWN";
|
|
}
|
|
}
|
|
|
|
export enum Led {
|
|
Off = 0,
|
|
On = 1,
|
|
BlinkingSlow = 2,
|
|
BlinkingFash = 3,
|
|
UNRECOGNIZED = -1,
|
|
}
|
|
|
|
export function ledFromJSON(object: any): Led {
|
|
switch (object) {
|
|
case 0:
|
|
case "Off":
|
|
return Led.Off;
|
|
case 1:
|
|
case "On":
|
|
return Led.On;
|
|
case 2:
|
|
case "BlinkingSlow":
|
|
return Led.BlinkingSlow;
|
|
case 3:
|
|
case "BlinkingFash":
|
|
return Led.BlinkingFash;
|
|
case -1:
|
|
case "UNRECOGNIZED":
|
|
default:
|
|
return Led.UNRECOGNIZED;
|
|
}
|
|
}
|
|
|
|
export function ledToJSON(object: Led): string {
|
|
switch (object) {
|
|
case Led.Off:
|
|
return "Off";
|
|
case Led.On:
|
|
return "On";
|
|
case Led.BlinkingSlow:
|
|
return "BlinkingSlow";
|
|
case Led.BlinkingFash:
|
|
return "BlinkingFash";
|
|
default:
|
|
return "UNKNOWN";
|
|
}
|
|
}
|
|
|
|
export interface Leds {
|
|
green: Led;
|
|
amber: Led;
|
|
blue: Led;
|
|
red: Led;
|
|
}
|
|
|
|
export interface Temperatures {
|
|
board: number;
|
|
cellsCenter: number;
|
|
cellsLateral1: number;
|
|
cellsLateral2: number;
|
|
heaterPowerCenterPct: number;
|
|
heaterPowerLateralPct: number;
|
|
}
|
|
|
|
export interface BatteryStatus48TL {
|
|
nodeId: number;
|
|
soc: number;
|
|
cellsVoltage: number;
|
|
cellsCurrent: number;
|
|
busVoltage: number;
|
|
temperature: number;
|
|
leds: Leds | undefined;
|
|
temperatures: Temperatures | undefined;
|
|
warnings: Warnings[];
|
|
alarms: Alarms[];
|
|
ioStatus: IoStatus[];
|
|
}
|
|
|
|
function createBaseLeds(): Leds {
|
|
return { green: 0, amber: 0, blue: 0, red: 0 };
|
|
}
|
|
|
|
export const Leds = {
|
|
encode(message: Leds, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
|
|
if (message.green !== 0) {
|
|
writer.uint32(8).int32(message.green);
|
|
}
|
|
if (message.amber !== 0) {
|
|
writer.uint32(16).int32(message.amber);
|
|
}
|
|
if (message.blue !== 0) {
|
|
writer.uint32(24).int32(message.blue);
|
|
}
|
|
if (message.red !== 0) {
|
|
writer.uint32(32).int32(message.red);
|
|
}
|
|
return writer;
|
|
},
|
|
|
|
decode(input: _m0.Reader | Uint8Array, length?: number): Leds {
|
|
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
|
|
let end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseLeds();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.green = reader.int32() as any;
|
|
break;
|
|
case 2:
|
|
message.amber = reader.int32() as any;
|
|
break;
|
|
case 3:
|
|
message.blue = reader.int32() as any;
|
|
break;
|
|
case 4:
|
|
message.red = reader.int32() as any;
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): Leds {
|
|
return {
|
|
green: isSet(object.green) ? ledFromJSON(object.green) : 0,
|
|
amber: isSet(object.amber) ? ledFromJSON(object.amber) : 0,
|
|
blue: isSet(object.blue) ? ledFromJSON(object.blue) : 0,
|
|
red: isSet(object.red) ? ledFromJSON(object.red) : 0,
|
|
};
|
|
},
|
|
|
|
toJSON(message: Leds): unknown {
|
|
const obj: any = {};
|
|
message.green !== undefined && (obj.green = ledToJSON(message.green));
|
|
message.amber !== undefined && (obj.amber = ledToJSON(message.amber));
|
|
message.blue !== undefined && (obj.blue = ledToJSON(message.blue));
|
|
message.red !== undefined && (obj.red = ledToJSON(message.red));
|
|
return obj;
|
|
},
|
|
|
|
fromPartial<I extends Exact<DeepPartial<Leds>, I>>(object: I): Leds {
|
|
const message = createBaseLeds();
|
|
message.green = object.green ?? 0;
|
|
message.amber = object.amber ?? 0;
|
|
message.blue = object.blue ?? 0;
|
|
message.red = object.red ?? 0;
|
|
return message;
|
|
},
|
|
};
|
|
|
|
function createBaseTemperatures(): Temperatures {
|
|
return {
|
|
board: 0,
|
|
cellsCenter: 0,
|
|
cellsLateral1: 0,
|
|
cellsLateral2: 0,
|
|
heaterPowerCenterPct: 0,
|
|
heaterPowerLateralPct: 0,
|
|
};
|
|
}
|
|
|
|
export const Temperatures = {
|
|
encode(
|
|
message: Temperatures,
|
|
writer: _m0.Writer = _m0.Writer.create()
|
|
): _m0.Writer {
|
|
if (message.board !== 0) {
|
|
writer.uint32(13).float(message.board);
|
|
}
|
|
if (message.cellsCenter !== 0) {
|
|
writer.uint32(21).float(message.cellsCenter);
|
|
}
|
|
if (message.cellsLateral1 !== 0) {
|
|
writer.uint32(29).float(message.cellsLateral1);
|
|
}
|
|
if (message.cellsLateral2 !== 0) {
|
|
writer.uint32(37).float(message.cellsLateral2);
|
|
}
|
|
if (message.heaterPowerCenterPct !== 0) {
|
|
writer.uint32(45).float(message.heaterPowerCenterPct);
|
|
}
|
|
if (message.heaterPowerLateralPct !== 0) {
|
|
writer.uint32(53).float(message.heaterPowerLateralPct);
|
|
}
|
|
return writer;
|
|
},
|
|
|
|
decode(input: _m0.Reader | Uint8Array, length?: number): Temperatures {
|
|
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
|
|
let end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseTemperatures();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.board = reader.float();
|
|
break;
|
|
case 2:
|
|
message.cellsCenter = reader.float();
|
|
break;
|
|
case 3:
|
|
message.cellsLateral1 = reader.float();
|
|
break;
|
|
case 4:
|
|
message.cellsLateral2 = reader.float();
|
|
break;
|
|
case 5:
|
|
message.heaterPowerCenterPct = reader.float();
|
|
break;
|
|
case 6:
|
|
message.heaterPowerLateralPct = reader.float();
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): Temperatures {
|
|
return {
|
|
board: isSet(object.board) ? Number(object.board) : 0,
|
|
cellsCenter: isSet(object.cellsCenter) ? Number(object.cellsCenter) : 0,
|
|
cellsLateral1: isSet(object.cellsLateral1)
|
|
? Number(object.cellsLateral1)
|
|
: 0,
|
|
cellsLateral2: isSet(object.cellsLateral2)
|
|
? Number(object.cellsLateral2)
|
|
: 0,
|
|
heaterPowerCenterPct: isSet(object.heaterPowerCenterPct)
|
|
? Number(object.heaterPowerCenterPct)
|
|
: 0,
|
|
heaterPowerLateralPct: isSet(object.heaterPowerLateralPct)
|
|
? Number(object.heaterPowerLateralPct)
|
|
: 0,
|
|
};
|
|
},
|
|
|
|
toJSON(message: Temperatures): unknown {
|
|
const obj: any = {};
|
|
message.board !== undefined && (obj.board = message.board);
|
|
message.cellsCenter !== undefined &&
|
|
(obj.cellsCenter = message.cellsCenter);
|
|
message.cellsLateral1 !== undefined &&
|
|
(obj.cellsLateral1 = message.cellsLateral1);
|
|
message.cellsLateral2 !== undefined &&
|
|
(obj.cellsLateral2 = message.cellsLateral2);
|
|
message.heaterPowerCenterPct !== undefined &&
|
|
(obj.heaterPowerCenterPct = message.heaterPowerCenterPct);
|
|
message.heaterPowerLateralPct !== undefined &&
|
|
(obj.heaterPowerLateralPct = message.heaterPowerLateralPct);
|
|
return obj;
|
|
},
|
|
|
|
fromPartial<I extends Exact<DeepPartial<Temperatures>, I>>(
|
|
object: I
|
|
): Temperatures {
|
|
const message = createBaseTemperatures();
|
|
message.board = object.board ?? 0;
|
|
message.cellsCenter = object.cellsCenter ?? 0;
|
|
message.cellsLateral1 = object.cellsLateral1 ?? 0;
|
|
message.cellsLateral2 = object.cellsLateral2 ?? 0;
|
|
message.heaterPowerCenterPct = object.heaterPowerCenterPct ?? 0;
|
|
message.heaterPowerLateralPct = object.heaterPowerLateralPct ?? 0;
|
|
return message;
|
|
},
|
|
};
|
|
|
|
function createBaseBatteryStatus48TL(): BatteryStatus48TL {
|
|
return {
|
|
nodeId: 0,
|
|
soc: 0,
|
|
cellsVoltage: 0,
|
|
cellsCurrent: 0,
|
|
busVoltage: 0,
|
|
temperature: 0,
|
|
leds: undefined,
|
|
temperatures: undefined,
|
|
warnings: [],
|
|
alarms: [],
|
|
ioStatus: [],
|
|
};
|
|
}
|
|
|
|
export const BatteryStatus48TL = {
|
|
encode(
|
|
message: BatteryStatus48TL,
|
|
writer: _m0.Writer = _m0.Writer.create()
|
|
): _m0.Writer {
|
|
if (message.nodeId !== 0) {
|
|
writer.uint32(8).int32(message.nodeId);
|
|
}
|
|
if (message.soc !== 0) {
|
|
writer.uint32(21).float(message.soc);
|
|
}
|
|
if (message.cellsVoltage !== 0) {
|
|
writer.uint32(29).float(message.cellsVoltage);
|
|
}
|
|
if (message.cellsCurrent !== 0) {
|
|
writer.uint32(37).float(message.cellsCurrent);
|
|
}
|
|
if (message.busVoltage !== 0) {
|
|
writer.uint32(45).float(message.busVoltage);
|
|
}
|
|
if (message.temperature !== 0) {
|
|
writer.uint32(53).float(message.temperature);
|
|
}
|
|
if (message.leds !== undefined) {
|
|
Leds.encode(message.leds, writer.uint32(58).fork()).ldelim();
|
|
}
|
|
if (message.temperatures !== undefined) {
|
|
Temperatures.encode(
|
|
message.temperatures,
|
|
writer.uint32(66).fork()
|
|
).ldelim();
|
|
}
|
|
writer.uint32(74).fork();
|
|
for (const v of message.warnings) {
|
|
writer.int32(v);
|
|
}
|
|
writer.ldelim();
|
|
writer.uint32(82).fork();
|
|
for (const v of message.alarms) {
|
|
writer.int32(v);
|
|
}
|
|
writer.ldelim();
|
|
writer.uint32(90).fork();
|
|
for (const v of message.ioStatus) {
|
|
writer.int32(v);
|
|
}
|
|
writer.ldelim();
|
|
return writer;
|
|
},
|
|
|
|
decode(input: _m0.Reader | Uint8Array, length?: number): BatteryStatus48TL {
|
|
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
|
|
let end = length === undefined ? reader.len : reader.pos + length;
|
|
const message = createBaseBatteryStatus48TL();
|
|
while (reader.pos < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.nodeId = reader.int32();
|
|
break;
|
|
case 2:
|
|
message.soc = reader.float();
|
|
break;
|
|
case 3:
|
|
message.cellsVoltage = reader.float();
|
|
break;
|
|
case 4:
|
|
message.cellsCurrent = reader.float();
|
|
break;
|
|
case 5:
|
|
message.busVoltage = reader.float();
|
|
break;
|
|
case 6:
|
|
message.temperature = reader.float();
|
|
break;
|
|
case 7:
|
|
message.leds = Leds.decode(reader, reader.uint32());
|
|
break;
|
|
case 8:
|
|
message.temperatures = Temperatures.decode(reader, reader.uint32());
|
|
break;
|
|
case 9:
|
|
if ((tag & 7) === 2) {
|
|
const end2 = reader.uint32() + reader.pos;
|
|
while (reader.pos < end2) {
|
|
message.warnings.push(reader.int32() as any);
|
|
}
|
|
} else {
|
|
message.warnings.push(reader.int32() as any);
|
|
}
|
|
break;
|
|
case 10:
|
|
if ((tag & 7) === 2) {
|
|
const end2 = reader.uint32() + reader.pos;
|
|
while (reader.pos < end2) {
|
|
message.alarms.push(reader.int32() as any);
|
|
}
|
|
} else {
|
|
message.alarms.push(reader.int32() as any);
|
|
}
|
|
break;
|
|
case 11:
|
|
if ((tag & 7) === 2) {
|
|
const end2 = reader.uint32() + reader.pos;
|
|
while (reader.pos < end2) {
|
|
message.ioStatus.push(reader.int32() as any);
|
|
}
|
|
} else {
|
|
message.ioStatus.push(reader.int32() as any);
|
|
}
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
},
|
|
|
|
fromJSON(object: any): BatteryStatus48TL {
|
|
return {
|
|
nodeId: isSet(object.nodeId) ? Number(object.nodeId) : 0,
|
|
soc: isSet(object.soc) ? Number(object.soc) : 0,
|
|
cellsVoltage: isSet(object.cellsVoltage)
|
|
? Number(object.cellsVoltage)
|
|
: 0,
|
|
cellsCurrent: isSet(object.cellsCurrent)
|
|
? Number(object.cellsCurrent)
|
|
: 0,
|
|
busVoltage: isSet(object.busVoltage) ? Number(object.busVoltage) : 0,
|
|
temperature: isSet(object.temperature) ? Number(object.temperature) : 0,
|
|
leds: isSet(object.leds) ? Leds.fromJSON(object.leds) : undefined,
|
|
temperatures: isSet(object.temperatures)
|
|
? Temperatures.fromJSON(object.temperatures)
|
|
: undefined,
|
|
warnings: Array.isArray(object?.warnings)
|
|
? object.warnings.map((e: any) => warningsFromJSON(e))
|
|
: [],
|
|
alarms: Array.isArray(object?.alarms)
|
|
? object.alarms.map((e: any) => alarmsFromJSON(e))
|
|
: [],
|
|
ioStatus: Array.isArray(object?.ioStatus)
|
|
? object.ioStatus.map((e: any) => ioStatusFromJSON(e))
|
|
: [],
|
|
};
|
|
},
|
|
|
|
toJSON(message: BatteryStatus48TL): unknown {
|
|
const obj: any = {};
|
|
message.nodeId !== undefined && (obj.nodeId = Math.round(message.nodeId));
|
|
message.soc !== undefined && (obj.soc = message.soc);
|
|
message.cellsVoltage !== undefined &&
|
|
(obj.cellsVoltage = message.cellsVoltage);
|
|
message.cellsCurrent !== undefined &&
|
|
(obj.cellsCurrent = message.cellsCurrent);
|
|
message.busVoltage !== undefined && (obj.busVoltage = message.busVoltage);
|
|
message.temperature !== undefined &&
|
|
(obj.temperature = message.temperature);
|
|
message.leds !== undefined &&
|
|
(obj.leds = message.leds ? Leds.toJSON(message.leds) : undefined);
|
|
message.temperatures !== undefined &&
|
|
(obj.temperatures = message.temperatures
|
|
? Temperatures.toJSON(message.temperatures)
|
|
: undefined);
|
|
if (message.warnings) {
|
|
obj.warnings = message.warnings.map((e) => warningsToJSON(e));
|
|
} else {
|
|
obj.warnings = [];
|
|
}
|
|
if (message.alarms) {
|
|
obj.alarms = message.alarms.map((e) => alarmsToJSON(e));
|
|
} else {
|
|
obj.alarms = [];
|
|
}
|
|
if (message.ioStatus) {
|
|
obj.ioStatus = message.ioStatus.map((e) => ioStatusToJSON(e));
|
|
} else {
|
|
obj.ioStatus = [];
|
|
}
|
|
return obj;
|
|
},
|
|
|
|
fromPartial<I extends Exact<DeepPartial<BatteryStatus48TL>, I>>(
|
|
object: I
|
|
): BatteryStatus48TL {
|
|
const message = createBaseBatteryStatus48TL();
|
|
message.nodeId = object.nodeId ?? 0;
|
|
message.soc = object.soc ?? 0;
|
|
message.cellsVoltage = object.cellsVoltage ?? 0;
|
|
message.cellsCurrent = object.cellsCurrent ?? 0;
|
|
message.busVoltage = object.busVoltage ?? 0;
|
|
message.temperature = object.temperature ?? 0;
|
|
message.leds =
|
|
object.leds !== undefined && object.leds !== null
|
|
? Leds.fromPartial(object.leds)
|
|
: undefined;
|
|
message.temperatures =
|
|
object.temperatures !== undefined && object.temperatures !== null
|
|
? Temperatures.fromPartial(object.temperatures)
|
|
: undefined;
|
|
message.warnings = object.warnings?.map((e) => e) || [];
|
|
message.alarms = object.alarms?.map((e) => e) || [];
|
|
message.ioStatus = object.ioStatus?.map((e) => e) || [];
|
|
return message;
|
|
},
|
|
};
|
|
|
|
type Builtin =
|
|
| Date
|
|
| Function
|
|
| Uint8Array
|
|
| string
|
|
| number
|
|
| boolean
|
|
| undefined;
|
|
|
|
export type DeepPartial<T> = T extends Builtin
|
|
? T
|
|
: T extends Array<infer U>
|
|
? Array<DeepPartial<U>>
|
|
: T extends ReadonlyArray<infer U>
|
|
? ReadonlyArray<DeepPartial<U>>
|
|
: T extends {}
|
|
? { [K in keyof T]?: DeepPartial<T[K]> }
|
|
: Partial<T>;
|
|
|
|
type KeysOfUnion<T> = T extends T ? keyof T : never;
|
|
export type Exact<P, I extends P> = P extends Builtin
|
|
? P
|
|
: P & { [K in keyof P]: Exact<P[K], I[K]> } & Record<
|
|
Exclude<keyof I, KeysOfUnion<P>>,
|
|
never
|
|
>;
|
|
|
|
if (_m0.util.Long !== Long) {
|
|
_m0.util.Long = Long as any;
|
|
_m0.configure();
|
|
}
|
|
|
|
function isSet(value: any): boolean {
|
|
return value !== null && value !== undefined;
|
|
}
|